@cython.trashcan(True) can be used on an extension type to enable the
CPython trashcan. This allows deallocating deeply recursive objects without
overflowing the stack. Patch by Jeroen Demeyer. (Github issue #2842)

Multiplication of Python numbers with small constant integers is faster.
(Github issue #2808)

Extension types that do not need their own tp_new implementation (because
they have no object attributes etc.) directly inherit the implementation of
their parent type if possible.
(Github issue #1555)

The attributes gen.gi_frame and coro.cr_frame of Cython compiled
generators and coroutines now return an actual frame object for introspection.
(Github issue #2306)

The unicode methods .upper(), .lower() and .title() were
incorrectly optimised for single character input values and only returned
the first character if multiple characters should have been returned.
They now use the original Python methods again.

Diverging from the usual behaviour, len(memoryview), len(char*)
and len(Py_UNICODE*) returned an unsigned size_t value. They now
return a signed Py_ssize_t, like other usages of len().

Nested dict literals in function call kwargs could incorrectly raise an
error about duplicate keyword arguments, which are allowed when passing
them from dict literals.
(Github issue #2963)

Item access (subscripting) with integer indices/keys always tried the
Sequence protocol before the Mapping protocol, which diverged from Python
semantics. It now passes through the Mapping protocol first when supported.
(Github issue #1807)

Name lookups in class bodies no longer go through an attribute lookup.
Patch by Jeroen Demeyer. (Github issue #3100)

Broadcast assignments to a multi-dimensional memory view slice could end
up in the wrong places when the underlying memory view is known to be
contiguous but the slice is not.
(Github issue #2941)

The default language level was changed to 3str, i.e. Python 3 semantics,
but with str literals (also in Python 2.7). This is a backwards incompatible
change from the previous default of Python 2 semantics. The previous behaviour
is available through the directive language_level=2.

Cython no longer generates __qualname__ attributes for classes in Python
2.x since they are problematic there and not correctly maintained for subclasses.
Patch by Jeroen Demeyer. (Github issue #2772)

Source file fingerprinting now uses SHA-1 instead of MD5 since the latter
tends to be slower and less widely supported these days.
(Github issue #2790)

The long deprecated include files python_*, stdio, stdlib and
stl in Cython/Includes/Deprecated/ were removed. Use the libc.*
and cpython.* pxd modules instead.
Patch by Jeroen Demeyer. (Github issue #2904)

The search order for include files was changed. Previously it was
include_directories, Cython/Includes, sys.path. Now it is
include_directories, sys.path, Cython/Includes. This was done to
allow third-party *.pxd files to override the ones in Cython.
Patch by Matti Picus. (Github issue #2905)

The command line parser was rewritten and modernised using argparse.
Patch by Egor Dranischnikow. (Github issue #2952, #3001)

The search order for include files was changed. Previously it was
include_directories, Cython/Includes, sys.path. Now it is
include_directories, sys.path, Cython/Includes. This was done to
allow third-party *.pxd files to override the ones in Cython.
Original patch by Matti Picus. (Github issue #2905)

Setting language_level=2 in a file did not work if language_level=3
was enabled globally before.
Patch by Jeroen Demeyer. (Github issue #2791)

Assignments to C++ references returned by operator[] could fail to compile.
(Github issue #2671)

The power operator and the support for NumPy math functions were fixed
in Pythran expressions.
Patch by Serge Guelton. (Github issues #2702, #2709)

Signatures with memory view arguments now show the expected type
when embedded in docstrings.
Patch by Matthew Chan and Benjamin Weigel. (Github issue #2634)

Some from...cimport... constructs were not correctly considered
when searching modified dependencies in cythonize() to decide
whether to recompile a module.
Patch by Kryštof Pilnáček. (Github issue #2638)

A struct field type in the cpython.array declarations was corrected.
Patch by John Kirkham. (Github issue #2712)

PEP-489 multi-phase module initialisation has been enabled again. Module
reloads in other subinterpreters raise an exception to prevent corruption
of the static module state.

A set of mypy compatible PEP-484 declarations were added for Cython’s C data
types to integrate with static analysers in typed Python code. They are available
in the Cython/Shadow.pyi module and describe the types in the special cython
module that can be used for typing in Python code.
Original patch by Julian Gethmann. (Github issue #1965)

C++ functions can now be declared as potentially raising both C++ and Python
exceptions, so that Cython can handle both correctly.
(Github issue #2615)

cython.inline() supports a direct language_level keyword argument that
was previously only available via a directive.

A new language level name 3str was added that mostly corresponds to language
level 3, but keeps unprefixed string literals as type ‘str’ in both Py2 and Py3,
and the builtin ‘str’ type unchanged. This will become the default in the next
Cython release and is meant to help user code a) transition more easily to this
new default and b) migrate to Python 3 source code semantics without making support
for Python 2.x difficult.

In CPython 3.6 and later, looking up globals in the module dict is almost
as fast as looking up C globals.
(Github issue #2313)

For a Python subclass of an extension type, repeated method calls to non-overridden
cpdef methods can avoid the attribute lookup in Py3.6+, which makes them 4x faster.
(Github issue #2313)

The exception handling in generators and coroutines under CPython 3.7 was adapted
to the newly introduced exception stack. Users of Cython 0.28 who want to support
Python 3.7 are encouraged to upgrade to 0.29 to avoid potentially incorrect error
reporting and tracebacks. (Github issue #1958)

Crash when importing a module under Stackless Python that was built for CPython.
Patch by Anselm Kruis. (Github issue #2534)

When PEP-489 support is enabled, reloading the module overwrote any static
module state. It now raises an exception instead, given that reloading is
not actually supported.

Object-returning, C++ exception throwing functions were not checking that
the return value was non-null.
Original patch by Matt Wozniski (Github Issue #2603)

The source file encoding detection could get confused if the
c_string_encoding directive appeared within the first two lines.
(Github issue #2632)

Cython generated modules no longer emit a warning during import when the
size of the NumPy array type is larger than what was found at compile time.
Instead, this is assumed to be a backwards compatible change on NumPy side.

Cython now emits a warning when no language_level (2, 3 or ‘3str’) is set
explicitly, neither as a cythonize() option nor as a compiler directive.
This is meant to prepare the transition of the default language level from
currently Py2 to Py3, since that is what most new users will expect these days.
The future default will, however, not enforce unicode literals, because this
has proven a major obstacle in the support for both Python 2.x and 3.x. The
next major release is intended to make this change, so that it will parse all
code that does not request a specific language level as Python 3 code, but with
str literals. The language level 2 will continue to be supported for an
indefinite time.

The documentation was restructured, cleaned up and examples are now tested.
The NumPy tutorial was also rewritten to simplify the running example.
Contributed by Gabriel de Marmiesse. (Github issue #2245)

Cython compiles less of its own modules at build time to reduce the installed
package size to about half of its previous size. This makes the compiler
slightly slower, by about 5-7%.

The copy of a read-only memoryview was considered read-only as well, whereas
a common reason to copy a read-only view is to make it writable. The result
of the copying is now a writable buffer by default.
(Github issue #2134)

The switch statement generation failed to apply recursively to the body of
converted if-statements.

NULL was sometimes rejected as exception return value when the returned
type is a fused pointer type.
Patch by Callie LeFave. (Github issue #2177)

The const modifier can be applied to memoryview declarations to allow
read-only buffers as input. (Github issues #1605, #1869)

C code in the docstring of a cdefextern block is copied verbatimly
into the generated file.
Patch by Jeroen Demeyer. (Github issue #1915)

When compiling with gcc, the module init function is now tuned for small
code size instead of whatever compile flags were provided externally.
Cython now also disables some code intensive optimisations in that function
to further reduce the code size. (Github issue #2102)

Decorating an async coroutine with @cython.iterable_coroutine changes its
type at compile time to make it iterable. While this is not strictly in line
with PEP-492, it improves the interoperability with old-style coroutines that
use yieldfrom instead of await.

The IPython magic has preliminary support for JupyterLab.
(Github issue #1775)

The new TSS C-API in CPython 3.7 is supported and has been backported.
Patch by Naotoshi Seo. (Github issue #1932)

Cython knows the new Py_tss_t type defined in PEP-539 and automatically
initialises variables declared with that type to Py_tss_NEEDS_INIT,
a value which cannot be used outside of static assignments.

The set methods .remove() and .discard() are optimised.
Patch by Antoine Pitrou. (Github issue #2042)

The warning about repeated extern declarations is now visible by default.
(Github issue #1874)

The exception handling of the function types used by CPython’s type slot
functions was corrected to match the de-facto standard behaviour, so that
code that uses them directly benefits from automatic and correct exception
propagation. Patch by Jeroen Demeyer. (Github issue #1980)

Defining the macro CYTHON_NO_PYINIT_EXPORT will prevent the module init
function from being exported as symbol, e.g. when linking modules statically
in an embedding setup. Patch by AraHaan. (Github issue #1944)

If a module name is explicitly provided for an Extension() that is compiled
via cythonize(), it was previously ignored and replaced by the source file
name. It can now be used to override the target module name, e.g. for compiling
prefixed accelerator modules from Python files. (Github issue #2038)

The arguments of the num_threads parameter of parallel sections
were not sufficiently validated and could lead to invalid C code.
(Github issue #1957)

Catching exceptions with a non-trivial exception pattern could call into
CPython with a live exception set. This triggered incorrect behaviour
and crashes, especially in CPython 3.7.

The signature of the special __richcmp__() method was corrected to recognise
the type of the first argument as self. It was previously treated as plain
object, but CPython actually guarantees that it always has the correct type.
Note: this can change the semantics of user code that previously relied on
self being untyped.

Some Python 3 exceptions were not recognised as builtins when running Cython
under Python 2.

Some async helper functions were not defined in the generated C code when
compiling simple async code. (Github issue #2075)

Line tracing did not include generators and coroutines.
(Github issue #1949)

Extension module initialisation follows
PEP 489 in CPython 3.5+, which
resolves several differences with regard to normal Python modules. This makes
the global names __file__ and __path__ correctly available to module
level code and improves the support for module-level relative imports.
(Github issues #1715, #1753, #1035)

Asynchronous generators (PEP 525)
and asynchronous comprehensions (PEP 530)
have been implemented. Note that async generators require finalisation support
in order to allow for asynchronous operations during cleanup, which is only
available in CPython 3.6+. All other functionality has been backported as usual.

Variable annotations are now parsed according to
PEP 526. Cython types (e.g.
cython.int) are evaluated as C type declarations and everything else as Python
types. This can be disabled with the directive annotation_typing=False.
Note that most complex PEP-484 style annotations are currently ignored. This will
change in future releases. (Github issue #1850)

New decorator @cython.exceptval(x=None,check=False) that makes the signature
declarations exceptx, except?x and except* available to pure Python
code. Original patch by Antonio Cuni. (Github issue #1653)

Signature annotations are now included in the signature docstring generated by
the embedsignature directive. Patch by Lisandro Dalcin (Github issue #1781).

The gdb support for Python code (libpython.py) was updated to the latest
version in CPython 3.7 (git rev 5fe59f8).

The compiler tries to find a usable exception return value for cdef functions
with except* if the returned type allows it. Note that this feature is subject
to safety limitations, so it is still better to provide an explicit declaration.

C functions can be assigned to function pointers with a compatible exception
declaration, not only with exact matches. A side-effect is that certain compatible
signature overrides are now allowed and some more mismatches of exception signatures
are now detected and rejected as errors that were not detected before.

The IPython/Jupyter magic integration has a new option %%cython--pgo for profile
guided optimisation. It compiles the cell with PGO settings for the C compiler,
executes it to generate a runtime profile, and then compiles it again using that
profile for C compiler optimisation. Currently only tested with gcc.

len(memoryview) can be used in nogil sections to get the size of the
first dimension of a memory view (shape[0]). (Github issue #1733)

C++ classes can now contain (properly refcounted) Python objects.

NumPy dtype subarrays are now accessible through the C-API.
Patch by Gerald Dalley (Github issue #245).

Extension types that were cimported from other Cython modules could disagree
about the order of fused cdef methods in their call table. This could lead
to wrong methods being called and potentially also crashes. The fix required
changes to the ordering of fused methods in the call table, which may break
existing compiled modules that call fused cdef methods across module boundaries,
if these methods were implemented in a different order than they were declared
in the corresponding .pxd file. (Github issue #1873)

The exception state handling in generators and coroutines could lead to
exceptions in the caller being lost if an exception was raised and handled
inside of the coroutine when yielding. (Github issue #1731)

Loops over range(enum) were not converted into C for-loops. Note that it
is still recommended to use an explicit cast to a C integer type in this case.

Error positions of names (e.g. variables) were incorrectly reported after the
name and not at the beginning of the name.

Compile time DEF assignments were evaluated even when they occur inside of
falsy IF blocks. (Github issue #1796)

Disabling the line tracing from a trace function could fail.
Original patch by Dmitry Trofimov. (Github issue #1769)

Several issues with the Pythran integration were resolved.

abs(signed int) now returns a signed rather than unsigned int.
(Github issue #1837)

Reading frame.f_locals of a Cython function (e.g. from a debugger or profiler
could modify the module globals. (Github issue #1836)

Buffer type mismatches in the NumPy buffer support could leak a reference to the
buffer owner.

Using the “is_f_contig” and “is_c_contig” memoryview methods together could leave
one of them undeclared. (Github issue #1872)

Compilation failed if the for-in-range loop target was not a variable but a more
complex expression, e.g. an item assignment. (Github issue #1831)

Compile time evaluations of (partially) constant f-strings could show incorrect
results.

Escape sequences in raw f-strings (fr'...') were resolved instead of passing
them through as expected.

Type declarations in signature annotations are now parsed according to
PEP 484
typing. Only Cython types (e.g. cython.int) and Python builtin types are
currently considered as type declarations. Everything else is ignored, but this
will change in a future Cython release.
(Github issue #1672)

The directive annotation_typing is now True by default, which enables
parsing type declarations from annotations.

Extension types with a .pxd override for their __releasebuffer__ slot
(e.g. as provided by Cython for the Python array.array type) could leak
a reference to the buffer owner on release, thus not freeing the memory.
(Github issue #1638)

Item lookup/assignment with a unicode character as index that is typed
(explicitly or implicitly) as Py_UCS4 or Py_UNICODE used the
integer value instead of the Unicode string value. Code that relied on
the previous behaviour now triggers a warning that can be disabled by
applying an explicit cast. (Github issue #1602)

f-string processing was adapted to changes in PEP 498 and CPython 3.6.

The “%%cython” IPython/jupyter magic now defaults to the language level of
the current jupyter kernel. The language level can be set explicitly with
“%%cython -2” or “%%cython -3”.

The distutils extension Cython.Distutils.build_ext has now been updated
to use cythonize which properly handles dependencies. The old extension can
still be found in Cython.Distutils.old_build_ext and is now deprecated.

directive_defaults is no longer available in Cython.Compiler.Options,
use get_directive_defaults() instead.

C string literals were previously always stored as non-const global
variables in the module. They are now stored as global constants
when possible, and otherwise as non-const C string literals in the
generated code that uses them. This improves compatibility with
strict C compiler options and prevents non-const strings literals
with the same content from being incorrectly merged.

Compile time evaluated str expressions (DEF) now behave in a
more useful way by turning into Unicode strings when compiling under
Python 3. This allows using them as intermediate values in expressions.
Previously, they always evaluated to bytes objects.

isinf() declarations in libc/math.pxd and numpy/math.pxd now
reflect the actual tristate int return value instead of using bint.

Literal assignments to ctuples avoid Python tuple round-trips in some
more corner cases.

Iteration over dict(...).items() failed to get optimised when dict
arguments included keyword arguments.

Support for coverage.py 4.0+ can be enabled by adding the plugin
“Cython.Coverage” to the “.coveragerc” config file.

Annotated HTML source pages can integrate (XML) coverage reports.

Tracing is supported in nogil functions/sections and module init code.

When generators are used in a Cython module and the module imports the
modules “inspect” and/or “asyncio”, Cython enables interoperability by
patching these modules during the import to recognise Cython’s internal
generator and coroutine types. This can be disabled by C compiling the
module with “-D CYTHON_PATCH_ASYNCIO=0” or “-D CYTHON_PATCH_INSPECT=0”

When generators or coroutines are used in a Cython module, their types
are registered with the Generator and Coroutine ABCs in the
collections or collections.abc stdlib module at import time to
enable interoperability with code that needs to detect and process Python
generators/coroutines. These ABCs were added in CPython 3.5 and are
available for older Python versions through the backports_abc module
on PyPI. See https://bugs.python.org/issue24018

Adding/subtracting/dividing/modulus and equality comparisons with
constant Python floats and small integers are faster.

Binary and/or/xor/rshift operations with small constant Python integers
are faster.

When called on generator expressions, the builtins all(), any(),
dict(), list(), set(), sorted() and unicode.join()
avoid the generator iteration overhead by inlining a part of their
functionality into the for-loop.

Keyword argument dicts are no longer copied on function entry when they
are not being used or only passed through to other function calls (e.g.
in wrapper functions).

The PyTypeObject declaration in cpython.object was extended.

The builtin type type is now declared as PyTypeObject in source,
allowing for extern functions taking type parameters to have the correct
C signatures. Note that this might break code that uses type just
for passing around Python types in typed variables. Removing the type
declaration provides a backwards compatible fix.

wraparound() and boundscheck() are available as no-ops in pure
Python mode.

NULL is allowed as default argument when embedding signatures.
This fixes ticket 843.

When compiling with --embed, the internal module name is changed to
__main__ to allow arbitrary program names, including those that would
be invalid for modules. Note that this prevents reuse of the generated
C code as an importable module.

External C++ classes that overload the assignment operator can be used.
Patch by Ian Henriksen.

Support operator bool() for C++ classes so they can be used in if statements.

Installation under CPython 3.3+ no longer requires a pass of the
2to3 tool. This also makes it possible to run Cython in Python
3.3+ from a source checkout without installing it first.
Patch by Petr Viktorin.

jedi-typer.py (in Tools/) was extended and renamed to
jedityper.py (to make it importable) and now works with and
requires Jedi 0.9. Patch by Tzer-jen Wei.

Mismatching ‘except’ declarations on signatures in .pxd and .pyx files failed
to produce a compile error.

Failure to find any files for the path pattern(s) passed into cythonize()
is now an error to more easily detect accidental typos.

The logaddexp family of functions in numpy.math now has correct
declarations.

In Py2.6/7 and Py3.2, simple Cython memory views could accidentally be
interpreted as non-contiguous by CPython, which could trigger a CPython
bug when copying data from them, thus leading to data corruption.
See CPython issues 12834 and 23349.

To fix a name collision and to reflect availability on host platforms,
standard C declarations [ clock(), time(), struct tm and tm* functions ]
were moved from posix/time.pxd to a new libc/time.pxd. Patch by Charles
Blake.

Compilation no longer fails hard when unknown compilation options are
passed. Instead, it raises a warning and ignores them (as it did silently
before 0.21). This will be changed back to an error in a future release.

Enums can now be declared as cpdef to export their values to
the module’s Python namespace. Cpdef enums in pxd files export
their values to their own module, iff it exists.

Allow @staticmethod decorator to declare static cdef methods.
This is especially useful for declaring “constructors” for
cdef classes that can take non-Python arguments.

Taking a char* from a temporary Python string object is safer
in more cases and can be done inside of non-trivial expressions,
including arguments of a function call. A compile time error
is raised only when such a pointer is assigned to a variable and
would thus exceed the lifetime of the string itself.

Generators have new properties __name__ and __qualname__
that provide the plain/qualified name of the generator function
(following CPython 3.5). See https://bugs.python.org/issue21205

The inline function modifier is available as a decorator
@cython.inline in pure mode.

When cygdb is run in a virtualenv, it enables the same virtualenv
inside of the debugger. Patch by Marc Abramowitz.

PEP 465: dedicated infix operator for matrix multiplication (A @ B).

HTML output of annotated code uses Pygments for code highlighting
and generally received a major overhaul by Matthias Bussonier.

IPython magic support is now available directly from Cython with
the command “%load_ext cython”. Cython code can directly be
executed in a cell when marked with “%%cython”. Code analysis
is available with “%%cython -a”. Patch by Martín Gaitán.

Simple calls to C implemented Python functions/methods are faster.
This also speeds up many operations on builtins that Cython cannot
otherwise optimise.

The “and”/”or” operators try to avoid unnecessary coercions of their
arguments. They now evaluate the truth value of each argument
independently and only coerce the final result of the whole expression
to the target type (e.g. the type on the left side of an assignment).
This also avoids reference counting overhead for Python values during
evaluation and generally improves the code flow in the generated C code.

Set literals now create all of their items before trying to add them
to the set, following the behaviour in CPython. This makes a
difference in the rare case that the item creation has side effects
and some items are not hashable (or if hashing them has side effects,
too).

Cython no longer generates the cross product of C functions for code
that uses memory views of fused types in function signatures (e.g.
cdeffunc(floating[:]a,floating[:]b)). This is considered the
expected behaviour by most users and was previously inconsistent with
other structured types like C arrays. Code that really wants all type
combinations can create the same fused memoryview type under different
names and use those in the signature to make it clear which types are
independent.

Names that were unknown at compile time were looked up as builtins at
runtime but not as global module names. Trying both lookups helps with
globals() manipulation.

Fixed stl container conversion for typedef element types.

obj.pop(x) truncated large C integer values of x to Py_ssize_t.

__init__.pyc is recognised as marking a package directory
(in addition to .py, .pyx and .pxd).

Syntax highlighting in cython-mode.el for Emacs no longer
incorrectly highlights keywords found as part of longer names.

bytearray has become a known type and supports coercion from and
to C strings. Indexing, slicing and decoding is optimised. Note that
this may have an impact on existing code due to type inference.

Using cdefbasestringstringvar and function arguments typed as
basestring is now meaningful and allows assigning exactly
str and unicode objects, but no subtypes of these types.

Support for the __debug__ builtin.

Assertions in Cython compiled modules are disabled if the running
Python interpreter was started with the “-O” option.

Some types that Cython provides internally, such as functions and
generators, are now shared across modules if more than one Cython
implemented module is imported.

The type inference algorithm works more fine granular by taking the
results of the control flow analysis into account.

A new script in bin/cythonize provides a command line frontend
to the cythonize() compilation function (including distutils build).

The new extension type decorator @cython.no_gc_clear prevents
objects from being cleared during cyclic garbage collection, thus
making sure that object attributes are kept alive until deallocation.

During cyclic garbage collection, attributes of extension types that
cannot create reference cycles due to their type (e.g. strings) are
no longer considered for traversal or clearing. This can reduce the
processing overhead when searching for or cleaning up reference cycles.

Abstract Python classes that subtyped a Cython extension type
failed to raise an exception on instantiation, and thus ended
up being instantiated.

set.add(a_tuple) and set.discard(a_tuple) failed with a
TypeError in Py2.4.

The PEP 3155 __qualname__ was incorrect for nested classes and
inner classes/functions declared as global.

Several corner cases in the try-finally statement were fixed.

The metaclass of a Python class was not inherited from its parent
class(es). It is now extracted from the list of base classes if not
provided explicitly using the Py3 metaclass keyword argument.
In Py2 compilation mode, a __metaclass__ entry in the class
dict will still take precedence if not using Py3 metaclass syntax,
but only after creating the class dict (which may have been done
by a metaclass of a base class, see PEP 3115). It is generally
recommended to use the explicit Py3 syntax to define metaclasses
for Python types at compile time.

Completely empty C-API structs for extension type slots (protocols like
number/mapping/sequence) are no longer generated into the C code.

Docstrings that directly follow a public/readonly attribute declaration
in a cdef class will be used as docstring of the auto-generated property.
This fixes ticket 206.

The automatic signature documentation tries to preserve more semantics
of default arguments and argument types. Specifically, bint arguments
now appear as type bool.

A warning is emitted when negative literal indices are found inside of
a code section that disables wraparound handling. This helps with
fixing invalid code that might fail in the face of future compiler
optimisations.

Constant folding for boolean expressions (and/or) was improved.

Added a build_dir option to cythonize() which allows one to place
the generated .c files outside the source tree.

isinstance(X,type) failed to get optimised into a call to
PyType_Check(), as done for other builtin types.

A spurious fromdatetimecimport* was removed from the “cpython”
declaration package. This means that the “datetime” declarations
(added in 0.19) are no longer available directly from the “cpython”
namespace, but only from “cpython.datetime”. This is the correct
way of doing it because the declarations refer to a standard library
module, not the core CPython C-API itself.

The C code for extension types is now generated in topological order
instead of source code order to avoid C compiler errors about missing
declarations for subtypes that are defined before their parent.

The memoryview type name no longer shows up in the module dict of
modules that use memory views. This fixes trac ticket 775.

Regression in 0.19 that rejected valid C expressions from being used
in C array size declarations.

In C++ mode, the C99-only keyword restrict could accidentally be
seen by the GNU C++ compiler. It is now specially handled for both
GCC and MSVC.

Testing large (> int) C integer values for their truth value could fail
due to integer wrap-around.

Py_UNICODE* coerces from and to Python unicode strings. This is
helpful when talking to Windows APIs, which use compatible wchar_t
arrays for strings. Note that the Py_UNICODE type is otherwise
deprecated as of CPython 3.3.

isinstance(obj,basestring) is optimised. In Python 3 it only tests
for instances of str (i.e. Py2 unicode).

The basestring builtin is mapped to str (i.e. Py2 unicode) when
compiling the generated C code under Python 3.

Closures use freelists, which can speed up their creation quite substantially.
This is also visible for short running generator expressions, for example.

A new class decorator @cython.freelist(N) creates a static freelist of N
instances for an extension type, thus avoiding the costly allocation step if
possible. This can speed up object instantiation by 20-30% in suitable
scenarios. Note that freelists are currently only supported for base types,
not for types that inherit from others.

Fast extension type instantiation using the Type.__new__(Type) idiom has
gained support for passing arguments. It is also a bit faster for types defined
inside of the module.

2-value slicing of unknown objects passes the correct slice when the getitem
protocol is used instead of the getslice protocol (especially in Python 3),
i.e. None values for missing bounds instead of [0,maxsize]. It is also
a bit faster in some cases, e.g. for constant bounds. This fixes trac ticket 636.

Cascaded assignments of None values to extension type variables failed with
a TypeError at runtime.

The __defaults__ attribute was not writable for Cython implemented
functions.

Default values of keyword-only arguments showed up in __defaults__ instead
of __kwdefaults__ (which was not implemented). Both are available for
Cython implemented functions now, as specified in Python 3.x.

yield works inside of withgil sections. It previously lead to a crash.
This fixes trac ticket 803.

Static methods without explicitly named positional arguments (e.g. having only
*args) crashed when being called. This fixes trac ticket 804.

dir() without arguments previously returned an unsorted list, which now
gets sorted as expected.

During final interpreter cleanup (with types cleanup enabled at compile time), extension types that inherit from base types over more than one level that were cimported from other modules could lead to a crash.

Alpha quality support for compiling and running Cython generated extension modules in PyPy (through cpyext). Note that this requires at least PyPy 1.9 and in many cases also adaptations in user code, especially to avoid borrowed references when no owned reference is being held directly in C space (a reference in a Python list or dict is not enough, for example). See the documentation on porting Cython code to PyPy.

“yield from” is supported (PEP 380) and a couple of minor problems with generators were fixed.

C++ STL container classes automatically coerce from and to the equivalent Python container types on typed assignments and casts. Note that the data in the containers is copied during this conversion.

C++ iterators can now be iterated over using “for x in cpp_container” whenever cpp_container has begin() and end() methods returning objects satisfying the iterator pattern (that is, it can be incremented, dereferenced, and compared (for non-equality)).

cdef classes can now have C++ class members (provided a zero-argument constructor exists)

A new cpython.array standard cimport file allows to efficiently talk to the stdlib array.array data type in Python 2. Since CPython does not export an official C-API for this module, it receives special casing by the compiler in order to avoid setup overhead on user side. In Python 3, both buffers and memory views on the array type already worked out of the box with earlier versions of Cython due to the native support for the buffer interface in the Py3 array module.

Fast dict iteration is now enabled optimistically also for untyped variables when the common iteration methods are used.

Old-style Py2 imports did not work reliably in Python 3.x and were broken in Python 3.3. Regardless of this fix, it’s generally best to be explicit about relative and global imports in Cython code because old-style imports have a higher overhead. To this end, “from __future__ import absolute_import” is supported in Python/Cython 2.x code now (previous versions of Cython already used it when compiling Python 3 code).

Stricter constraints on the “inline” and “final” modifiers. If your code does not compile due to this change, chances are these modifiers were previously being ignored by the compiler and can be removed without any performance regression.

Exceptions are always instantiated while raising them (as in Python), instead of risking to instantiate them in potentially unsafe situations when they need to be handled or otherwise processed.

Uninitialized variables are no longer initialized to None and accessing them has the same semantics as standard Python.

globals() now returns a read-only dict of the Cython module’s globals, rather than the globals of the first non-Cython module in the stack

Many C++ exceptions are now special cased to give closer Python counterparts. This means that except+ functions that formerly raised generic RuntimeErrors may raise something else such as ArithmeticError.

The inlined generator expressions (introduced in Cython 0.13) were disabled in favour of full generator expression support. This breaks code that previously used them inside of cdef functions (usage in def functions continues to work) and induces a performance regression for cases that continue to work but that were previously inlined. We hope to reinstate this feature in the near future.

Python classes can now be nested and receive a proper closure at definition time.

Redefinition is supported for Python functions, even within the same scope.

Lambda expressions are supported in class bodies and at the module level.

Metaclasses are supported for Python classes, both in Python 2 and Python 3 syntax. The Python 3 syntax (using a keyword argument in the type declaration) is preferred and optimised at compile time.

“final” extension classes prevent inheritance in Python space. This feature is available through the new “cython.final” decorator. In the future, these classes may receive further optimisations.

“internal” extension classes do not show up in the module dictionary. This feature is available through the new “cython.internal” decorator.

Extension type inheritance from builtin types, such as “cdef class MyUnicode(unicode)”, now works without further external type redeclarations (which are also strongly discouraged now and continue to issue a warning).

Constant tuples are now cached over the lifetime of an extension module, just like CPython does. Constant argument tuples of Python function calls are also cached.

Closures have tightened to include exactly the names used in the inner functions and classes. Previously, they held the complete locals of the defining function.

The builtin “next()” function in Python 2.6 and later is now implemented internally and therefore available in all Python versions. This makes it the preferred and portable way of manually advancing an iterator.

In addition to the previously supported inlined generator expressions in 0.13, “sorted(genexpr)” can now be used as well. Typing issues were fixed in “sum(genexpr)” that could lead to invalid C code being generated. Other known issues with inlined generator expressions were also fixed that make upgrading to 0.14 a strong recommendation for code that uses them. Note that general generators and generator expressions continue to be not supported.

Inplace arithmetic operators now respect the cdivision directive and are supported for complex types.

Typing a variable as type “complex” previously gave it the Python object type. It now uses the appropriate C/C++ double complex type. A side-effect is that assignments and typed function parameters now accept anything that Python can coerce to a complex, including integers and floats, and not only complex instances.

Large integer literals pass through the compiler in a safer way. To prevent truncation in C code, non 32-bit literals are turned into Python objects if not used in a C context. This context can either be given by a clear C literal suffix such as “UL” or “LL” (or “L” in Python 3 code), or it can be an assignment to a typed variable or a typed function argument, in which case it is up to the user to take care of a sufficiently large value space of the target.

Python functions are declared in the order they appear in the file, rather than all being created at module creation time. This is consistent with Python and needed to support, for example, conditional or repeated declarations of functions. In the face of circular imports this may cause code to break, so a new –disable-function-redefinition flag was added to revert to the old behavior. This flag will be removed in a future release, so should only be used as a stopgap until old code can be fixed.

Closures are fully supported for Python functions. Cython supports inner functions and lambda expressions. Generators and generator expressions are not supported in this release.

Proper C++ support. Cython knows about C++ classes, templates and overloaded function signatures, so that Cython code can interact with them in a straight forward way.

Type inference is enabled by default for safe C types (e.g. double, bint, C++ classes) and known extension types. This reduces the need for explicit type declarations and can improve the performance of untyped code in some cases. There is also a verbose compile mode for testing the impact on user code.

Cython’s for-in-loop can iterate over C arrays and sliced pointers. The type of the loop variable will be inferred automatically in this case.

The Py_UNICODE integer type for Unicode code points is fully supported, including for-loops and ‘in’ tests on unicode strings. It coerces from and to single character unicode strings. Note that untyped for-loop variables will automatically be inferred as Py_UNICODE when iterating over a unicode string. In most cases, this will be much more efficient than yielding sliced string objects, but can also have a negative performance impact when the variable is used in a Python context multiple times, so that it needs to coerce to a unicode string object more than once. If this happens, typing the loop variable as unicode or object will help.

The built-in functions any(), all(), sum(), list(), set() and dict() are inlined as plain for loops when called on generator expressions. Note that generator expressions are not generally supported apart from this feature. Also, tuple(genexpr) is not currently supported - use tuple([listcomp]) instead.

More shipped standard library declarations. The python_* and stdlib/stdio .pxd files have been deprecated in favor of clib.* and cpython[.*] and may get removed in a future release.

Pure Python mode no longer disallows non-Python keywords like ‘cdef’, ‘include’ or ‘cimport’. It also no longer recognises syntax extensions like the for-from loop.

Parsing has improved for Python 3 syntax in Python code, although not all features are correctly supported. The missing Python 3 features are being worked on for the next release.

from __future__ import print_function is supported in Python 2.6 and later. Note that there is currently no emulation for earlier Python versions, so code that uses print() with this future import will require at least Python 2.6.

The availability of type inference by default means that Cython will also infer the type of pointers on assignments. Previously, code like this:

cdefchar* s=...untyped_variable=s

would convert the char* to a Python bytes string and assign that. This is no longer the case and no coercion will happen in the example above. The correct way of doing this is through an explicit cast or by typing the target variable, i.e.

bool is no longer a valid type name by default. The problem is that it’s not clear whether bool should refer to the Python type or the C++ type, and expecting one and finding the other has already led to several hard-to-find bugs. Both types are available for importing: you can use from cpython cimport bool for the Python bool type, and from libcpp cimport bool for the C++ type. bool is still a valid object by default, so one can still write bool(x).

__getsegcount__ is now correctly typed to take a Py_size_t* rather than an int*.

There have been several bug fixes and improvements to the type inferencer.

Notably, there is now a “safe” mode enabled by setting the infer_types directive to None. (The None here refers to the “default” mode, which will be the default in 0.13.) This safe mode limits inference to Python object types and C doubles, which should speed up execution without affecting any semantics such as integer overflow behavior like infer_types=True might. There is also an infer_types.verbose option which allows one to see what types are inferred.

The boundscheck directive works for lists and tuples as well as buffers.

len(s) and s.decode(“encoding”) are efficiently supported for char* s.

Cython’s INLINE macro has been renamed to CYTHON_INLINE to reduce conflict and has better support for the MSVC compiler on Windows. It is no longer clobbered if externally defined.

Revision history is now omitted from the source package, resulting in a 85% size reduction. Running make repo will download the history and turn the directory into a complete Mercurial working repository.

Cython modules don’t need to be recompiled when the size of an external type grows. (A warning, rather than an error, is produced.) This should be helpful for binary distributions relying on NumPy.