Hello community, here is the log from the commit of package python3-cffi for openSUSE:Factory checked in at 2016-05-25 21:27:50 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python3-cffi (Old) and /work/SRC/openSUSE:Factory/.python3-cffi.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python3-cffi" Changes: -------- New Changes file: --- /dev/null 2016-04-07 01:36:33.300037506 +0200 +++ /work/SRC/openSUSE:Factory/.python3-cffi.new/python3-cffi-doc.changes 2016-05-25 21:27:51.000000000 +0200 @@ -0,0 +1,350 @@ +------------------------------------------------------------------- +Wed May 18 19:33:12 UTC 2016 - [email protected] + +- Split documentation into own subpackage to speed up build. + +------------------------------------------------------------------- +Sun May 8 06:59:05 UTC 2016 - [email protected] + +- specfile: + * changed to https for source url + * updated source url to files.pythonhosted.org + + +------------------------------------------------------------------- +Sat Apr 23 16:14:54 UTC 2016 - [email protected] + +- update to version 1.6.0: + * ffi.list_types() + * ffi.unpack() + * extern “Python+C” + * in API mode, lib.foo.__doc__ contains the C signature now. On + CPython you can say help(lib.foo), but for some reason help(lib) + (or help(lib.foo) on PyPy) is still useless; I haven’t yet figured + out the hacks needed to convince pydoc to show more. (You can use + dir(lib) but it is not most helpful.) + * Yet another attempt at robustness of ffi.def_extern() against + CPython’s interpreter shutdown logic. + +- changes from version 1.5.2: + * Fix 1.5.1 for Python 2.6. + +------------------------------------------------------------------- +Sun Feb 14 02:03:18 UTC 2016 - [email protected] + +- update to version 1.5.2: + * Fix 1.5.1 for Python 2.6. + +- changes from version 1.5.1: + * A few installation-time tweaks (thanks Stefano!) + * Issue #245: Win32: __stdcall was never generated for extern + "Python" functions + * Issue #246: trying to be more robust against CPython’s fragile + interpreter shutdown logic + +------------------------------------------------------------------- +Sun Jan 17 20:48:16 UTC 2016 - [email protected] + +- specfile: + * update copyright year + +- update to version 1.5.0: + * Support for using CFFI for embedding. + +------------------------------------------------------------------- +Wed Dec 30 18:36:16 UTC 2015 - [email protected] + +- update to version 1.4.2: + * Nothing changed from v1.4.1. + +- changes from version 1.4.1: + * Fix the compilation failure of cffi on CPython 3.5.0. (3.5.1 + works; some detail changed that makes some underscore-starting + macros disappear from view of extension modules, and I worked + around it, thinking it changed in all 3.5 versions—but no: it was + only in 3.5.1.) + +- changes from version 1.4.0: + * A better way to do callbacks has been added (faster and more + portable, and usually cleaner). It is a mechanism for the + out-of-line API mode that replaces the dynamic creation of + callback objects (i.e. C functions that invoke Python) with the + static declaration in cdef() of which callbacks are needed. This + is more C-like, in that you have to structure your code around the + idea that you get a fixed number of function pointers, instead of + creating them on-the-fly. + * ffi.compile() now takes an optional verbose argument. When True, + distutils prints the calls to the compiler. + * ffi.compile() used to fail if given sources with a path that + includes "..". Fixed. + * ffi.init_once() added. See docs. + * dir(lib) now works on libs returned by ffi.dlopen() too. + * Cleaned up and modernized the content of the demo subdirectory in + the sources (thanks matti!). + * ffi.new_handle() is now guaranteed to return unique void * values, + even if called twice on the same object. Previously, in that case, + CPython would return two cdata objects with the same void * + value. This change is useful to add and remove handles from a + global dict (or set) without worrying about duplicates. It already + used to work like that on PyPy. This change can break code that + used to work on CPython by relying on the object to be kept alive + by other means than keeping the result of ffi.new_handle() + alive. (The corresponding warning in the docs of ffi.new_handle() + has been here since v0.8!) + +------------------------------------------------------------------- +Sun Nov 22 00:47:16 UTC 2015 - [email protected] + +- update to version 1.3.1: + * The optional typedefs (bool, FILE and all Windows types) were not + always available from out-of-line FFI objects. + * Opaque enums are phased out from the cdefs: they now give a + warning, instead of (possibly wrongly) being assumed equal to + unsigned int. Please report if you get a reasonable use case for + them. + * Some parsing details, notably volatile is passed along like const + and restrict. Also, older versions of pycparser mis-parse some + pointer-to-pointer types like char * const *: the “const” ends up + at the wrong place. Added a workaround. + +------------------------------------------------------------------- +Sun Nov 1 19:29:10 UTC 2015 - [email protected] + +- update to version 1.3.0: + * Added ffi.memmove(). + * Pull request #64: out-of-line API mode: we can now declare + floating-point types with typedef float... foo_t;. This only works + if foo_t is a float or a double, not long double. + * Issue #217: fix possible unaligned pointer manipulation, which + crashes on some architectures (64-bit, non-x86). + * Issues #64 and #126: when using set_source() or verify(), the + const and restrict keywords are copied from the cdef to the + generated C code; this fixes warnings by the C compiler. It also + fixes corner cases like typedef const int T; T a; which would + previously not consider a as a constant. (The cdata objects + themselves are never const.) + * Win32: support for __stdcall. For callbacks and function pointers; + regular C functions still don’t need to have their calling + convention declared. + * Windows: CPython 2.7 distutils doesn’t work with Microsoft’s + official Visual Studio for Python, and I’m told this is not a + bug. For ffi.compile(), we removed a workaround that was inside + cffi but which had unwanted side-effects. Try saying import + setuptools first, which patches distutils... + +- changes from version 1.2.1: + * Nothing changed from v1.2.0. + +- changes from version 1.2.0: + * Out-of-line mode: int a[][...]; can be used to declare a structure + field or global variable which is, simultaneously, of total length + unknown to the C compiler (the a[] part) and each element is + itself an array of N integers, where the value of N is known to + the C compiler (the int and [...] parts around it). Similarly, int + a[5][...]; is supported (but probably less useful: remember that + in C it means int (a[5])[...];). + * PyPy: the lib.some_function objects were missing the attributes + __name__, __module__ and __doc__ that are expected e.g. by some + decorators-management functions from functools. + * Out-of-line API mode: you can now do from _example.lib import x to + import the name x from _example.lib, even though the lib object is + not a standard module object. (Also works in from _example.lib + import *, but this is even more of a hack and will fail if lib + happens to declare a name called __all__. Note that * excludes the + global variables; only the functions and constants make sense to + import like this.) + * lib.__dict__ works again and gives you a copy of the dict—assuming + that lib has got no symbol called precisely __dict__. (In general, + it is safer to use dir(lib).) + * Out-of-line API mode: global variables are now fetched on demand + at every access. It fixes issue #212 (Windows DLL variables), and + also allows variables that are defined as dynamic macros (like + errno) or __thread -local variables. (This change might also + tighten the C compiler’s check on the variables’ type.) + * Issue #209: dereferencing NULL pointers now raises RuntimeError + instead of segfaulting. Meant as a debugging aid. The check is + only for NULL: if you dereference random or dead pointers you + might still get segfaults. + * Issue #152: callbacks: added an argument ffi.callback(..., + onerror=...). If the main callback function raises an exception + and onerror is provided, then onerror(exception, exc_value, + traceback) is called. This is similar to writing a try: except: in + the main callback function, but in some cases (e.g. a signal) an + exception can occur at the very start of the callback + function—before it had time to enter the try: except: block. + * Issue #115: added ffi.new_allocator(), which officializes support + for alternative allocators. + +------------------------------------------------------------------- +Mon Jun 15 02:13:07 UTC 2015 - [email protected] + +- update to version 1.1.2: + * ffi.gc(): fixed a race condition in multithreaded programs + introduced in 1.1.1 + +- changes from version 1.1.1: + * Out-of-line mode: ffi.string(), ffi.buffer() and ffi.getwinerror() + didn't accept their arguments as keyword arguments, unlike their + in-line mode equivalent. (It worked in PyPy.) + * Out-of-line ABI mode: documented a restriction of ffi.dlopen() + when compared to the in-line mode. + * ffi.gc(): when called several times with equal pointers, it was + accidentally registering only the last destructor, or even none at + all depending on details. (It was correctly registering all of + them only in PyPy, and only with the out-of-line FFIs.) + +------------------------------------------------------------------- +Sun May 31 16:34:10 UTC 2015 - [email protected] ++++ 153 more lines (skipped) ++++ between /dev/null ++++ and /work/SRC/openSUSE:Factory/.python3-cffi.new/python3-cffi-doc.changes --- /work/SRC/openSUSE:Factory/python3-cffi/python3-cffi.changes 2016-02-16 09:19:13.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python3-cffi.new/python3-cffi.changes 2016-05-25 21:27:51.000000000 +0200 @@ -1,0 +2,31 @@ +Wed May 18 19:33:12 UTC 2016 - [email protected] + +- Split documentation into own subpackage to speed up build. + +------------------------------------------------------------------- +Sun May 8 06:59:05 UTC 2016 - [email protected] + +- specfile: + * changed to https for source url + * updated source url to files.pythonhosted.org + + +------------------------------------------------------------------- +Sat Apr 23 16:14:54 UTC 2016 - [email protected] + +- update to version 1.6.0: + * ffi.list_types() + * ffi.unpack() + * extern “Python+C” + * in API mode, lib.foo.__doc__ contains the C signature now. On + CPython you can say help(lib.foo), but for some reason help(lib) + (or help(lib.foo) on PyPy) is still useless; I haven’t yet figured + out the hacks needed to convince pydoc to show more. (You can use + dir(lib) but it is not most helpful.) + * Yet another attempt at robustness of ffi.def_extern() against + CPython’s interpreter shutdown logic. + +- changes from version 1.5.2: + * Fix 1.5.1 for Python 2.6. + +------------------------------------------------------------------- Old: ---- cffi-1.5.2.tar.gz New: ---- cffi-1.6.0.tar.gz python3-cffi-doc.changes python3-cffi-doc.spec ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python3-cffi-doc.spec ++++++ # # spec file for package python3-cffi-doc # # Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed # upon. The license for this file, and modifications and additions to the # file, is the same license as for the pristine package itself (unless the # license for the pristine package is not an Open Source License, in which # case the license is the MIT License). An "Open Source License" is a # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. # Please submit bugfixes or comments via http://bugs.opensuse.org/ # Name: python3-cffi-doc Version: 1.6.0 Release: 0 Summary: Documentation for python3-cffi License: MIT Group: Documentation/HTML Url: http://cffi.readthedocs.org Source0: https://files.pythonhosted.org/packages/source/c/cffi/cffi-%{version}.tar.gz BuildRequires: python3-cffi BuildRequires: python3-Sphinx Recommends: python3-cffi BuildRoot: %{_tmppath}/%{name}-%{version}-build %description Documentation and help files for python3-cffi. %prep %setup -q -n cffi-%{version} %build # Not needed %install python3 setup.py build_sphinx rm build/sphinx/html/.buildinfo %files %defattr(-,root,root,-) %doc LICENSE %doc build/sphinx/html/ %changelog ++++++ python3-cffi.spec ++++++ --- /var/tmp/diff_new_pack.qH4Hq1/_old 2016-05-25 21:27:52.000000000 +0200 +++ /var/tmp/diff_new_pack.qH4Hq1/_new 2016-05-25 21:27:52.000000000 +0200 @@ -17,18 +17,16 @@ Name: python3-cffi -Version: 1.5.2 +Version: 1.6.0 Release: 0 Summary: Foreign Function Interface for Python calling C code License: MIT Group: Development/Languages/Python Url: http://cffi.readthedocs.org -Source0: http://pypi.python.org/packages/source/c/cffi/cffi-%{version}.tar.gz +Source0: https://files.pythonhosted.org/packages/source/c/cffi/cffi-%{version}.tar.gz BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: pkgconfig(libffi) -# Documentation requirements: -BuildRequires: python3-Sphinx # Test requirements: BuildRequires: gcc-c++ BuildRequires: python3-pycparser @@ -45,7 +43,6 @@ %build CFLAGS="%{optflags}" python3 setup.py build -python3 setup.py build_sphinx && rm build/sphinx/html/.buildinfo %install python3 setup.py install --prefix=%{_prefix} --root=%{buildroot} @@ -55,7 +52,7 @@ %files %defattr(-,root,root,-) -%doc LICENSE build/sphinx/html/ +%doc LICENSE %{python3_sitearch}/* %changelog ++++++ cffi-1.5.2.tar.gz -> cffi-1.6.0.tar.gz ++++++ ++++ 3181 lines of diff (skipped)
