how do i work with pre-compiled libraries in cython?

baz.pxd

from foo.bar cimport Bar

cdef class Baz(Bar):
   pass

baz.pyx

cdef class Baz(Bar):
   def __init__(self, * a, ** k):
   ...

setup.py

from distutils.core
import setup
from Cython.Build
import cythonize
from distutils.extension
import Extension

extensions = [Extension('baz', ['baz.pyx', ], libraries = ['foo.pyd', ])]
setup(name = 'baz', ext_modules = cythonize(extensions))

Suggestion : 2

The cython command takes a .py or .pyx file and compiles it into a C/C++ file.,The cythonize command takes a .py or .pyx file and compiles it into a C/C++ file. It then compiles the C/C++ file into an extension module which is directly importable from Python.,If you cimport multiple .pxd files defining libraries, then Cython merges the list of libraries, so this works as expected (similarly with other options, like include_dirs above).,Run the cythonize compiler command with your options and list of .pyx files to generate an extension module. For example:

$ cython primes.pyx

$ cythonize - a - i yourmod.pyx

$ gcc - shared - pthread - fPIC - fwrapv - O2 - Wall - fno - strict - aliasing\ -
   I / usr / include / python3 .5 - o yourmod.so yourmod.c

from setuptools
import setup
from Cython.Build
import cythonize

setup(
   ext_modules = cythonize("example.pyx")
)

[build - system]
requires = ["setuptools", "wheel", "Cython"]

$ python setup.py build_ext--inplace

Suggestion : 3

Updated: May 03, 2018

void hello(const char * name) {
   printf("hello %s\n", name);
}

$ gcc - c examples.c
$ ar rcs libexamples.a examples.o

CC = gcc

default: libexamples.a

libexamples.a: examples.o
ar rcs $ @ $ ^

   examples.o: examples.c examples.h
$(CC) - c $ <

   clean:
   rm * .o * .a

$ pip3 install cython

cdef extern from "examples.h":
   void hello(const char * name)

def py_hello(name: bytes) - > None:
   hello(name)

from distutils.core
import setup
from distutils.extension
import Extension
from Cython.Build
import cythonize

examples_extension = Extension(
   name = "pyexamples",
   sources = ["pyexamples.pyx"],
   libraries = ["examples"],
   library_dirs = ["lib"],
   include_dirs = ["lib"]
)
setup(
   name = "pyexamples",
   ext_modules = cythonize([examples_extension])
)

Suggestion : 4

Enter Cython. The Cython language is a superset of Python that compiles to C, yielding performance boosts that can range from a few percent to several orders of magnitude, depending on the task at hand. For work that is bound by Python’s native object types, the speedups won’t be large. But for numerical operations, or any operations not involving Python’s own internals, the gains can be massive. ,It helps to remember in all cases that Cython isn’t magic—that sensible real-world performance practices still apply. The less you shuttle back and forth between Python and Cython, the faster your app will run.,Keep in mind that Cython isn’t a magic wand. It doesn’t automatically turn every instance of poky Python code into sizzling-fast C code. To make the most of Cython, you must use it wisely—and understand its limitations:,Note how little our actual code has changed. All we’ve done is add type declarations to existing code to get a significant performance boost.

def f(x): return x ** 2 - xdef integrate_f(a, b, N): s = 0 dx = (b - a) / N
for i in range(N): s += f(a + i * dx) return s * dx

Now consider the Cython version of the same code, with Cython’s additions underscored:

cdef double f(double x): return x ** 2 - xdef integrate_f(double a, double b, int N): cdef int i cdef double s, x, dx s = 0 dx = (b - a) / N
for i in range(N): s += f(a + i * dx) return s * dx