Metadata-Version: 2.4
Name: Cython
Version: 3.3.0a1
Summary: The Cython compiler for writing C extensions in the Python language.
Home-page: https://cython.org/
Author: Robert Bradshaw, Stefan Behnel, David Woods, Greg Ewing, et al.
Author-email: cython-devel@python.org
License: Apache-2.0
Project-URL: Documentation, https://cython.readthedocs.io/
Project-URL: Donate, https://cython.readthedocs.io/en/latest/src/donating.html
Project-URL: Source Code, https://github.com/cython/cython
Project-URL: Bug Tracker, https://github.com/cython/cython/issues/
Project-URL: User Group, https://groups.google.com/g/cython-users
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Programming Language :: C
Classifier: Programming Language :: C++
Classifier: Programming Language :: Cython
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Typing :: Typed
Requires-Python: >=3.9
Description-Content-Type: text/x-rst
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license
Dynamic: project-url
Dynamic: requires-python
Dynamic: summary

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

The Cython language is a superset of the Python language (almost all Python
code is also valid Cython code), but Cython additionally supports optional
static typing to natively call C functions, operate with C++ classes and
declare fast 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/C++ libraries, and for fast C modules that speed up the execution of
Python code.

The newest Cython release can always be downloaded from https://cython.org/.
Unpack the tarball or zip file, enter the directory, and then run::

    pip install .

Note that for one-time builds, e.g. for CI/testing, on platforms that are not
covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
that we provide is not used, it is substantially faster than a full source build
to install an uncompiled (slower) version of Cython with::

    NO_CYTHON_COMPILE=true pip install .

.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/

3.3.0a1 (2026-06-24)
====================

Features added
--------------

* Changes were made to adapt to Python 3.15 and its Limited API.
  (Github issues https://github.com/cython/cython/issues/6405, https://github.com/cython/cython/issues/7190, https://github.com/cython/cython/issues/7347, https://github.com/cython/cython/issues/7348, https://github.com/cython/cython/issues/7358)

* PEP-634 Pattern Matching is implemented.
  (Github issue https://github.com/cython/cython/issues/4029)

* Declared container item types (e.g. ``list[float]``) are now used by the type system.
  (Github issue https://github.com/cython/cython/issues/7288)

* Type inference was improved for builtin Python types.
  (Github issues https://github.com/cython/cython/issues/7536, https://github.com/cython/cython/issues/7644)

* Extension types can declare themselves explicitly as sequence or mapping with
  ``@cython.collection_type("sequence")`` or ``@cython.collection_type("mapping")``.
  This has an effect on their behaviour in pattern matching and subscripting.
  (Github issue https://github.com/cython/cython/issues/5027)

* Sequence types that have their ``Py_TPFLAGS_SEQUENCE`` type flag set can benefit from
  faster subscripting via the sequence protocol as Cython now bypasses the mapping protocol
  for them if both protocols are implemented.
  (Github issue https://github.com/cython/cython/issues/7432)

* Sequence types marked as ``@cython.collection_type("sequence")`` that use C integers
  in the subscript special methods now implement only the sequence and not the mapping protocol.
  This allows subscripting code to avoid creating Python index objects when the index
  is already available as C integer.
  (Github issue https://github.com/cython/cython/issues/7435)

* The Py3.15 ``frozendict`` builtin type is supported and has been backported as an alias
  for ``dict`` in older Python versions.
  Patches to adapt existing ``dict`` optimisations were contributed by Omkar Kabde.
  (Github issues https://github.com/cython/cython/issues/7545, https://github.com/cython/cython/issues/7647)

* The Py3.15 ``sentinel`` builtin is supported and its C-API declarations are available in
  ``cpython.sentinel``.

* The builtin Python types ``int``, ``float``, ``str``, ``bytes`` and ``bytearray``
  are special cased in comparisons to speed them up.
  (Github issues https://github.com/cython/cython/issues/7452, https://github.com/cython/cython/issues/7474)

* The builtin Python types ``int`` and ``float`` are special cased in ``+``, ``-`` and ``*``
  operations with (compile-time) unknown Python types in order to speed them up.
  The bit operations ``^``, ``|`` and ``&`` are additionally special cased for ``int``.
  (Github issues https://github.com/cython/cython/issues/7485, https://github.com/cython/cython/issues/7541)

* ``<bool>`` casts can be used to convert C values to Python ``True`` / ``False``.
  (Github issue https://github.com/cython/cython/issues/7513)

* ``cdef`` property methods support setters.
  (Github issue https://github.com/cython/cython/issues/7505)

* The C ``restrict`` modifier can be used in declarations.
  (Github issue https://github.com/cython/cython/issues/7617)

* C arrays may now be declared with (``extern`` or internal) enum values as their size.
  (Github issues https://github.com/cython/cython/issues/7401, https://github.com/cython/cython/issues/7406)

* ``prange(num_threads=0)`` automatically selects the maximum number of OpenMP threads.
  (Github issue https://github.com/cython/cython/issues/7586)

* ``prange()`` and ``parallel()`` sections can be used without releasing the GIL, which
  helps in freethreading builds.  When releasing the GIL as part of the section declaration,
  re-acquiring it immediately inside is now faster, e.g. to do per-thread Python initialisations.
  (Github issue https://github.com/cython/cython/issues/6562)

* ``cython.pymutex`` and ``cython.pythread_type_lock`` now support a ``.locked()`` method
  to check if the lock is currently held without blocking. The method works on all Python
  versions using atomic reads on Python 3.13+ and a try-acquire approach on older versions.
  (Github issue https://github.com/cython/cython/issues/7275)

* A simpler mechanism was added for implementing C++ exception handlers in Cython code.
  (Github issues https://github.com/cython/cython/issues/7388, https://github.com/cython/cython/issues/7390)

* Repeated memoryview slicing inside of loops now avoids redundant reference counting,
  making it substantially faster.
  (Github issue https://github.com/cython/cython/issues/5507)

* Indexing into Cython memoryview objects from Python is faster.
  (Github issue https://github.com/cython/cython/issues/7529)

* Some internal call overhead in the memoryview code was removed.
  (Github issue https://github.com/cython/cython/issues/7609)

* Extension types use the vectorcall interface for their instantiation in many cases.
  This can be configured with a new C feature macro ``CYTHON_VECTORCALL_TPNEW``.
  (Github issue https://github.com/cython/cython/issues/7698)

* Coroutine methods use the faster vectorcall interface.
  (Github issue https://github.com/cython/cython/issues/7678)

* Vectorcalls with literal keyword arguments use cached constant keyword name tuples.
  (Github issue https://github.com/cython/cython/issues/7713)

* List comprehensions that generate new objects avoid refcounting overhead for appending.
  (Github issue https://github.com/cython/cython/issues/7748)

* Method calls in older Limited API versions are slightly faster.
  (Github issue https://github.com/cython/cython/issues/7707)

* C arrays are substituted for sequence iteration in more cases, also inside of generators.
  Ad-hoc C array storage on the stack and in closures was reworked along the way.
  (Github issues https://github.com/cython/cython/issues/7323, https://github.com/cython/cython/issues/7339)

* Unicode string comparisons to single character literals are faster.
  (Github issue https://github.com/cython/cython/issues/7418)

* F-strings are a little faster in some cases.
  (Github issues https://github.com/cython/cython/issues/7495, https://github.com/cython/cython/issues/7526)

* PyPy and GraalPython use the vectorcall protocol to enable faster Python calls in future releases.
  (Github issue https://github.com/cython/cython/issues/7614)

* The runtime conversion from a Python mapping to a C struct/union uses less code.
  (Github issue https://github.com/cython/cython/issues/7343)

* The error handling of memoryviews uses less code.
  (Github issue https://github.com/cython/cython/issues/7525)

* The runtime dispatch code of fused types uses less code.
  (Github issue https://github.com/cython/cython/issues/7501)

* More code is extracted to the shared utility code module.
  (Github issues https://github.com/cython/cython/issues/7556, https://github.com/cython/cython/issues/7570)

* Cython compiled functions have a more efficient memory layout in the Limited API.
  (Github issue https://github.com/cython/cython/issues/7519)

* Module string content is now compressed with LZSS by default, which reduces the footprint of the
  decompressor code compared to the 3.2.x default ``zlib``.  This also avoids a runtime dependency
  on the ``zlib`` module since the tiny LZSS decompressor can be embedded in the module.
  (Github issue https://github.com/cython/cython/issues/7577)

* The Py2 ``print`` statement is now implemented in Cython instead of C to make it
  thread-safe and uses a vectorcall into Python.
  (Github issue https://github.com/cython/cython/issues/7642)

* Several C++ exception declarations were added to ``libcpp.exceptions``.
  (Github issue https://github.com/cython/cython/issues/7389)

* Missing Python type flag declarations were added to ``cpython.object``.
  (Github issue https://github.com/cython/cython/issues/7441)

* Declarations for ``PyType_GetSlot()`` and the corresponding type slot IDs were added
  to ``cpython.type``.

* Declarations for specialised byte-conversion functions were added to ``cpython.long`` and ``cpython.float``.
  Patch by Valentin Valls.  (Github issue https://github.com/cython/cython/issues/7738)

* Error detection when assigning to ``const`` variables was improved.
  (Github issue https://github.com/cython/cython/issues/7359)

* Some cases of likely misuse of ``critical_section`` now generate warnings.
  (Github issue https://github.com/cython/cython/issues/6766)

* Programmatic use of Cython has become easier by avoiding the need to manually set up
  the error reporting.
  (Github issue https://github.com/cython/cython/issues/7235)

* Autoscaling in ``cymeit`` is a little faster.

* Unicode 17.0.0 is used to parse identifiers.

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

* Generated Cython language features like properties, auto-pickle or dataclasses
  now use a critical section (on the object itself) as guard for concurrent access.
  (Github issue https://github.com/cython/cython/issues/6621)

* The star-import implementation needlessly rejected several names in internal use.
  They are now allowed and become regular Python module attributes.
  (Github issue https://github.com/cython/cython/issues/4931)

* Mixing function signature declarations in Python modules and their ``.pxd`` modules could fail.
  (Github issues https://github.com/cython/cython/issues/5970, https://github.com/cython/cython/issues/4388)

* C array declarations with type and size could fail with an exception in pure Python code.
  (Github issue https://github.com/cython/cython/issues/7372)

* A ``const`` modifier in C++ template type arguments could be mapped incorrectly.
  (Github issue https://github.com/cython/cython/issues/6294)

* C++ ``typeid()`` failed to compile on more complex expressions.
  (Github issue https://github.com/cython/cython/issues/7069)

* Optimised Python ``int`` and ``float`` operations did not remember their result type,
  leading to less optimised code in longer expressions.
  (Github issues https://github.com/cython/cython/issues/7363, https://github.com/cython/cython/issues/7502)

* Slices as dictionary keys confused the type inference of item access.
  (Github issue https://github.com/cython/cython/issues/7702)

* A race condition when ``return``ing from a ``cython.parallel.parallel`` section was fixed.
  (Github issue https://github.com/cython/cython/issues/6521)

* Cython still used ``(type, exc, traceback)`` for saving and restoring exception state,
  even though modern CPython versions only store the exception object itself internally.
  This is now modernised in many places to reduce overhead.
  (Github issue https://github.com/cython/cython/issues/7481)

* Exceptions originating from the ``Py_UNICODE_IS*()`` character classification macros and
  the corresponding ``str.is*()`` methods, which they alias, were not handled but ignored in
  the Limited API.
  (Github issue https://github.com/cython/cython/issues/7602)

* In the Limited API, import time failures to create code objects for compiled functions,
  e.g. due to future Python API changes, are no longer fatal but generate a warning.
  (Github issue https://github.com/cython/cython/issues/5718)

* Several internal cases where exceptions are caught and discarded now propagate the
  ``BaseException`` errors and only discard the expected exceptions.
  (Github issue https://github.com/cython/cython/issues/7600)

* Error handling was improved when setting up the table of ``cdef`` methods for extension types
  and unexpected errors are propagated.
  (Github issue https://github.com/cython/cython/issues/7613)

* Exceptions while setting up the automatic pickle support are now propagated.
  (Github issue https://github.com/cython/cython/issues/7613)

* Exceptions thrown into async generators could leave the generator in an unclosed state.
  (Github issue https://github.com/cython/cython/issues/7618)

* In the Limited API, failures while formatting type names in exceptions are now uniformly handled.
  (Github issue https://github.com/cython/cython/issues/7680)

* The global module state struct now lives in an anonymous namespace in C++ mode to
  allow linking multiple modules together in one shared library file.
  (Github issue https://github.com/cython/cython/issues/7159)

* Dict iteration generates safer code in PyPy/GraalPy/free-threading.
  (Github issue https://github.com/cython/cython/issues/7637)

* The floating point parsing code relied on C implementation specific "pointer compare after free" behaviour.
  Patch by stratakis.  (Github issue https://github.com/cython/cython/issues/7463)

* When non-heap types were used as base classes of extension heap types, the heap types
  were not correctly reference counted by their instances.
  (Github issue https://github.com/cython/cython/issues/7483)

* The ``.__signatures__`` dict of fused functions is no longer writable.
  (Github issue https://github.com/cython/cython/issues/7386)

* A minimal implementation of ``.__annotate__`` was added to Cython compiled functions to make
  ``@functools.wraps`` work in Python 3.14+.
  (Github issue https://github.com/cython/cython/issues/7675)

* The ``--embed-positions`` option no longer includes absolute file paths in the C code.
  (Github issue https://github.com/cython/cython/issues/6755)

* Error reporting on missing braces in f-strings was misleading.
  (Github issue https://github.com/cython/cython/issues/7436)

* ``None`` default values for function arguments declared as ``not None`` are now rejected at compile time
  rather than leading to errors at runtime.
  Patch by Vyas Ramasubramani.  (Github issue https://github.com/cython/cython/issues/7762)

* Cython did not reject code with multiple contradicting type annotations on the same variable.
  (Github issue https://github.com/cython/cython/issues/7246)

* Cython no longer warns if ``@profile`` or ``@linetrace`` is applied to a function
  without changing the global/outer setting.  This avoids annoyance when users leave
  such redundant decorators in the code for occasional use.

* Cached methods of builtin types were not GC-traversed and cleaned up as part of the module state.
  Patch by Maxwell Bernstein.  (Github issue https://github.com/cython/cython/issues/7468)

* Modules with non-ASCII names could end up with UTF-8 characters in their C code.
  (Github issue https://github.com/cython/cython/issues/7588)

* Several C compiler warnings related to mixed signed/unsigned C integer usage were resolved.

* Includes all fixes as of Cython 3.2.6.

3.2.6 (2026-06-24):

* ``@functools.wraps()`` was broken in Py3.14+ for Cython compiled functions.
  (Github issue https://github.com/cython/cython/issues/7675)

* A double-free in the t-string code was fixed.
  (Github issue https://github.com/cython/cython/issues/7712)

* The ``-`` operator declarations for iterators in ``libcpp.vector`` we corrected.
  Patch by Vadim Markovtsev.  (Github issue https://github.com/cython/cython/issues/7717)

* The shared utility code module no longer uses a temporary file path that
  changed the C code on each generation.
  (Github issue https://github.com/cython/cython/issues/7723)

* On 32 bit platforms, cached constants are no longer made immortal during module import.
  (Github issue https://github.com/cython/cython/issues/7744)

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

* Support for Python 3.8 has been removed.
  As a side-effekt, support for StacklessPython and Pyston (last release was 3.8) was also removed.
  Python 3.9 is planned to remain supported for several years due to its use in LTS Linux distributions.
  (Github issue https://github.com/cython/cython/issues/7271)

* The vectorcall feature macros were unified to make ``CYTHON_VECTORCALL`` the only way to
  disable this feature (if need arises).  Previously the option macros ``CYTHON_METH_FASTCALL``,
  ``CYTHON_FAST_PYCALL`` and ``CYTHON_VECTORCALL`` all controlled different aspects of the
  implementation.
  (Github issue https://github.com/cython/cython/issues/7616)

* Coroutines no longer provide the legacy ``_is_coroutine`` property.
  (Github issue https://github.com/cython/cython/issues/7709)

* ``Cython/Shadow.pyi`` has been merged into ``Cython/Shadow.py``.
  (Github issue https://github.com/cython/cython/issues/7376)

* The documentation now uses the "Clarity" Sphinx theme.
  Patch by Libor Jelínek.  (Github issue https://github.com/cython/cython/issues/7564)
