overkill | desktop app for checking VALORANT shop

It's possible to access public fields of Sequence by casting the elements of serializedObject.targetObjects in your editor script. You can also use serializedObject.targetObject or Editor.target if you aren't using [CanEditMultipleObjects].

Yes, you can show a tooltip for your nodes that you have drawn on the drawing surface. To do so, you need to do the followings:

• Implement hit-testing for your node, so you can get the node under the mouse position.
• Create a timer and In mouse move event handler of the drawing surface, do hit-testing to find the hot item. If the hot node is not same as the current hot node, you stop the timer, otherwise, if there's a new hot item you start the timer.
• In the timer tick event handler, check if there's a hot item, show the tooltip and stop the time.
• In the mouse leave event of the drawing surface, stop the timer.

And here is the result, which shows tooltip for some points in a drawing:

The above algorithm, is being used in internal logic of ToolStrip control to show tooltip for the tool strip items (which are not control). So without wasting a lot of windows handle, and using a single parent control and a single tooltip, you can show tooltip for as many nodes as you want.

Code Example - Show Tooltip for some points in a drawing

Here is the drawing surface:

tags with unmatched media queries are download with low priority so that they don't block page rendering, but are still downloaded in order to be available in case media properties change (for example by rotating a smartphone or by zooming out a desktop browser). There is an advantage in having separate stylesheets for different media types, but there is also a disadvantage in creating multiple HTTP requests.

Media blocks inside a stylesheet are already downloaded and I would assume that they are compiled anyway, so it's not really the same as a media query in the tag. But if a certain set of rules is only relevant to a certain width and is always overriden in wider screens, it makes sense to tell the browser that by encapsulating it inside a media query. It's not just about the original page rendering but about any change to the window or to the DOM that requires a redraw - the less rules the browser would need to evaluate, the faster it would be.

I could imagine the standard bi-directional association using @OneToMany being a maintainable yet performant solution.

To mitigate n+1 selects, one could use e.g.:

• @EntityGraph, to specify which associated data is to be loaded (e.g. one user with all of it's posts and all associated votes within one single select query)
• Hibernates @BatchSize, e.g. to load votes for multiple posts at once when iterating over all posts of a user, instead having one query for each collection of votes of each post

When it comes to restricting users to perform accesses in less performant ways, I'd argue that it should be up the API to document possible performance impacts and offer performant alternatives for different use-cases.

(As a user of an API one might always find ways to implement things in the least performant fashion:)

Since you refer to bash, you can use the bash specific format character "q" in printf:

Since you're using a data class, areContentsTheSame() can be simplified to simply do an equality check:

Use Index.isin with inverted mask by ~ in boolean indexing:

Try to replace this:

Of course generally there is no way to directly modify some existing code you didn't write yourself (whether or not it's "installed" is not the issue).

If you think it's really of general use or interest you could propose a patch to allow this function to take, e.g., a callback function to call on each loop. It might be useful if it's a slow function in general (I did notice some things in the implementation that could be changed to speed it up, but that's another matter).

You could of course find a number of clever hacks to make it work in this one specific case, though it would be fragile considering that it's a hack designed specifically to the implementation details of this function. I found a few possibilities for this.

The simplest seems to be this stupid trick:

Make an ndarray subclass (I called it tqdm_array) which when iterated in Python returns an iterator over a tqdm progress bar which wraps the array itself: