settings | Simple key-value storage package for @ Laravel | Key Value Database library

Put everything in an object.

This way the 2 defs that depends on each other will be available at the same time.

IntelliJ worksheets do not like such definitions as they are "evaluated" one by one. You cannot define 2 depending on one the other at the top-level, they need to be encapsulated.

The problem is simple: QWidgets are hidden by default so isVisible() will return false, the solution is to invoke the show() method in init() to make it visible:

After doing some tests I found that this problem can be solved fairly easily. To fix/go around this issue,

• Go to the location of the bundled package that is listed in the error. There will be a bunch of .tgz files.
• Copy the .tgz file that is showing in the error message (in this instance it is com.unity.adaptiveperformance-2.1.1.tgz).
• Navigate then to: C:\Users\\AppData\Local\Unity\cache\npm\packages.unity.com
• Make a folder in this directory named without the version number and extension (folder name in this instance would be com.unity.adaptiveperformance).
• Enter this folder and create a sub-folder with the given version number (this instance 2.1.1).
• Paste the .tgz file that you copied before into this folder and rename it package.tgz.
• Open the .tgz file or extract the file to the version number folder you created. Image of final directory path and files

My understanding of this problem is that after syncing data between my main computer and my laptop made it to where the package data would be regenerated on my laptop. When this occurred, my laptop would not be able to extract a given package from unity's compressed packages for the editor. This caused me to have to manually extract that given package into the unity cache. (Note: syncing was done through onedrive)

After you have added the file, close and relaunch the unity project and it should pass this error without issue. I thought I should post this issue and the solution I found for others that may find themselves with this same issue.

You can turn off any specific rule like so:

Pythons multiprocessing package is limited to shared memory parallelization. It spawns new processes that all have access to the main memory of a single machine.

You cannot simply scale out such a software onto multiple nodes. As the different machines do not have a shared memory that they can access.

To run your program on multiple nodes at once, you should have a look into MPI (Message Passing Interface). There is also a python package for that.

Depending on your task, it may also be suitable to run the program 4 times (so one job per node) and have it work on a subset of the data. It is often the simpler approach, but not always possible.

a) Even if obviously it could be better, is this solution is acceptable or not at all ?

I think it has some problems you want to address, but the general idea of using the filesystem and storing just filenames can be acceptable, depending on how many users you need to serve and what guarantees regarding data consistency and concurrent accesses you want to make.

I would consider the uploaded file temporary data that may be lost on system failure. If you want to provide any guarantees of not losing the data, you want to store it in a database instead of on the filesystem.

b) I pass 'uploaded_file' from one view to another using "request.session" is it a good practice? Is there another way to do it without using GET variables?

There are up- and downsides to using request.session.

• attackers can not change the filename and thus retrieve data of other users. This is also the reason why you should not use a GET parameter here: If you used one, attackers could simpy change that parameter and get access to files of other users.
• users can upload a file, go and do other stuff, and later come back to actually import the file, however:
• if users end their session, you lose the filename. Also, users can not upload the file on one device, change to another device, and then go on with the import, since the other device will have a different session.

The last point correlates with the leftover files problem: If you lose your information about which files are still needed, it makes cleaning up harder (although, in theory, you can retrieve which files are still needed from the session store).

If it is a problem that sessions might end or change because users clear their cookies or change devices, you could consider adding the filename to the UserProfile in the database. This way, it is not bound to sessions.

c) At first my wish was to avoid to save the csv-file. But I could not figure out how to do it? Reading all the file to request.session seems not a good idea for me. Is there some possibility to upload the file into memory in Django?

You want to store state. The go-to ways of storing state are the database or a session store. You could load the whole CSVFile and put it into the database as text. Whether this is acceptable depends on your databases ability to handle large, unstructured data. Traditional databases were not originally built for that, however, most of them can handle small binary files pretty well nowadays. A database could give you advantages like ACID guarantees where concurrent writes to the same file on the file system will likely break the file. See this discussion on the dba stackexchange

Your database likely has documentation on the topic, e.g. there is this page about binary data in postgres.

d) If I have to use the tmp-file. How should I handle the situation if user abandon upload at the middle (for example, he sees the confirmation page, but does not click "yes" and decide to re-write his file). How to remove the tmp-file?

Some ideas:

• Limit the count of uploaded files per user to one by design. Currently, your filename is based on a timestamp. This breaks if two users simultaneously decide to upload a file: They will both get the same timestamp, and the file on disk may be corrupted. If you instead use the user's primary key, this guarantees that you have at most one file per user. If they later upload another file, their old file will be overwritten. If your user count is small enough that you can store one leftover file per user, you don't need additional cleaning. However, if the same user simultaneusly uploads two files, this still breaks.
• Use a unique identifier, like a UUID, and delete the old stored file whenever the user uploads a new file. This requires you to still have the old filename, so session storage can not be used with this. You will still always have the last file of the user in the filesystem.
• Use a unique identifier for the filename and set some arbitrary maximum storage duration. Set up a cronjob or similar that regularly goes through the files and deletes all files that have been stored longer than your specified maximum duration. If a user uploads a file, but does not do the actual import soon enough, their data is deleted, and they would have to do the upload again. Here, your code has to handle the case that the file with the stored filename does not exist anymore (and may even be deleted while you are reading the file).

You probably want to limit your server to one file stored per user so that attackers can not fill your filesystem.

e) Small additional question : what kind of checks there are in Django about uploaded file? For example, how could I check that the file is at least a text-file? Should I do it?

You definitely want to set up some maximum file size for the file, as described e.g. here. You could limit the allowed file extensions, but that would only be a usability thing. Attackers could also give you garbage data with any accepted extension.

Keep in mind: If you only store the csv as text data that you load and parse everytime a certain view is accessed, this can be an easy way for attackers to exhaust your servers, giving them an easy DoS attack.

Overall, it depends on what guarantees you want to make, how many users you have and how trustworthy they are. If users might be malicious, you want to keep all possible kinds of data extraction and resource exhaustion attacks in mind. The filesystem will not scale out (at least not as easily as a database).

I know of a similar setup in a project where only a handful of priviliged users are allowed to upload stuff, and we can tolerate deletion of all temporary files on failure. Users will simply have to reupload their files. This works fine.

Apparently all you have to do is to close out the file. It seems to only show when the file is opened.

Perhaps a later version of Visual Studio can make this warning behave more consistently with a standard warning in VS. Really it behaves very much like a refactoring / code cleanup suggestion (which commonly has a grey, squiggly line), rather than an actual warning. It's like it's just been mislabeled in development or whatever. However the good thing is that as long as the file is closed, it doesn't pollute the build or the errors window with warning messages.

The solution lies in the federated identity pool's settings.

By default the identity pool will provide the IAM role that it's configured with. In other words, one of either the "unauthenticated role" or the "authenticated role" that it's set up with.

But it can be told instead to provide a role specified by the authentication provider. That's what will solve the problem here.

1. In the AWS console, in Cognito, open the relevant identity pool.
2. Click "Edit identity pool" (top right)
3. Expand "Authentication Providers"
4. Under Authenticated Role Selection, choose "Choose role from token".

That will allow Cognito to specify its own roles, and you will find that the users get the privileges of their group.