fastapi | 基于Fastapi开发，集成Celery-redis分布式任务队列、JWT | SQL Database library

The SpaCy tokenizer seems to cache each token in a map internally. Consequently, each new token increases the size of that map. Over time, more and more new tokens inevitably occur (although with decreasing speed, following Zipf's law). At some point, after having processed large numbers of texts, the token map will thus outgrow the available memory. With a large amount of available memory, of course this can be delayed for a very long time.

The solution I have chosen is to store the SpaCy model in a TTLCache and to reload it every hour, emptying the token map. This adds some extra computational cost for reloading the SpaCy model from, but that is almost negligible.

If your use case is just to serve a single user, and is not mission-critical, this might be a good way to start.

main.py

A possible and promising approach is to generate the Pydantic model starting from the corresponding JSON Schema of the STIX object.

Luckily enough the JSON schemas for all the STIX 2 objects have been defined by the OASIS Open organization on the GitHub repository CTI-STIX2-JSON-Schemas.

In particular, the JSON Schema for the Attack-Pattern is available here.

You can make optional fields required in subclasses, but you cannot make required fields optional in subclasses. In fastapi author tiangolo's boilerplate projects, he utilizes a pattern like this for your example:

The question then is, how do we get the workers to share and operate on the same object?

While you could share objects via something like multiprocessing, in your use case you're probably better off using a cache, like Redis.

I'm no expert at all in parallel/concurrent applications, but I do know that unless you need to speed up really expensive CPU-bound operations (i.e. very complex and/or long runnning calculations), you DO NOT want to share objects between processes.

You CAN do that, via dedicated libraries and modules, however it will make your app significantly more complex, having to handle all the possible race conditions and edge cases intrinsic with parallelism. If you do want to go that route, I'm sure there are plenty of libraries and tools, but you should first take a look at multiprocessing, the standard python library for handling parallelism. Check also this and this about using it to share resources among workers with gunicorn.

On the other hand, your use case doesn't look like it requires very complex calculations, so I would suggest to use a simple cache to act as the "data hub" for your workers, instead of a class. It will give you the desired result of having a single source of truth for your processes without the complexities of shared memory.

If you want to give this approach a try, I suggest to give a look at Redis which is a very popular and well supported solution for a cache and can even persist the data if you want.

Here's a list of Redis clients for python. redis-py is the recommended one.

As a side question, the problem above affects the /reset endpoint too. If this endpoint is called then only one of the workers will reset its object. Is there a way to force all workers to respond to a single call on an endpoint?

If you use a cache the problem disappears. You only have a single source of truth and you just erase the data there, with whichever worker responds to the request. Then every worker will see the data has been reset.

You can iterate it via data.__root__

You can try using prefetch_related()

For example:

Heroku's filesystem is ephemeral/short lived. This means that any images you save locally will disappear after you redeploy your app. You can't rely on Heroku's filesystem to store images that need to persist for a longer time.

For saving images, have a look at 3rd party storage solutions such as Cloudinary or AWS S3.

TemplateResponse return a starlette.responses.Response, not a renderer template .

For that, you need to use