zlo | Zlo API wrapper for zclient | REST library

First of all, Python is clearly not best tool for doing such a computation efficiently. The code is sequential and most of the time is spent in the CPython interpreter operation or Numpy internal functions.

Option 1: cython3
This did not yield any performance improvements.

This is partially because optimizations are not enabled. You need to use the flag -O2 or even -O3. Still, Cython will probably not help a lot as most of the time is spent in CPython-to-Numpy calls in this specific code.

Option 2: C/C++ Converting entire code to C/C++ and compile it. In fact, my first code was in C++ and debugging was a nightmare and switched to python. So, I don't want to follow this route.

You do not need to port all the code. You can rewrite only performance-critical functions like this one and put them in a dedicated CPython module (ie. writing a C/C++ extension). However, this solution require to deal with low-level CPython internals. Cython may help to deal with that: AFAIK, you can use Cython to call C++ function from a Cython function and Cython help to easily perform the interface between CPython and the C++ functions. Simple function interface should help to make the code easier to read and maintain. Still, I agree that this is not great, but a C++ code can do this computation at least an order of magnitude faster than CPython...

Searching into the google I found many options like shedskin etc.

ShedSkin is not actively developed anymore. I doubt such a project can help in you case because the code is pretty complex and use Numpy.

Numba could theoretically help a lot in this case. However, strings are not well supported yet (ie. parsing).

Could you point out the best way to optimize the above code snippet and possible alternative solutions to speed it up?

Lines like array_pxx[loc] += pxx are very slow because the interpreter need to call C Numpy function internally that performs a lot of unneeded operations: bound/type checking, type conversions, allocations/deallocations, reference counting, etc. Such an operation is very slow (>1000 times slower than in C++). One solution to avoid this, is simply to use pure-Python lists in pure-Python loops (at least when the code cannot be efficiently vectorized). You can convert list to Numpy array efficiently and perform the accumulation with np.add.at. Here is an improved implementation: