CFFI release 0.3

Hi everybody,

We released CFFI 0.3. This is the first release that supports more than CPython 2.x :-)

• CPython 2.6, 2.7, and 3.x are supported (3.3 definitely, but maybe 3.2 or earlier too)
• PyPy trunk is supported.

In more details, the main news are:

• support for PyPy. You need to get a trunk version of PyPy, which comes with the built-in module _cffi_backend to use with the CFFI release. For testing, you can download the Linux 32/64 versions of PyPy trunk. The OS/X and Windows versions of _cffi_backend are not tested at all so far, so probably don't work yet.
• support for Python 3. It is unknown which exact version is required; probably 3.2 or even earlier, but we need 3.3 to run the tests. The 3.x version is not a separate source; it runs out of the same sources. Thanks Amaury for starting this port.
• the main change in the API is that you need to use ffi.string(cdata) instead of str(cdata) or unicode(cdata). The motivation for this change was the Python 3 compatibility. If your Python 2 code used to contain str(<cdata 'char *'>), it would interpret the memory content as a null-terminated string; but on Python 3 it would just return a different string, namely "<cdata 'char *'>", and proceed without even a crash, which is bad. So ffi.string() solves it by always returning the memory content as an 8-bit string (which is a str in Python 2 and a bytes in Python 3).
• other minor API changes are documented at http://cffi.readthedocs.org/ (grep for version 0.3).

Upcoming work, to be done before release 1.0:

• expose to the user the module cffi.model in a possibly refactored way, for people that don't like (or for some reason can't easily use) strings containing snippets of C declarations. We are thinking about refactoring it in such a way that it has a ctypes-compatible interface, to ease porting existing code from ctypes to cffi. Note that this would concern only the C type and function declarations, not all the rest of ctypes.
• CFFI 1.0 will also have a corresponding PyPy release. We are thinking about calling it PyPy 2.0 and including the whole of CFFI (instead of just the _cffi_backend module like now). In other words it will support CFFI out of the box --- we want to push forward usage of CFFI in PyPy :-)

Cheers,

Armin Rigo and Maciej Fijałkowski

CFFI release 0.2.1

Hi everybody,

We released CFFI 0.2.1 (expected to be 1.0 soon). CFFI is a way to call C from Python.

EDIT: Win32 was broken in 0.2. Fixed.

This release is only for CPython 2.6 or 2.7. PyPy support is coming in
the ffi-backend branch, but not finished yet. CPython 3.x would be
easy but requires the help of someone.

The package is available on bitbucket as well as documented. You
can also install it straight from the python package index: pip install cffi

• Contains numerous small changes and support for more C-isms.
• The biggest news is the support for installing packages that use
  ffi.verify() on machines without a C compiler. Arguably, this
  lifts the last serious restriction for people to use CFFI.
• Partial list of smaller changes:
  • mappings between 'wchar_t' and Python unicodes
  • the introduction of ffi.NULL
  • a possibly clearer API for ffi.new(): e.g. to allocate a single int and obtain a pointer to it, use ffi.new("int *") instead of the old
    ffi.new("int")
  • and of course a plethora of smaller bug fixes
• CFFI uses pkg-config to install itself if available. This helps
  locate libffi on modern Linuxes. Mac OS/X support is available too
  (see the detailed installation instructions). Win32 should work out
  of the box. Win64 has not been really tested yet.

Cheers,
Armin Rigo and Maciej Fijałkowski

Release 0.1 of CFFI

Hi.

We're pleased to announce the first public release, 0.1 of CFFI, a way to call C from Python.
(This release does not support PyPy yet --- but we announce it here as it is planned for the
next release :-)

The package is available on bitbucket as well as documented. You can also install it
straight from the python package index (pip).

The aim of this project is to provide a convenient and reliable way of calling C code from Python.
The interface is based on LuaJIT's FFI and follows a few principles:

• The goal is to call C code from Python. You should be able to do so
  without learning a 3rd language: every alternative requires you to learn
  their own language (Cython, SWIG) or API (ctypes). So we tried to
  assume that you know Python and C and minimize the extra bits of API that
  you need to learn.
• Keep all the Python-related logic in Python so that you don't need to
  write much C code (unlike CPython native C extensions).
• Work either at the level of the ABI (Application Binary Interface)
  or the API (Application Programming Interface). Usually, C
  libraries have a specified C API but often not an ABI (e.g. they may
  document a "struct" as having at least these fields, but maybe more).
  (ctypes works at the ABI level, whereas Cython or native C extensions
  work at the API level.)
• We try to be complete. For now some C99 constructs are not supported,
  but all C89 should be, including macros (and including macro "abuses",
  which you can manually wrap in saner-looking C functions).
• We attempt to support both PyPy and CPython (although PyPy support is not
  complete yet) with a reasonable path for other Python implementations like
  IronPython and Jython.
• Note that this project is not about embedding executable C code in
  Python, unlike Weave. This is about calling existing C libraries
  from Python.

Status of the project

Consider this as a beta release. Creating CPython extensions is fully supported and the API should
be relatively stable; however, minor adjustements of the API are possible.

PyPy support is not yet done and this is a goal for the next release. There are vague plans to make this the
preferred way to call C from Python that can reliably work between PyPy and CPython.

Right now CFFI's verify() requires a C compiler and header files to be available at run-time.
This limitation will be lifted in the near future and it'll contain a way to cache the resulting binary.

Cheers,

Armin Rigo and Maciej Fijałkowski