set-value | Set nested properties on an object using dot-notation | YAML Processing library

The object generated by your JSON string is an array of two objects:

First of all you are not using the correct key it should be a GlobalKey(), but even then the reset() would not work.

The reason for this is because of the implementation of DropdownButtonFormField:

Looking at the package.json you posted in a comment, as of this writing at least, all your issues are in dev dependencies and none are in production dependencies. You can confirm this with npm audit --omit=dev which (as of this writing) shows 0 vulnerabilities.

At this point, a valid option is to decide not to worry about any of those issues reported by npm. You are, for example, extremely unlikely to trigger a denial of service issue via glob-parent (as reported in the snippet you provide) and in the vanishingly-small likelihood that you do, it will be a "denial of service" on your own tooling while running gulp. Literally, who cares?

But if you really want to get rid of these things: uninstall gulp and check-dependencies. The former hasn't published a new version in 2 years and you're not using it in your package.json. The latter hasn't published a new version in 4 years and isn't anything you can't live without. You aren't using either of those dev dependencies in your package.json. If you were planning on using gulp, consider using grunt instead (currently, reports 0 vulnerabilities when installed) or regular npm scripts.

TL;DR:

1. You can choose to ignore these. They are all in dev dependencies, at least as of this writing.
2. If ignoring them is not what you want to do, remove gulp and check-dependencies. You are not using them anyway, at least not yet.

If you are following along with a tutorial, definitely ignore the warnings for the purposes of the tutorial or find a more up-to-date tutorial.

One of the advantages of pandas is that you can often use vectorized operations instead of loops. Thus in your case it's possible to sum over a 2-dimensional slice of the dataframe like this:

This error can appear if you're trying to use the Vue 3 composition API, but you have Vue 2 installed. Currently if you run npm install vue you'll get version 2; you need to run npm install vue@next to get version 3.

If you want to use version 2, the basic TypeScript approach for component definition is instead like this:

The documentation for plt.bar() should clear things up.

The function creates bars centered at x, each with width width (0.8 by default). So your first bar is centered at x = 0 and spans from -0.4 to 0.4. Likewise for the last one. You can change the alignment or width (smaller would make them thinner), but that's about it.

First of all, the number of cores is not necessarily the number of processors. On early computers days it was like 1-1, but with modern improvements one processor can offer more than one core. (Check this: https://www.tomshardware.com/news/cpu-core-definition,37658.html). So, if it detected 12 cores, you can use it as the basis for your calculus.

The number of processes means how many different parallel instances of your web application will be running in that server. WSGI first creates a master process that will coordinate things. Then it bootstraps your application and creates N clones of it (fork). These child forked processes are isolated, they don't share resources. If one process get's unhealthy for any reason (e.g. I/O problems), it can terminate or even be voluntarily killed by the master process while the rest of the clones keep working, so your application is still up and running. When a process is terminated/killed the master process can create another fresh clone to replace it (re-spawn).

It is OK to set the number of processes as a ratio of the available cores. But there's no benefit of increasing it too much. So, you definitely shouldn't set it to the limit (2784). Remember that the operating system will round-robin across all processes to give each one a chance of have some instructions processed. So, if it offers 12 cores and you create like 1000 different processes, you are just putting stress on the system and you'll end up getting the same throughput (or even a worse throughput since there's so much chaos).

Then we move on to the number of threads. For the sake of simplicity, let's just say that the number of threads means the number of parallel requests each of these child process can handle. While one thread is waiting for a database response to answer a request, another thread could be doing something else to answer another request.

You may say: why do I need multiple threads if I already have multiple processes?

A process is an expensive thing, but threads are just the way you can parallel the workload a process can handle. Imagine that a process is a Coffee Shop, and threads are the number of attendants you have inside. You can spread 10 different Coffee Shops units around the city. If one of them closes, there's still another 9 somewhere else the customer can go. But each shop need an amount of attendants to serve people the best way possible.

If you set just a single process with 100 threads, that means that 100 is your concurrency limit. If at some point there's 101 concurrent requests to your application, that last one will have to wait for one of the 100 first to be finished. That's when you start to get an increasing response time for some users. The more the requests are queued, the worse it gets (queuing theory).

Besides that, since you have a single process, if it crashes, all these 100 requests will fail with a server error (500). So, it's wiser to have more processes, let's say 4 processes handling 25 threads each one. You still have the 100 concurrency limit, but your application is more resilient.

It's up to you to get to know your application expected load so you can adjust these numbers properly. When you have external integrations like databases, you have to consider it's limitations also. Let's say a PostgreSQL Server that can handle 100 simultaneous connections. If you have 10 WSGI processes, 40 threads each (with a connection pool of size 40 as well), then there's the possibility that you stress the database with 400 connections, and then you have a big problem, but that's not your case!

So, just use the suggested number of processes (12 * 2 = 24) and set as much threads as needed to offer a certain desired level of concurrency.

If you don't know the expected load, I suggest you to make some sort of performance test that can simulate requests to your application and then you can experiment different loads and settings and check for it's side effects.

If you are running your application in a container orchestration platform, like Kubernetes, then you can probably have multiple balanced containers serving the same application. You can even make it dynamic so that the number of containers increases if memory or processing go beyond a threshold. That means that on top of all those WSGI fine tuning for a single server, there's also other modern layers of configurations that can help you face peaks and high load scenarios.

Found out the error was very dumb, in the statement:

TL;DR: Try npm uninstall update.

Using the package.json in the repo that you linked to and npm@7, running npm install and then npm audit reported: