golden | Package golden testing with golden file

I have a dataframe like this;

Consider the following code snippet:

Having created a Windows Azure VM and opened ports 3389 and 22 for inbound RDP and SSH connections, respectively.

I can successfully connect to the vm via RDP from a remote Windows PC. Testing SSH connection in the Portal succeeds. However trying to connect from a remote Linux VM using SSH fails.

Given that SSH connection test within the portal succeeds, it suggests that (1) it is possible to SSH into a windows VM; and (2) there is no other config require on the server ie installing OpenSSH (or similar) / Copying over key file(s) to some location etc. However, the help steps in the Azure Portal for my Windows VM, for making remote SSH connections suggest that maybe a public key needs to exist on the server and that I need the private key on the LinuxVM I am trying to connect from.

Please could someone help me understand if ssh into windows Azure VM is possible and if so, the requirements / minimum set of steps (on the target Windows VM and the source Linux VM) I need to get to a state that I can successfully SSH.

Other posts re similar question posted have not helped me connect via ssh. I have not found a 'golden source of truth' on Microsoft docs. Maybe I missed it.

Thank you.

Am building a movies App where i have list of posters loaded using TMDB using infinite_scroll_pagination 3.0.1+1 library. First set of data loads good but after scrolling and before loading second set of data i get the following Exception.

From this tutorial https://github.com/slouc/concurrency-in-scala-with-ce#threading async operations are divided into 3 groups and require significantly different thread pools to run on:

Non-blocking asynchronous operations:

Bounded pool with a very low number of threads (maybe even just one), with a very high priority. These threads will basically just sit idle most of the time and keep polling whether there is a new async IO notification. Time that these threads spend processing a request directly maps into application latency, so it's very important that no other work gets done in this pool apart from receiving notifications and forwarding them to the rest of the application. Bounded pool with a very low number of threads (maybe even just one), with a very high priority. These threads will basically just sit idle most of the time and keep polling whether there is a new async IO notification. Time that these threads spend processing a request directly maps into application latency, so it's very important that no other work gets done in this pool apart from receiving notifications and forwarding them to the rest of the application.

Blocking asynchronous operations:

Unbounded cached pool. Unbounded because blocking operation can (and will) block a thread for some time, and we want to be able to serve other I/O requests in the meantime. Cached because we could run out of memory by creating too many threads, so it’s important to reuse existing threads.

CPU-heavy operations:

Fixed pool in which number of threads equals the number of CPU cores. This is pretty straightforward. Back in the day the "golden rule" was number of threads = number of CPU cores + 1, but "+1" was coming from the fact that one extra thread was always reserved for I/O (as explained above, we now have separate pools for that).

In my Cats Effect application, I use Scala Future-based ReactiveMongo lib to access MongoDB, which does NOT block threads when talking with MongoDB, e.g. performs non-blocking IO.

It needs execution context. Cats effect provides default execution context IOApp.executionContext

My question is: which execution context should I use for non-blocking io?

IOApp.executionContext?

But, from IOApp.executionContext documemntation:

Provides a default ExecutionContext for the app.

The default on top of the JVM is lazily constructed as a fixed thread pool based on the number available of available CPUs (see PoolUtils).

Seems like this execution context falls into 3rd group I listed above - CPU-heavy operations (Fixed pool in which number of threads equals the number of CPU cores.), and it makes me think that IOApp.executionContext is not a good candidate for non-blocking IO.

Am I right and should I create a separate context with a fixed thread pool (1 or 2 threads) for non-blocking IO (so it will fall into the first group I listed above - Non-blocking asynchronous operations: Bounded pool with a very low number of threads (maybe even just one), with a very high priority.)?

Or is IOApp.executionContext designed for both CPU-bound and Non-Blocking IO operations?

The function I use to convert Scala Future to F and excepts execution context:

I want to merge these queries with AND logical operator, so I just get the data that fulfilled these 2 conditions

I've integrated Django with Stripe and seems that works ok. However i have a problem by showing all products in stripe checkout page. I need to tell stripe which products we're going to buy. If i have 2 products in cart i see only one product in stripe checkout.

views.py

The design

I'm trying to implement a RGB to YUV444 conversion algorithm in hardware based in the next approximation I've got working in a C based program:

Should I include a index.php with //silence is golden to every folder in my plugin? even css, js and images folders? Or is it just folders that contain code/ php files that should have the index.php file in it?