reliable | Testing management suite | Continous Integration library

I am trying to install all needed modules for an existing Django project. When I run pip install -r requirements.txt I get the following errors:

Is there away to run scheduled background job on stateful service in azure service fabric ? the only way I found only was timers & reminders which they run on Actors not stateful service. I'm trying to run scheduled background job to clean up some data in Reliable dictionary.

Searching a good way to split an XML path into an array. I have the feeling my solution is not as reliable as i want.

What I have:

What I want to get is an array like: [product, containeditem, productidentifier]

My Code:

cppreference states the following on thread_local variables

The storage for the object is allocated when the thread begins and deallocated when the thread ends. Each thread has its own instance of the object. Only objects declared thread_local have this storage duration.

I think of using a thread_local static member variable declared inside a shared library that is loaded at runtime via dlopen / LoadLibrary. Since it's totally possible that there are already quite a few threads running at the timepoint this library is loaded and some of them will then access that variable later, I wonder how this works if the storage is allocated when the thread begins? If the variable does not exist in the program at the timepoint the thread is created this obviously cannot work as explained there. Furthermore it seems like a waste of resources if a process running e.g. 100 threads would create an instance of that thread local variable for each of those threads if only a few of them would actually access the variable.

So, is the documentation incorrect here or are there chances that what I'm trying here might lead to undefined behavior? If the documentation is simply incorrect, where can I find a reliable description of what can be expected in reality? In case it's implementation defined, I'm particularly interested how clang handles it on macOS and Windows.

I am implementing a Kubernetes based solution where I am autoscaling a deployment based on a dynamic metric. I am running this deployment with autoscaling capabilities against a workload for 15 minutes. During this time, pods of this deployment are created and deleted dynamically as a result of the deployment autoscaling decisions.

I am interested in saving (for later inspection) of the logs of each of the dynamically created (and potentially deleted) pods occuring in the course of the autoscaling experiment.

If the deployment has a label like app=myapp , can I run the below command to store all the logs of my deployment?

I have a set of images of numbers that go from 0 to 20 with intermediate classes(0,25 / 0,5 / 0,75). Each number will be defined as a class of its own. I have 22 images per class.

These images will be used for training and testing on a convolutional neural network for classification. I'm not worried about accuracy, it's only a proof of concept so I realise that the dataset is too small for any real reliable outcome. Like I said, it's only meant as a proof of concept.

EDIT: As suggested by @Kaveh, I checked out ImageDataGenerator.flow_from_directory

As far as I could tell, this is used to increase your dataset size using data augmentation. However, what I'm asking is, now that I have these images set in different folders (22 images per folder, each folder making a class) how do I use them. I've always been loading one file that makes up the dataset (example: mnist; through keras). I've never used my own data and therefore, have no idea what the next step is.

I have a list of emails and UTM sources that I need to perform a lookup on to return the source, but I need the formula to default to certain values if they are present. See example table below

I essentially have a state with type array that will have a desired max limit in it, lets say a limit of 5 elements in the array.

Adding to the state with elements can come slowly, or just at quick succession.

The issue, that I'm aware of doing something like this won't work:

I have a bunch of instances, each having a unique tempfile for its use (save data from memory to disk and retrieve them later).

I want to be sure that at the end of the day, all these files are removed. However, I want to leave a room for a fine-grained control of their deletion. That is, some files may be removed earlier, if needed (e.g. they are too big and not important any more).

What is the best / recommended way to achieve this?

May thoughts on that

• The try-finalize blocks or with statements are not an option, as we have many files, whose lifetime may overlap each other. Also, it hardly admits the option of finer control.

• From what I have read, __del__ is also not a feasible option, as it is not even guaranteed that it will eventually run (although, it is not entirely clear to me, what are the "risky" cases). Also (if it is still the case), the libraries may not be available when __del__ runs.

• tempfile library seems promising. However, the file is gone after just closing it, which is definitely a bummer, as I want them to be closed (when they perform no operation) to limit the number of open files.

  • The library promises that the file "will be destroyed as soon as it is closed (including an implicit close when the object is garbage collected)."

    How do they achieve the implicit close? E.g. in C# I would use a (reliable) finalizer, which __del__ is not.

• atexit library seems to be the best candidate, which can work as a reliable finalizer instead of __del__ to implement safe disposable pattern. The only problem, compared to object finalizers, is that it runs truly at-exit, which is rather inconvenient (what if the object eligible to be garbage-collected earlier?).

  • Here, the question still stands. How the library achieves that the methods always run? (Except in a really unexpected cases with which is hard to do anything)

In ideal case, it seems that a combination of __del__ and atexit library may perform best. That is, the clean-up is both at __del__ and the method registered in atexit, while repeated clean-up would be forbidden. If __del__ was called, the registered will be removed.

The only (yet crucial) problem is that __del__ won't run if a method is registered at atexit, because a reference to the object exists forever.

Thus, any suggestion, advice, useful link and so on is welcomed.