cython | The most widely used Python to C compiler

If by unreadable you mean not readable by the machine, and if you use GitHub, just put yourPythonFile.py in a file called .gitignore.

This is fixed in Brownie v1.18.1. However, you will need to install Python 3.9.10 in order to get the latest brownie. For this to work in a virtual environment you can't use venv. Here is a process that works for me:

• install virtualenv on your standard Python version
• download python 3.9.10 and install it without "add to path" into a dedicated directory e.g. $home/pythonversions
• in your project directory create a virtual environment like so

python -m virtualenv -p=""

• start your virtual environment e.g. home>..venv\Scripts\activate.ps1

• test if your python version is the desired one with python --version

• Now install Cython to avoid another error.

• Install nodeenv in order to install ganage

• Activate with nodeenv -p (for this step you will need PowerShell with admin rights)

• Install ganache with npm

• Install eth-brownie with pip check if you got the latest version with

brownie --version

I just accidentally found the solution to the above problem. The problem is the package setuptools (which in my case is the version 60.9.1)! Indeed, by executing python setup.py build_ext --inplace --compiler=mingw32, the latter will call the class Mingw32CCompiler into setuptools/_distutils/cygwinccompiler.py which contains these two lines:

It happened the same to me last friday. I think it has something to do with Cuda instalation in Google Colab but I don't know exactly the reason

One of the dependencies for python-docx is lxml. The latest stable version of lxml is 4.6.3, released on March 21, 2021. On PyPI there is no lxml wheel for 3.10, yet. So it try to compile from source and for that Microsoft Visual C++ 14.0 or greater is required, as stated in the error.

However you can manually install lxml, before install python-docx. Download and install unofficial binary from Gohlke Alternatively you can use pipwin to install it from Gohlke. Note there may still be problems with dependencies for lxml.

Of course, you can also downgrade to python3.9.

EDIT: As of 14 Dec 2021 the latest lxml version 4.7.1 supports python 3.10

I got the conda working by modifying the script as below, emr python versions were colliding with the conda version.:

If the highest dimension contains always a small number of element like 6, then your code is not the best one.

First of all, myarray == 0, np.all and ~ creates temporary arrays that introduces some additional overhead as they needs to be written and read back. The overhead is dependent of the this of the temporary array and the biggest one is myarray == 0.

Moreover, Numpy calls perform some unwanted checks that Cython is not able to remove. These checks introduce a constant time overhead. Thus, is can be quite big for small input arrays but not big input arrays.

Additionally, the code of np.all can be faster if it would know the exact size of the last dimension which is not the case here. Indeed, the loop of np.all could theoretically be unrolled since the last dimension is small. Unfortunately, Cython does not optimize Numpy calls and Numpy is compiled for a variable input size, so not known at compile-time.

Finally, the computation can be parallelized if lenpropen is huge (otherwise this will not be faster and could actually be slower). However, note that a parallel implementation requires the computation to be done in two steps: np.all(myarray == 0, axis=1) needs to be computed in parallel and then you can create the resulting array and write it by computing myarray[~result] in parallel. In sequential, you can directly overwrite myarray by filtering lines in-place and then produce a view of the filtered lines. This pattern is known as the erase-remove idiom. Note that this assume the array is contiguous.

To conclude, a faster implementation consists writing 2 nested loops iterating on myarray with a constant number of iterations for the innermost one. Regarding the size of lenpropen, you can either use a sequential in-place implementation base on the erase-remove idiom, or a parallel out-of-place implementation with two steps (and a temporary array).

Numba currently uses LLVM-Lite to compile the code efficiently to a binary (after the Python code has been translated to an LLVM intermediate representation). The code is optimized like en C++ code would be using Clang with the flags -O3 and -march=native. This last parameter is very important as is enable LLVM to use wider SIMD instructions on relatively-recent x86-64 processors: AVX and AVX2 (possible AVX512 for very recent Intel processors). Otherwise, by default Clang and GCC use only the SSE/SSE2 instructions (because of backward compatibility).

Another difference come from the comparison between GCC and the LLVM code from Numba. Clang/LLVM tends to aggressively unroll the loops while GCC often don't. This has a significant performance impact on the resulting program. In fact, you can see that the generated assembly code from Clang:

With Clang (128 items per loops):

The problem here seems to be Python 3.10.1!

I used anaconda to create a new virtual environment with Python 3.8.12, installed brownie using pipx install --python python3.8 eth-brownie and it worked!

The trick here was, to also tell pipx to use another python version, otherwise it would create a dependency to the global python version, which is python 3.10 in my case.