decorators | loading decorators into your Rails application | Architecture library

It is a bug, you can downgrade using:

pip install "pip<22"

https://github.com/jazzband/pip-tools/issues/1558

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:

Since 5.0, passenger will "helpfully" add cache-control headers to responses it deems 'cachable'.

In order to stop this, your application should add the header Cache-Control: no-store.

To do this globally in Flask as described here:

This is an issue from a new edition of web3.py.

You need to add gasPrice to your transaction, like so:

What about this? It is shorter than the full signature:

I installed this package: https://www.npmjs.com/package/i18next-http-backend

And then in my i18n.js file, I add the backend.

Okey as suggested by VLAZ:

Private fields in JS are completely private and inaccessible to anything from outside. Thus it makes sense they cannot be decorated - there is no way for the decorator to access them.

This is completely correct, so when I took a closer look at the value object I realized that it does have public get properties, so by testing it is possible to use decorators on those properties.

Leaving something like:

This is one of the main challenges when working with SSR. So there's a process called Hydration that happens on the client after receiving the response with static HTML from the server. (you could read more on this Vue SSR guide)

Because of the way Nuxt is built and how the SSR/Client relationship works for hydration, what might happen is your server rendering an snapshot of your app, but the async data not being available before the client mounts the app, causing it to render a different store state, breaking the hydration.

The fact frameworks like Nuxt and Next (for React) implement their own components for Auth, and many others, is to deal with the manual conciliation process for correct hydration.

So going deeper on how to fix that without using Nuxt built-in auth module, there are a few things you could be aware of:

1. There the serverPrefetch method, that will be called on the Server-side which will wait until the promise is resolved before sending to the client to render it
2. Besides the component rendering, there's the context sent by the server to the client, which can be injected using the rendered hook, that's called when the app finishes the rendering, so the right moment to send your store state back to the client to reuse it during hydration process
3. On the store itself, if you're using registerModule, it supports an attribute preserveState, that's responsible for keeping the state injected by the server.

For the examples on how to work those parts, you could check the code on this page

Last, more related to your user auth challenge, another option would be to use nuxtServerInit on store actions to run this auth processing, since it'll be passed directly to the client afterwards, as described on Nuxt docs.

On the same page, the docs present that the first argument on the nextServerInit is the context, meaning you could get the store, for instance, from there.

Also one important point to mention, is that on your original question, you've mentioned that you don't want 3rd party libs, but you're already using one that brings a lot of complexity to the table, namely the nuxt-property-decorator. So not only you're dealing with SSR that's as complicated as it gets when using frameworks, but you're not using pure Vue, but Next, and not using pure TS Nuxt, but adding another complexity with decorators for the store.

Why am I mentioning it? Because taking a quick look on the lib issues, there are other people with the same issue of not accessing the this correctly.

Coming from a background of someone that used both Nuxt (Vue) and Next (React), my suggestion with you is to try to reduce the complexity, before trying out a lot of different stuff. So I'd test running your app without this nuxt-property-decorator to check if this works with the out-of-the-box store implementation, ensuring it's not a bug caused on the lib not fully prepared to support SSR complexity.

Class-Validator works based on classes. Request payloads that come into the server are just plain JSON objects to start off with. To change this behavir, Nest has to first call plainToClass from class-validator if you're using its ValidationPipe. Because of this, the @Transform() decorators take precedence over the the other class-validator decorators, and are acted upon first. You could get around this with using multiple pipes, or possible providing default values for the @Transform() decorator, but what is happening is the intended effect.