grains | Java framework generates thread-safe , versionable objects

1. Service discovery and load management happen automatically indeed. Consul is not a strong required. The only external requirement is a Membership table provider - something that is used internally by Orleans Clustering. There are many build in Membership table providers that come already built-in with Orleans. For example, Azure table storage. all you need is to configure Orleans to use it and of course have Azure storage account. Consul is another alternative to Membership table provider and there are more.

Another thing that does not come built-in is infrastructure scaling. If your service demand increases, something need to ask the infrastructure provider (Cloud Provider) to add more Servers. Once servers are added, Orleans will automatically adjust the workload and load balance across the new servers as well. But figuring out that more servers are needed and adding them is not done by Orleans itself (there likely some externally contributed tools to do that. maybe K8 can be configured to do that? I am not completely sure about that).

1. Yes, you can use those 2 grains as in-memory storage, just like you wrote. And no, you do not need to use locks. All grains are single threaded.

Here is a concrete example based on @Waldi 's comment:

You could take a simple single loop approach without recursion, but with an object for keeping all nodes.

Your lighting is not good, as HansHirse suggested, try normalizing the conditions in which you take your photos. There's, however, a method that can somewhat normalize the lighting and get it as uniform as possible. The method is called gain division. The idea is that you try to build a model of the background and then weight each input pixel by that model. The output gain should be relatively constant during most of the image. Let's give it a try:

I'm pretty sure this has to do with the dreaded "denominator degrees of freedom" question, i.e. what kind (if any) of finite-sample correction is being employed. tl;dr emmeans is using a Kenward-Roger correction, which is more or less the most accurate available option — the only reason not to use K-R is if you have a large data set for which it becomes unbearably slow.

Using the output of cmd.run into a grains.set command might not work in the same step as there is no Jinja context available. That said, a good way to add custom grains in Saltstack is by putting them in /etc/salt/grains file.

This file can be updated with key value pairs in YAML format. One way to update it with command:

full/grains?name_product=rice where you are using grains? so do you have any .htaccess file, if it exist then you can use like

This error is happening because of sending large objects to redis. merged_df is a large dataframe and since you are calling get_meal_category 10 times, Ray will attempt to serialize merged_df 10 times. Instead if you put merged_df into the Ray object store just once, and then pass along a reference to the object, this should work.

EDIT: Since the classifier is also large, do something similar for that as well.

Can you try something like this:

If I understand properly what you mean, then conceptually, in the TimeGrain class, I would keep a (custom) shadow variable keeping (only) the count of Break instances that are overlapping that TimeGrain (instance). Let me call it breakCount for simplicity. Let me call x the number of TimeGrains a Break spans.

So, upon the solver assigning a Break instance to a TimeGrain instance, I would increment that TimeGrain instance's breakCount. Not only thát TimeGrain instance's breakCount, but also the breakCount of the next few (x-1) TimeGrain instances. Beware to wrap each of those incrementations in a "scoreDirector.beforeVariableChanged()"-"scoreDirector.afterVariableChanged()" bracket.

The score calculation would do the rest. But do note that I myself would moreover also square the difference of a TimeGrain's ideal breakCount and it's "real" breakCount (i.e. the shadow variable), like explained in OptaPlanner's documentation, in order to enforce more "fairness".

Edit : of course also decrement a TimeGrain's breakCount upon removing a Break instance from a Timegrain instance...