./lang/py-cython, C-Extensions for Python

[ CVSweb ] [ Homepage ] [ RSS ] [ Required by ] [ Add to tracker ]


Branch: CURRENT, Version: 0.27.3, Package name: py27-cython-0.27.3, Maintainer: pkgsrc-users

The Cython language makes writing C extensions for the Python language
as easy as Python itself. Cython is a source code translator based on
the well-known Pyrex, but supports more cutting edge functionality and
optimizations.

The Cython language is very close to the Python language (and most
Python code is also valid Cython code), but Cython additionally supports
calling C functions and declaring C types on variables and class
attributes. This allows the compiler to generate very efficient C code
from Cython code.

This makes Cython the ideal language for writing glue code for external
C libraries, and for fast C modules that speed up the execution of
Python code.


Required to run:
[devel/py-setuptools]

Master sites:

SHA1: 688aa815301dd9e710cd847528de31099f3b52c4
RMD160: c6fa763137e0c000beff0898e3af0f6c23c9d9bc
Filesize: 1735.146 KB

Version history: (Expand)


CVS history: (Expand)


   2017-11-06 11:12:29 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-cython: updated to 0.27.3

0.27.3:

Bugs fixed

* String forward references to extension types like \ 
``@cython.locals(x="ExtType")``
  failed to find the named type.

* NumPy slicing generated incorrect results when compiled with Pythran.

* Fix "undefined reference" linker error for generators on Windows in \ 
Py3.3-3.5.

* Adapt to recent C-API change of ``PyThreadState`` in CPython 3.7.

* Fix signature of ``PyWeakref_GetObject()`` API declaration.
   2017-10-23 22:46:22 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-cython: updated to 0.27.2

0.27.2:

Bugs fixed
----------
* Comprehensions could incorrectly be optimised away when they appeared in boolean
  test contexts.
* The special methods ``__eq__``, ``__lt__`` etc. in extension types did not type
  their first argument as the type of the class but ``object``.
* Crash on first lookup of "cline_in_traceback" option during \ 
exception handling.
* Some nested module level comprehensions failed to compile.
* Compiler crash on some complex type declarations in pure mode.
* ``std::unordered_map.erase()`` was declared with an incorrect ``void`` return
  type in ``libcpp.unordered_map``.
* Invalid use of C++ ``fallthrough`` attribute before C++11 and similar issue in \ 
clang.
* Compiler crash on misnamed properties.
   2017-10-03 21:50:23 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-cython: update to 0.27.1

0.27.1:
Features added
* The Jupyter magic has a new debug option --verbose that shows details about \ 
the distutils invocation.

Bugs fixed
* Py3 list comprehensions in class bodies resulted in invalid C code.
* Modules built for later CPython 3.5.x versions failed to import in 3.5.0/3.5.1.
* Deallocating fused types functions and methods kept their GC tracking enabled, \ 
which could potentially lead to recursive deallocation attempts.
* Crash when compiling in C++ mode with old setuptools versions.
* C++ object arguments for the constructor of Cython implemented C++ are now \ 
passed by reference and not by value to allow for non-copyable arguments, such \ 
as unique_ptr.
* API-exported C++ classes with Python object members failed to compile.
* Some issues with the new relaxed exception value handling were resolved.
* Python classes as annotation types could prevent compilation.
* Cython annotation types in Python files could lead to import failures with a \ 
"cython undefined" error. Recognised types are now turned into \ 
strings.
* Coverage analysis could fail to report on extension modules on some platforms.
* Annotations could be parsed (and rejected) as types even with \ 
annotation_typing=False.

Other changes
* PEP 489 support has been disabled by default to counter incompatibilities with \ 
import setups that try to reload or reinitialise modules.
   2017-09-30 11:53:23 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-cython: update to 0.27

0.27:

Features added
* Extension module initialisation follows
  `PEP 489 <https://www.python.org/dev/peps/pep-0489/>`_ 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.
* Asynchronous generators (`PEP 525 \ 
<https://www.python.org/dev/peps/pep-0525/>`_)
  and asynchronous comprehensions (`PEP 530 \ 
<https://www.python.org/dev/peps/pep-0530/>`_)
  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 <https://www.python.org/dev/peps/pep-0526/>`_.  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.
* Extension types (also in pure Python mode) can implement the normal special methods
  ``__eq__``, ``__lt__`` etc. for comparisons instead of the low-level \ 
``__richcmp__``
  method.
* New decorator ``@cython.exceptval(x=None, check=False)`` that makes the signature
  declarations ``except x``, ``except? x`` and ``except *`` available to pure Python
  code.  Original patch by Antonio Cuni.
* Signature annotations are now included in the signature docstring generated by
  the ``embedsignature`` directive.
* 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]``).
* C++ classes can now contain (properly refcounted) Python objects.
* NumPy dtype subarrays are now accessible through the C-API.
* Resolves several issues with PyPy and uses faster async slots in PyPy3.

Bugs fixed
* 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.
* 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.
* 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.
* Disabling the line tracing from a trace function could fail.
* Several issues with the Pythran integration were resolved.
* abs(signed int) now returns a signed rather than unsigned int.
* Reading ``frame.f_locals`` of a Cython function (e.g. from a debugger or profiler
  could modify the module globals.
* 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.
* Compilation failed if the for-in-range loop target was not a variable but a more
  complex expression, e.g. an item assignment.
* 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.
* Some ref-counting issues in buffer error handling have been resolved.

Other changes
* Type declarations in signature annotations are now parsed according to
  `PEP 484 <https://www.python.org/dev/peps/pep-0484/>`_
  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.
* The directive ``annotation_typing`` is now ``True`` by default, which enables
  parsing type declarations from annotations.
* This release no longer supports Python 3.2.
   2017-09-03 20:48:54 by Adam Ciarcinski | Files touched by this commit (3)
Log message:
0.26.1:
Bugs fixed
* ``cython.view.array`` was missing ``.__len__()``.
* 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.
* Auto-decoding failed in 0.26 for strings inside of C++ containers.
* Compile error when inheriting from C++ container types.
* Invalid C code in generators (declaration after code).
* Arithmetic operations on ``const`` integer variables could generate invalid code.
* Local variables with names of special Python methods failed to compile inside of
  closures.
* Problem with indirect Emacs buffers in cython-mode.
* Extension types named ``result`` or ``PickleError`` generated invalid \ 
unpickling code.
* Bazel integration failed to compile ``.py`` files.
* Some include directories and dependencies were referenced with their absolute paths
  in the generated files despite lying within the project directory.
   2017-07-20 10:37:09 by Adam Ciarcinski | Files touched by this commit (3)
Log message:
0.26:

Features added

* Pythran can be used as a backend for evaluating NumPy array expressions.

* cdef classes now support pickling by default when possible.
  This can be disabled with the ``auto_pickle`` directive.

* Speed up comparisons of strings if their hash value is available.

* Support pyximport from zip files.

* IPython magic now respects the ``__all__`` variable and ignores
  names with leading-underscore (like ``import *`` does).

* ``abs()`` is optimised for C complex numbers.

* The display of C lines in Cython tracebacks can now be enabled at runtime
  via ``import cython_runtime; cython_runtime.cline_in_traceback=True``.
  The default has been changed to False.

* The overhead of calling fused types generic functions was reduced.

* "cdef extern" include files are now also searched relative to the \ 
current file.

* Optional optimization for re-aquiring the GIL, controlled by the
  `fast_gil` directive.

Bugs fixed
----------

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

* Invalid C code when decoding from UTF-16(LE/BE) byte strings.

* Unicode escapes in 'ur' raw-unicode strings were not resolved in Py2 code.

* File paths of code objects are now relative.

* Decorators of cdef class methods could be executed twice.

* Several warnings in the generated coder are now suppressed.

Other changes
-------------

* The ``unraisable_tracebacks`` option now defaults to ``True``.

* Coercion of C++ containers to Python is no longer automatic on attribute
  access (Github issue 1521).

* Access to Python attributes of cimported modules without the corresponding
  import is now a compile-time (rather than runtime) error.

* Do not use special dll linkage for "cdef public" functions.

* cdef/cpdef methods must match their declarations.  See Github Issue 1732.
  This is now a warning and will be an error in future releases.
   2017-01-25 17:09:06 by Adam Ciarcinski | Files touched by this commit (4)
Log message:
Changes 0.25.2:
Bugs fixed
----------
* Fixes several issues with C++ template deduction.
* Fixes a issue with bound method type inference
* Fixes a bug with cascaded tuple assignment
* Fixed or silenced many Clang warnings.
* Fixes bug with powers of pure real complex numbers
   2016-08-28 17:48:37 by Thomas Klausner | Files touched by this commit (112)
Log message:
Remove unnecessary PLIST_SUBST and FILES_SUBST that are now provided
by the infrastructure.

Mark a couple more packages as not ready for python-3.x.