Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-cymem for openSUSE:Factory
checked in at 2023-09-20 13:26:04
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-cymem (Old)
and /work/SRC/openSUSE:Factory/.python-cymem.new.16627 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-cymem"
Wed Sep 20 13:26:04 2023 rev:2 rq:1111927 version:2.0.8
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-cymem/python-cymem.changes
2023-08-08 15:54:53.780978993 +0200
+++ /work/SRC/openSUSE:Factory/.python-cymem.new.16627/python-cymem.changes
2023-09-20 13:27:58.120020963 +0200
@@ -1,0 +2,6 @@
+Mon Sep 18 09:22:35 UTC 2023 - Dirk Müller <dmuel...@suse.com>
+
+- update to 2.0.8:
+ * Python 3.12 support
+
+-------------------------------------------------------------------
Old:
----
cymem-2.0.7.tar.gz
New:
----
cymem-2.0.8.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-cymem.spec ++++++
--- /var/tmp/diff_new_pack.7U4NLB/_old 2023-09-20 13:27:59.200059655 +0200
+++ /var/tmp/diff_new_pack.7U4NLB/_new 2023-09-20 13:27:59.200059655 +0200
@@ -18,7 +18,7 @@
%{?sle15_python_module_pythons}
Name: python-cymem
-Version: 2.0.7
+Version: 2.0.8
Release: 0
Summary: Manage calls to calloc/free through Cython
License: MIT
++++++ cymem-2.0.7.tar.gz -> cymem-2.0.8.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/cymem-2.0.7/PKG-INFO new/cymem-2.0.8/PKG-INFO
--- old/cymem-2.0.7/PKG-INFO 2022-10-14 14:12:04.716015300 +0200
+++ new/cymem-2.0.8/PKG-INFO 2023-09-15 15:59:17.093226700 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: cymem
-Version: 2.0.7
+Version: 2.0.8
Summary: Manage calls to calloc/free through Cython
Home-page: https://github.com/explosion/cymem
Author: Matthew Honnibal
@@ -25,6 +25,7 @@
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: Topic :: Scientific/Engineering
Description-Content-Type: text/markdown
License-File: LICENSE
@@ -33,11 +34,11 @@
# cymem: A Cython Memory Helper
-cymem provides two small memory-management helpers for Cython. They make it
-easy to tie memory to a Python object's life-cycle, so that the memory is freed
-when the object is garbage collected.
+cymem provides two small memory-management helpers for Cython. They make it
easy
+to tie memory to a Python object's life-cycle, so that the memory is freed when
+the object is garbage collected.
-[](https://dev.azure.com/explosion-ai/public/_build?definitionId=2)
+[](https://github.com/explosion/cymem/actions/workflows/tests.yml)
[](https://pypi.python.org/pypi/cymem)
[](https://anaconda.org/conda-forge/cymem)
[](https://github.com/explosion/wheelwright/releases)
@@ -58,13 +59,15 @@
object is garbage collected. Typically you'll attach the `Pool` to some cdef'd
class. This is particularly handy for deeply nested structs, which have
complicated initialization functions. Just pass the `Pool` object into the
-initializer, and you don't have to worry about freeing your struct at all â
-all of the calls to `Pool.alloc` will be automatically freed when the `Pool`
+initializer, and you don't have to worry about freeing your struct at all â
all
+of the calls to `Pool.alloc` will be automatically freed when the `Pool`
expires.
## Installation
-Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
[Cython](http://cython.org). Before installing, make sure that your `pip`,
`setuptools` and `wheel` are up to date.
+Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
+[Cython](http://cython.org). Before installing, make sure that your `pip`,
+`setuptools` and `wheel` are up to date.
```bash
pip install -U pip setuptools wheel
@@ -73,10 +76,10 @@
## Example Use Case: An array of structs
-Let's say we want a sequence of sparse matrices. We need fast access, and
-a Python list isn't performing well enough. So, we want a C-array or C++
-vector, which means we need the sparse matrix to be a C-level struct â it
-can't be a Python class. We can write this easily enough in Cython:
+Let's say we want a sequence of sparse matrices. We need fast access, and a
+Python list isn't performing well enough. So, we want a C-array or C++ vector,
+which means we need the sparse matrix to be a C-level struct â it can't be a
+Python class. We can write this easily enough in Cython:
```python
"""Example without Cymem
@@ -144,9 +147,9 @@
free(sm)
```
-We wrap the data structure in a Python ref-counted class at as low a level as
-we can, given our performance constraints. This allows us to allocate and free
-the memory in the `__cinit__` and `__dealloc__` Cython special methods.
+We wrap the data structure in a Python ref-counted class at as low a level as
we
+can, given our performance constraints. This allows us to allocate and free the
+memory in the `__cinit__` and `__dealloc__` Cython special methods.
However, it's very easy to make mistakes when writing the `__dealloc__` and
`sparse_matrix_free` functions, leading to memory leaks. cymem prevents you
from
@@ -210,15 +213,15 @@
```
All that the `Pool` class does is remember the addresses it gives out. When the
-`MatrixArray` object is garbage-collected, the `Pool` object will also be
garbage
-collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then frees
all of
-its addresses. This saves you from walking back over your nested data
structures
-to free them, eliminating a common class of errors.
+`MatrixArray` object is garbage-collected, the `Pool` object will also be
+garbage collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then
+frees all of its addresses. This saves you from walking back over your nested
+data structures to free them, eliminating a common class of errors.
## Custom Allocators
-Sometimes external C libraries use private functions to allocate and free
objects,
-but we'd still like the laziness of the `Pool`.
+Sometimes external C libraries use private functions to allocate and free
+objects, but we'd still like the laziness of the `Pool`.
```python
from cymem.cymem cimport Pool, WrapMalloc, WrapFree
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/cymem-2.0.7/README.md new/cymem-2.0.8/README.md
--- old/cymem-2.0.7/README.md 2022-10-14 14:11:54.000000000 +0200
+++ new/cymem-2.0.8/README.md 2023-09-15 15:59:00.000000000 +0200
@@ -2,11 +2,11 @@
# cymem: A Cython Memory Helper
-cymem provides two small memory-management helpers for Cython. They make it
-easy to tie memory to a Python object's life-cycle, so that the memory is freed
-when the object is garbage collected.
+cymem provides two small memory-management helpers for Cython. They make it
easy
+to tie memory to a Python object's life-cycle, so that the memory is freed when
+the object is garbage collected.
-[](https://dev.azure.com/explosion-ai/public/_build?definitionId=2)
+[](https://github.com/explosion/cymem/actions/workflows/tests.yml)
[](https://pypi.python.org/pypi/cymem)
[](https://anaconda.org/conda-forge/cymem)
[](https://github.com/explosion/wheelwright/releases)
@@ -27,13 +27,15 @@
object is garbage collected. Typically you'll attach the `Pool` to some cdef'd
class. This is particularly handy for deeply nested structs, which have
complicated initialization functions. Just pass the `Pool` object into the
-initializer, and you don't have to worry about freeing your struct at all â
-all of the calls to `Pool.alloc` will be automatically freed when the `Pool`
+initializer, and you don't have to worry about freeing your struct at all â
all
+of the calls to `Pool.alloc` will be automatically freed when the `Pool`
expires.
## Installation
-Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
[Cython](http://cython.org). Before installing, make sure that your `pip`,
`setuptools` and `wheel` are up to date.
+Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
+[Cython](http://cython.org). Before installing, make sure that your `pip`,
+`setuptools` and `wheel` are up to date.
```bash
pip install -U pip setuptools wheel
@@ -42,10 +44,10 @@
## Example Use Case: An array of structs
-Let's say we want a sequence of sparse matrices. We need fast access, and
-a Python list isn't performing well enough. So, we want a C-array or C++
-vector, which means we need the sparse matrix to be a C-level struct â it
-can't be a Python class. We can write this easily enough in Cython:
+Let's say we want a sequence of sparse matrices. We need fast access, and a
+Python list isn't performing well enough. So, we want a C-array or C++ vector,
+which means we need the sparse matrix to be a C-level struct â it can't be a
+Python class. We can write this easily enough in Cython:
```python
"""Example without Cymem
@@ -113,9 +115,9 @@
free(sm)
```
-We wrap the data structure in a Python ref-counted class at as low a level as
-we can, given our performance constraints. This allows us to allocate and free
-the memory in the `__cinit__` and `__dealloc__` Cython special methods.
+We wrap the data structure in a Python ref-counted class at as low a level as
we
+can, given our performance constraints. This allows us to allocate and free the
+memory in the `__cinit__` and `__dealloc__` Cython special methods.
However, it's very easy to make mistakes when writing the `__dealloc__` and
`sparse_matrix_free` functions, leading to memory leaks. cymem prevents you
from
@@ -179,15 +181,15 @@
```
All that the `Pool` class does is remember the addresses it gives out. When the
-`MatrixArray` object is garbage-collected, the `Pool` object will also be
garbage
-collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then frees
all of
-its addresses. This saves you from walking back over your nested data
structures
-to free them, eliminating a common class of errors.
+`MatrixArray` object is garbage-collected, the `Pool` object will also be
+garbage collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then
+frees all of its addresses. This saves you from walking back over your nested
+data structures to free them, eliminating a common class of errors.
## Custom Allocators
-Sometimes external C libraries use private functions to allocate and free
objects,
-but we'd still like the laziness of the `Pool`.
+Sometimes external C libraries use private functions to allocate and free
+objects, but we'd still like the laziness of the `Pool`.
```python
from cymem.cymem cimport Pool, WrapMalloc, WrapFree
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/cymem-2.0.7/cymem/about.py
new/cymem-2.0.8/cymem/about.py
--- old/cymem-2.0.7/cymem/about.py 2022-10-14 14:11:54.000000000 +0200
+++ new/cymem-2.0.8/cymem/about.py 2023-09-15 15:59:00.000000000 +0200
@@ -1,5 +1,5 @@
__title__ = "cymem"
-__version__ = "2.0.7"
+__version__ = "2.0.8"
__summary__ = "Manage calls to calloc/free through Cython"
__uri__ = "https://github.com/explosion/cymem";
__author__ = "Matthew Honnibal"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/cymem-2.0.7/cymem.egg-info/PKG-INFO
new/cymem-2.0.8/cymem.egg-info/PKG-INFO
--- old/cymem-2.0.7/cymem.egg-info/PKG-INFO 2022-10-14 14:12:04.000000000
+0200
+++ new/cymem-2.0.8/cymem.egg-info/PKG-INFO 2023-09-15 15:59:17.000000000
+0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: cymem
-Version: 2.0.7
+Version: 2.0.8
Summary: Manage calls to calloc/free through Cython
Home-page: https://github.com/explosion/cymem
Author: Matthew Honnibal
@@ -25,6 +25,7 @@
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: Topic :: Scientific/Engineering
Description-Content-Type: text/markdown
License-File: LICENSE
@@ -33,11 +34,11 @@
# cymem: A Cython Memory Helper
-cymem provides two small memory-management helpers for Cython. They make it
-easy to tie memory to a Python object's life-cycle, so that the memory is freed
-when the object is garbage collected.
+cymem provides two small memory-management helpers for Cython. They make it
easy
+to tie memory to a Python object's life-cycle, so that the memory is freed when
+the object is garbage collected.
-[](https://dev.azure.com/explosion-ai/public/_build?definitionId=2)
+[](https://github.com/explosion/cymem/actions/workflows/tests.yml)
[](https://pypi.python.org/pypi/cymem)
[](https://anaconda.org/conda-forge/cymem)
[](https://github.com/explosion/wheelwright/releases)
@@ -58,13 +59,15 @@
object is garbage collected. Typically you'll attach the `Pool` to some cdef'd
class. This is particularly handy for deeply nested structs, which have
complicated initialization functions. Just pass the `Pool` object into the
-initializer, and you don't have to worry about freeing your struct at all â
-all of the calls to `Pool.alloc` will be automatically freed when the `Pool`
+initializer, and you don't have to worry about freeing your struct at all â
all
+of the calls to `Pool.alloc` will be automatically freed when the `Pool`
expires.
## Installation
-Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
[Cython](http://cython.org). Before installing, make sure that your `pip`,
`setuptools` and `wheel` are up to date.
+Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
+[Cython](http://cython.org). Before installing, make sure that your `pip`,
+`setuptools` and `wheel` are up to date.
```bash
pip install -U pip setuptools wheel
@@ -73,10 +76,10 @@
## Example Use Case: An array of structs
-Let's say we want a sequence of sparse matrices. We need fast access, and
-a Python list isn't performing well enough. So, we want a C-array or C++
-vector, which means we need the sparse matrix to be a C-level struct â it
-can't be a Python class. We can write this easily enough in Cython:
+Let's say we want a sequence of sparse matrices. We need fast access, and a
+Python list isn't performing well enough. So, we want a C-array or C++ vector,
+which means we need the sparse matrix to be a C-level struct â it can't be a
+Python class. We can write this easily enough in Cython:
```python
"""Example without Cymem
@@ -144,9 +147,9 @@
free(sm)
```
-We wrap the data structure in a Python ref-counted class at as low a level as
-we can, given our performance constraints. This allows us to allocate and free
-the memory in the `__cinit__` and `__dealloc__` Cython special methods.
+We wrap the data structure in a Python ref-counted class at as low a level as
we
+can, given our performance constraints. This allows us to allocate and free the
+memory in the `__cinit__` and `__dealloc__` Cython special methods.
However, it's very easy to make mistakes when writing the `__dealloc__` and
`sparse_matrix_free` functions, leading to memory leaks. cymem prevents you
from
@@ -210,15 +213,15 @@
```
All that the `Pool` class does is remember the addresses it gives out. When the
-`MatrixArray` object is garbage-collected, the `Pool` object will also be
garbage
-collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then frees
all of
-its addresses. This saves you from walking back over your nested data
structures
-to free them, eliminating a common class of errors.
+`MatrixArray` object is garbage-collected, the `Pool` object will also be
+garbage collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then
+frees all of its addresses. This saves you from walking back over your nested
+data structures to free them, eliminating a common class of errors.
## Custom Allocators
-Sometimes external C libraries use private functions to allocate and free
objects,
-but we'd still like the laziness of the `Pool`.
+Sometimes external C libraries use private functions to allocate and free
+objects, but we'd still like the laziness of the `Pool`.
```python
from cymem.cymem cimport Pool, WrapMalloc, WrapFree
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/cymem-2.0.7/setup.py new/cymem-2.0.8/setup.py
--- old/cymem-2.0.7/setup.py 2022-10-14 14:11:54.000000000 +0200
+++ new/cymem-2.0.8/setup.py 2023-09-15 15:59:00.000000000 +0200
@@ -5,8 +5,8 @@
import sys
import contextlib
from setuptools import Extension, setup, find_packages
-from distutils.command.build_ext import build_ext
-from distutils.sysconfig import get_python_inc
+from setuptools.command.build_ext import build_ext
+from sysconfig import get_path
from Cython.Build import cythonize
@@ -76,7 +76,7 @@
with io.open(os.path.join(root, "README.md"), encoding="utf8") as f:
readme = f.read()
- include_dirs = [get_python_inc(plat_specific=True)]
+ include_dirs = [get_path("include")]
ext_modules = []
for mod_name in MOD_NAMES:
@@ -122,6 +122,7 @@
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering",
],
cmdclass={"build_ext": build_ext_subclass},
