limiter | Dead simple rate limit middleware for Go | Runtime Evironment library

I think you need to write code [ return response('Custom response...', 429); ] in functions.

I'm reticent to take a stab at answering this for real without knowing what's going on in color_table. My hunch, based on the behavior you're describing is that filter_json_run_all is being forced to wait on a congested DOM manipulation/render pipeline as HTML is being updated to achieve the color-coding for your updated table elements.

I see you're already taking some measures to prevent some of these DOM manipulations from blocking this function's execution (via setTimeout). If color_table isn't already employing a similar strategy, that'd be the first thing I'd focus on refactoring to unclog things here.

It might also be worth throwing these DOM updates for processed events into a simple queue, so that if slow browser behavior creates a rendering backlog, the function actually responsible for invoking pending DOM manipulations can elect to skip outdated render operations to keep the UI acceptably snappy.

Edit: a basic queueing system might involve the following components:

1. The queue, itself (this can be a simple array, it just needs to be accessible to both of the components below).
2. A queue appender, which runs during filter_json_run_all, simply adding objects to the end of the queue representing each DOM manipulation job you plan to complete using color_table or one of your setTimeout` callbacks. These objects should contain the operation to performed (i.e: the function definition, uninvoked), and the parameters for that operation (i.e: the arguments you're passing into each function).
3. A queue runner, which runs on its own interval, and invokes pending DOM manipulation tasks from the front of the queue, removing them as it goes. Since this operation has access to all of the objects in the queue, it can also take steps to optimize/combine similar operations to minimize the amount of repainting it's asking the browser to do before subsequent code can be executed. For example, if you've got several color_table operations that coloring the same cell multiple times, you can simply perform this operation once with the data from the last color_table item in the queue involving that cell. Additionally, you can further optimize your interaction with the DOM by invoking the aggregated DOM manipulation operations, themselves, inside a requestAnimationFrame callback, which will ensure that scheduled reflows/repaints happen only when the browser is ready, and is preferable from a performance perspective to DOM manipulation queueing via setTimeout/setInterval.

I would propose to take a look in the RateLimiter direction. Maybe it does not work as expected, depending on the number of requests your application does over time. From the Javadoc for Ratelimiter: "It is important to note that the number of permits requested never affects the throttling of the request itself ... but it affects the throttling of the next request. I.e., if an expensive task arrives at an idle RateLimiter, it will be granted immediately, but it is the next request that will experience extra throttling, thus paying for the cost of the expensive task." Also helpful might be this discussion: github or github

I could imaginge there is some throttling adding up or other effect in the RateLimiter, i would try to play around with it and make sure this thing really works the way you want. Alternatively, consider using Spring @Scheduled to read from your queue. You might want to spice it up using embedded JMS for further goodies (message persistence etc).

Fwiw, I'm curious to know the same thing: if there's a way to avoid the $_ replacement or preserve or access the prior value in the exception context.

That said, I do know you can work around it by assigning $_ to a new variable as the first line of the loop:

I could not figure out what the point of the intermediate MySchemaNames table is. I would just use a cursor -

1. Create dictionary in global namespace for storing cancel scope and event (key: UUID, val: Tuple[trio.CancelScope, trio.Event]
2. Assign every client with unique UUID (Anything that is unique to client)
3. Let client send UUID at start of connection
4. Check if dictionary has that UUID as key. If exist, cancel the scope and wait for event to be set.
5. Now do the actual transmission

Websocket doesn't know if client disconnected or not if client doesn't close websocket explicitly. Therefore best bet I can think of is enforcing Timeout and waiting for client's response on every transmission. (Which makes this method a bit less efficient).

Below is demonstrational code of above ideas.

Since I don't know how client code looks like, I just made some client for testing your concerns.

This is a bit buggy, but I didn't learned js - Please don't judge client code too seriously!

I decided to ultimately go with websockets rather than SSE, as I realised I needed to pass an object as data to my endpoint, and while SEE can accept query params, dealing with objects as query parameters was too much of a hassle.

websockets with FastAPI are based on starlette, and are pretty easy to use, implementing them to the problem above can be done like so:

You should do it all with one yq call, passing the external values as variables; that will make the code safer and faster:

You are trying to use nullish coalescing (??) on an unsuported version of Node. Nullish coalescing is supported from Node v14 and up.
For now the simple alternative is ||, unless you upgrade your version.