Sublimation | A collection of commands and snippets

I think the issue is with your axios.all(...) code. You are passing in two values but the values have .map inside them which are returning urls. Because of this, axios.post() on both indexes will upload the images but axios.all() will have the return values from the .map() function which is an array of promises. You can try something like this.

I think that your problem may be due to inconsistent data output: lines with a code can start with or without a colon.

I made a new code that identifies data block by searching the the lines that start with a code (or : + code) and and then reads each block into a data frame.

Try this:

obtainRandom and stemQuestions are properties of hangmanGame, so in order to refer to them from inside populateQuestions you need to use this:

I generally agree with the advice presented by @chepner and @juanpa.arrivillaga in the comments. Numpy is a performant library, and it is true that the underlying calculations it performs are written in C. Furthermore, the syntax is clean and it is trivial to apply scalar operations across all elements of a numpy array.

However, there actually is a way to significantly improve the performance of your code with cython thanks to the way your particular algorithm is structured if we use the following assumptions (and can tolerate ugly code):

• Your arrays are all one-dimensional, making iterating over each item in an array extremely trivial. We do not need to replace more difficult numpy functions like numpy.dot for example as all operations in your code only combine scalars with matrices.
• While using a for loop in python would be unthinkable, iterating over every index is very feasible in cython. Additionally, each item in the final output depends only on the inputs that correspond to that item's index (i.e. the 0th item uses u[0], PorosityProfile[0], etc).
• You are not interested in any of the intermediate arrays, only in the final result returned in your compute_python function. Therefore, why waste time allocating memory for all of those intermediate numpy arrays?
• Using x**y syntax is surprisingly slow. I use a gcc compiler option, --ffast-math to improve this significantly. I also use several cython compiler directives to avoid python checks and overhead.
• Creating numpy arrays itself can have python overhead, so I use a combination of typed memoryviews (the preferred, newer syntax anyways) and malloc-ed pointers to create the output array without interacting with python very much (only two lines, getting the output size and the return statement show significant python interaction as seen in the cython annotation files).

Taking all of these considerations into account, here is the modified code. It performs nearly an order of magnitude faster than the naive python version on my laptop.

sublimation.pyx

So here it is. I used flexbox to align items.

just add following html