Cython changelog

Changelog History

Page 8

• v0.20 Changes

  January 18, 2014

  🔋 Features added

  • 👌 Support for CPython 3.4.

  • 👌 Support for calling C++ template functions.

  • 👍 yield is supported in finally clauses.

  • The C code generated for finally blocks is duplicated for each exit case to allow for better optimisations by the C compiler.

  • Cython tries to undo the Python optimisationism of assigning a bound method to a local variable when it can generate better code for the direct call.

  • Constant Python float values are cached.

  • String equality comparisons can use faster type specific code in more cases than before.

  • String/Unicode formatting using the '%' operator uses a faster C-API call.

  • 👍 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 cdef basestring stringvar 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.

  • Package compilation (i.e. __init__.py files) now works, starting with Python 3.3.

  • ⚡️ The cython-mode.el script for Emacs was updated. Patch by Ivan Andrus.

  • An option common_utility_include_dir was added to cythonize() to save oft-used utility code once in a separate directory rather than as part of each generated file.

  • 🖨 unraisable_tracebacks directive added to control printing of tracebacks of unraisable exceptions.

  🐛 Bugs fixed

  • 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.

  • The automatic C switch statement generation behaves more safely for heterogeneous value types (e.g. mixing enum and char), allowing for a slightly wider application and reducing corner cases. It now always generates a 'default' clause to avoid C compiler warnings about unmatched enum values.

  • 🛠 Fixed a bug where class hierarchies declared out-of-order could result in broken generated code.

  • 🛠 Fixed a bug which prevented overriding const methods of C++ classes.

  • 🛠 Fixed a crash when converting Python objects to C++ strings fails.

  Other changes

  • 💅 In Py3 compilation mode, Python2-style metaclasses declared by a __metaclass__ class dict entry are ignored.

  • In Py3.4+, the Cython generator type uses tp_finalize() for safer cleanup instead of tp_del().

• v0.19.2 Changes

  October 13, 2013

  🔋 Features added

  🐛 Bugs fixed

  • ⚡️ Some standard declarations were fixed or updated, including the previously incorrect declaration of PyBuffer_FillInfo() and some missing bits in libc.math.

  • Heap allocated subtypes of type used the wrong base type struct at the C level.

  • Calling the unbound method dict.keys/value/items() in dict subtypes could call the bound object method instead of the unbound supertype method.

  • 👍 "yield" wasn't supported in "return" value expressions.

  • Using the "bint" type in memory views lead to unexpected results. It is now an error.

  • Assignments to global/closure variables could catch them in an illegal state while deallocating the old value.

  Other changes

• v0.19.1 Changes

  May 11, 2013

  🔋 Features added

  • 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.

  🐛 Bugs fixed

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

  • 🚚 A spurious from datetime cimport * 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.

  Other changes

• v0.19 Changes

  April 19, 2013

  🔋 Features added

  • New directives c_string_type and c_string_encoding to more easily and automatically convert between C strings and the different Python string types.

  • The extension type flag Py_TPFLAGS_HAVE_VERSION_TAG is enabled by default on extension types and can be disabled using the type_version_tag compiler directive.

  • 👍 EXPERIMENTAL support for simple Cython code level line tracing. Enabled by the "linetrace" compiler directive.

  • Cython implemented functions make their argument and return type annotations available through the __annotations__ attribute (PEP 3107).

  • Access to non-cdef module globals and Python object attributes is faster.

  • 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.

  • The Python2-only dict methods .iter*() and .view*() (requires Python 2.7) are automatically mapped to the equivalent keys/values/items methods in Python 3 for typed dictionaries.

  • Slicing unicode strings, lists and tuples is faster.

  • list.append() is faster on average.

  • 👻 raise Exception() from None suppresses the exception context in Py3.3.

  • 👍 Py3 compatible exec(tuple) syntax is supported in Py2 code.

  • 👍 Keyword arguments are supported for cdef functions.

  • 🛠 External C++ classes can be declared nogil. Patch by John Stumpo. This fixes trac ticket 805.

  🐛 Bugs fixed

  • 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.

  • 0️⃣ The __defaults__ attribute was not writable for Cython implemented functions.

  • 0️⃣ 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 with gil 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.

  • dict.items(), dict.keys() and dict.values() no longer return lists in Python 3.

  • 👻 Exiting from an except-as clause now deletes the exception in Python 3 mode.

  • The declarations of frexp() and ldexp() in math.pxd were incorrect.

  Other changes

• v0.18 Changes

  January 28, 2013

  🔋 Features added

  • 👍 Named Unicode escapes ("\N{...}") are supported.

  • Python functions/classes provide the special attribute "qualname" as defined by PEP 3155.

  • ➕ Added a directive overflowcheck which raises an OverflowException when arithmetic with C ints overflow. This has a modest performance penalty, but is much faster than using Python ints.

  • Calls to nested Python functions are resolved at compile time.

  • Type inference works across nested functions.

  • py_bytes_string.decode(...) is optimised.

  • 👍 C const declarations are supported in the language.

  🐛 Bugs fixed

  • 👻 Automatic C++ exception mapping didn't work in nogil functions (only in "with nogil" blocks).

  Other changes

• v0.17.4 Changes

  January 03, 2013

  🐛 Bugs fixed

  • Garbage collection triggered during deallocation of container classes could lead to a double-deallocation.

• v0.17.3 Changes

  December 14, 2012

  🔋 Features added

  🐛 Bugs fixed

  • 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.

  • Weak-reference support in extension types (with a cdef __weakref__ attribute) generated incorrect deallocation code.

  • In CPython 3.3, converting a Unicode character to the Py_UNICODE type could fail to raise an overflow for non-BMP characters that do not fit into a wchar_t on the current platform.

  • Negative C integer constants lost their longness suffix in the generated C code.

  Other changes

• v0.17.2 Changes

  November 20, 2012

  🔋 Features added

  • cythonize() gained a best effort compile mode that can be used to simply ignore .py files that fail to compile.

  🐛 Bugs fixed

  • Replacing an object reference with the value of one of its cdef attributes could generate incorrect C code that accessed the object after deleting its last reference.

  • C-to-Python type coercions during cascaded comparisons could generate invalid C code, specifically when using the 'in' operator.

  • "obj[1,]" passed a single integer into the item getter instead of a tuple.

  • Cyclic imports at module init time did not work in Py3.

  • The names of C++ destructors for template classes were built incorrectly.

  • In pure mode, type casts in Cython syntax and the C ampersand operator are now rejected. Use the pure mode replacements instead.

  • In pure mode, C type names and the sizeof() function are no longer recognised as such and can be used as normal Python names.

  • 👍 The extended C level support for the CPython array type was declared too late to be used by user defined classes.

  • C++ class nesting was broken.

  • 👍 Better checking for required nullary constructors for stack-allocated C++ instances.

  • ✂ Remove module docstring in no-docstring mode.

  • 🛠 Fix specialization for varargs function signatures.

  • 🛠 Fix several compiler crashes.

  Other changes

  • An experimental distutils script for compiling the CPython standard library was added as Tools/cystdlib.py.

• v0.17.1 Changes

  September 26, 2012

  🔋 Features added

  🐛 Bugs fixed

  • 🛠 A reference leak was fixed in the new dict iteration code when the loop target was not a plain variable but an unpacked tuple.

  • Memory views did not handle the special case of a NULL buffer strides value, as allowed by PEP3118.

  Other changes

• v0.17 Changes

  September 01, 2012

  🔋 Features added

  • 📚 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.

  • The unicode string processing code was adapted for the upcoming CPython 3.3 (PEP 393, new Unicode buffer layout).

  • Buffer arguments and memory view arguments in Python functions can be declared "not None" to raise a TypeError on None input.

  • c(p)def functions in pure mode can specify their return type with "@cython.returns()".

  • Automatic dispatch for fused functions with memoryview arguments

  • 👌 Support newaxis indexing for memoryviews

  • 👌 Support decorators for fused functions

  🐛 Bugs fixed

  • 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.

  • locals() properly ignores names that do not have Python compatible types (including automatically inferred types).

  • 🛠 Some garbage collection issues of memory views were fixed.

  • numpy.pxd compiles in Python 3 mode.

  • ⚠ Several C compiler warnings were fixed.

  • 🛠 Several bugs related to memoryviews and fused types were fixed.

  • 💅 Several bug-fixes and improvements related to cythonize(), including ccache-style caching.

  Other changes

  • libc.string provides a convenience declaration for const uchar in addition to const char.

  • 👉 User declared char* types are now recognised as such and auto-coerce to and from Python bytes strings.

  • callable() and next() compile to more efficient C code.

  • list.append() is faster on average.

  • Modules generated by @cython.inline() are written into the directory pointed to by the environment variable CYTHON_CACHE_DIR if set.

• « First
• ‹ Prev
• 4
• 5
• 6
• 7
• 8
• 9
• Next ›
• Last »