All Versions
88
Latest Version
Avg Release Cycle
53 days
Latest Release
805 days ago

Changelog History
Page 8

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

  • v0.16 Changes

    April 21, 2012

    ๐Ÿ”‹ Features added

    • โœจ Enhancements to Cython's function type (support for weak references, default arguments, code objects, dynamic attributes, classmethods, staticmethods, and more)

    • ๐Ÿ“„ Fused Types - Template-like support for functions and methods CEP 522 (docs)

    • ๐Ÿ“„ Typed views on memory - Support for efficient direct and indirect buffers (indexing, slicing, transposing, ...) CEP 517 (docs)

    • super() without arguments

    • Final cdef methods (which translate into direct calls on known instances)

    ๐Ÿ› Bugs fixed

    • ๐Ÿ›  fix alignment handling for record types in buffer support

    Other changes

    • ๐Ÿ‘Œ support default arguments for closures

    • search sys.path for pxd files

    • ๐Ÿ‘Œ support C++ template casting

    • ๐Ÿ— faster traceback building and faster generator termination

    • ๐Ÿ‘Œ support inplace operators on indexed buffers

    • ๐Ÿ‘ allow nested prange sections

  • v0.15.1 Changes

    September 19, 2011

    ๐Ÿ”‹ Features added

    ๐Ÿ› Bugs fixed

    Other changes