Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-tinyarray for
openSUSE:Factory checked in at 2026-03-14 22:22:32
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-tinyarray (Old)
and /work/SRC/openSUSE:Factory/.python-tinyarray.new.8177 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-tinyarray"
Sat Mar 14 22:22:32 2026 rev:7 rq:1338816 version:1.2.5
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-tinyarray/python-tinyarray.changes
2025-05-09 18:53:14.909796769 +0200
+++
/work/SRC/openSUSE:Factory/.python-tinyarray.new.8177/python-tinyarray.changes
2026-03-14 22:23:42.912411486 +0100
@@ -1,0 +2,7 @@
+Fri Mar 13 20:47:27 UTC 2026 - Dirk Müller <[email protected]>
+
+- update to 1.2.5:
+ * Adapt tests to Numpy 2
+ * use Py_ssize_t everywhere
+
+-------------------------------------------------------------------
Old:
----
tinyarray-1.2.4.tar.gz
New:
----
tinyarray-1.2.5.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-tinyarray.spec ++++++
--- /var/tmp/diff_new_pack.SqKAiv/_old 2026-03-14 22:23:43.372430541 +0100
+++ /var/tmp/diff_new_pack.SqKAiv/_new 2026-03-14 22:23:43.376430708 +0100
@@ -1,7 +1,7 @@
#
# spec file for package python-tinyarray
#
-# Copyright (c) 2025 SUSE LLC
+# Copyright (c) 2026 SUSE LLC and contributors
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -18,7 +18,7 @@
%define skip_python36 1
Name: python-tinyarray
-Version: 1.2.4
+Version: 1.2.5
Release: 0
Summary: Arrays of numbers for Python, optimized for small sizes
License: BSD-2-Clause
++++++ tinyarray-1.2.4.tar.gz -> tinyarray-1.2.5.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/.gitignore
new/tinyarray-1.2.5/.gitignore
--- old/tinyarray-1.2.4/.gitignore 1970-01-01 01:00:00.000000000 +0100
+++ new/tinyarray-1.2.5/.gitignore 2024-01-02 19:17:40.000000000 +0100
@@ -0,0 +1,8 @@
+*~
+*.pyc
+*.so
+build.conf
+/tinyarray.egg-info/
+/build/
+/dist/
+/src/version.hh
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/.gitlab-ci.yml
new/tinyarray-1.2.5/.gitlab-ci.yml
--- old/tinyarray-1.2.4/.gitlab-ci.yml 1970-01-01 01:00:00.000000000 +0100
+++ new/tinyarray-1.2.5/.gitlab-ci.yml 2019-12-30 09:55:51.000000000 +0100
@@ -0,0 +1,31 @@
+image: kwant/tinyarray-testing
+
+stages:
+ - test
+ - deploy
+
+python2:
+ script:
+ - python2 setup.py build_ext -i
+ - python2 test_tinyarray.py
+
+python3:
+ script:
+ - python3 setup.py build_ext -i
+ - python3 test_tinyarray.py
+
+create conda dev package:
+ image: condaforge/linux-anvil
+ stage: deploy
+ only:
+ - master@kwant/tinyarray
+ script:
+ - git clone https://gitlab.kwant-project.org/kwant/conda-recipes.git
+ - conda build -c conda-forge --python 3.4 conda-recipes/tinyarray-dev
+ - conda build -c conda-forge --python 3.5 conda-recipes/tinyarray-dev
+ - conda build -c conda-forge --python 3.6 conda-recipes/tinyarray-dev
+ - mv /opt/conda/conda-bld/linux-64/tinyarray-dev*.tar.bz2 .
+ - anaconda --token=$ANACONDA_TOKEN upload --force tinyarray-dev*tar.bz2
+ artifacts:
+ paths:
+ - tinyarray-dev*.tar.bz2
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/PKG-INFO new/tinyarray-1.2.5/PKG-INFO
--- old/tinyarray-1.2.4/PKG-INFO 2021-12-17 14:55:14.558119000 +0100
+++ new/tinyarray-1.2.5/PKG-INFO 2025-07-26 13:12:37.940868400 +0200
@@ -1,30 +1,12 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.1
Name: tinyarray
-Version: 1.2.4
+Version: 1.2.5
Summary: Arrays of numbers for Python, optimized for small sizes
Home-page: https://gitlab.kwant-project.org/kwant/tinyarray
+Download-URL: http://downloads.kwant-project.org/tinyarray/
Author: Christoph Groth (CEA) and others
Author-email: [email protected]
License: Simplified BSD license
-Download-URL: http://downloads.kwant-project.org/tinyarray/
-Description: Tinyarrays are similar to NumPy arrays, but optimized for small
sizes.
- Common operations on very small arrays are to 3-7 times faster than
with
- NumPy (with NumPy 1.6 it used to be up to 35 times), and 3 times less
- memory is used to store them. Tinyarrays are useful if you need many
- small arrays of numbers, and cannot combine them into a few large ones.
- (The resulting code is still much slower than C, but it may now be fast
- enough.)
-
- Unlike Python's built-in tuples, Tinyarrays support mathematical
- operations like element-wise addition and matrix multiplication.
Unlike
- Numpy arrays, Tinyarrays can be used as dictionary keys because they
are
- hashable and immutable. What is more, tinyarrays are equivalent to
- tuples with regard to hashing and comparisons: a dictionary or set with
- tinyarray keys may by transparently indexed by tuples.
-
- The module's interface is a subset of that of NumPy and thus should be
- familiar to many. Whenever an operation is missing from Tinyarray,
- NumPy functions can be used directly with Tinyarrays.
Platform: Unix
Platform: Linux
Platform: Mac OS-X
@@ -42,3 +24,23 @@
Classifier: Operating System :: Unix
Classifier: Operating System :: MacOS
Classifier: Operating System :: Microsoft :: Windows
+License-File: LICENSE.rst
+
+Tinyarrays are similar to NumPy arrays, but optimized for small sizes.
+Common operations on very small arrays are to 3-7 times faster than with
+NumPy (with NumPy 1.6 it used to be up to 35 times), and 3 times less
+memory is used to store them. Tinyarrays are useful if you need many
+small arrays of numbers, and cannot combine them into a few large ones.
+(The resulting code is still much slower than C, but it may now be fast
+enough.)
+
+Unlike Python's built-in tuples, Tinyarrays support mathematical
+operations like element-wise addition and matrix multiplication. Unlike
+Numpy arrays, Tinyarrays can be used as dictionary keys because they are
+hashable and immutable. What is more, tinyarrays are equivalent to
+tuples with regard to hashing and comparisons: a dictionary or set with
+tinyarray keys may by transparently indexed by tuples.
+
+The module's interface is a subset of that of NumPy and thus should be
+familiar to many. Whenever an operation is missing from Tinyarray,
+NumPy functions can be used directly with Tinyarrays.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/src/array.cc
new/tinyarray-1.2.5/src/array.cc
--- old/tinyarray-1.2.4/src/array.cc 2021-12-16 16:46:04.000000000 +0100
+++ new/tinyarray-1.2.5/src/array.cc 2024-01-02 19:17:40.000000000 +0100
@@ -459,7 +459,7 @@
case 'Q':
return number_from_ptr<T, unsigned long long>;
case 'n':
- return number_from_ptr<T, ssize_t>;
+ return number_from_ptr<T, Py_ssize_t>;
case 'N':
return number_from_ptr<T, size_t>;
case 'f':
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/src/array.hh
new/tinyarray-1.2.5/src/array.hh
--- old/tinyarray-1.2.4/src/array.hh 2017-05-22 14:59:27.000000000 +0200
+++ new/tinyarray-1.2.5/src/array.hh 2024-01-02 19:17:40.000000000 +0100
@@ -105,7 +105,7 @@
}
}
- ssize_t object_size() const;
+ Py_ssize_t object_size() const;
static bool check_exact(PyObject *candidate) {
return (Py_TYPE(candidate) == &pytype);
@@ -160,7 +160,7 @@
template <typename T> PyObject *transpose(PyObject *in, PyObject *dummy);
template <typename T>
-ssize_t Array<T>::object_size() const
+Py_ssize_t Array<T>::object_size() const
{
int ndim;
size_t *shape;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/test_tinyarray.py
new/tinyarray-1.2.5/test_tinyarray.py
--- old/tinyarray-1.2.4/test_tinyarray.py 2021-12-16 16:46:04.000000000
+0100
+++ new/tinyarray-1.2.5/test_tinyarray.py 2025-04-25 15:47:37.000000000
+0200
@@ -7,7 +7,8 @@
# top-level directory of this distribution and at
# https://gitlab.kwant-project.org/kwant/tinyarray.
-import operator, warnings
+import operator
+import warnings
import platform
import itertools as it
import tinyarray as ta
@@ -32,15 +33,24 @@
else:
raise RuntimeError('unknown architecture', bits)
+
dtypes = [int, float, complex]
some_shapes = [(), 0, 1, 2, 3,
(0, 0), (1, 0), (0, 1), (2, 2), (17, 17),
(0, 0, 0), (1, 1, 1), (2, 2, 1), (2, 0, 3)]
+sizeof_c_long = ctypes.sizeof(ctypes.c_long)
+
+if np.array(0).itemsize == sizeof_c_long:
+ np_int_dtype = int
+else:
+ # Special case for NumPy 2 on Windows.
+ np_int_dtype = eval('np.int' + str(sizeof_c_long * 8))
+
def make(shape, dtype):
- result = np.arange(np.prod(shape), dtype=int)
+ result = np.arange(np.prod(shape), dtype=np_int_dtype)
if dtype in (float, complex):
result = result + 0.1 * result
if dtype == complex:
@@ -51,7 +61,7 @@
def shape_of_seq(seq, r=()):
try:
l = len(seq)
- except:
+ except Exception:
return r
if l == 0:
return r + (0,)
@@ -169,7 +179,7 @@
# Determine maximum value of the C "long" type. This is different from
# sys.maxsize, notably on 64 bit Windows.
- maxlong = 2 ** (ctypes.sizeof(ctypes.c_long) * 8 - 1) - 1
+ maxlong = 2 ** (sizeof_c_long * 8 - 1) - 1
# Check correct overflow detection when integers are used to initialize
# integer tinyarrays.
@@ -206,7 +216,7 @@
if dtype is not float:
# This solicitates the buffer interface.
x = np.array(x)
- assert(x.dtype == dtype)
+ assert x.dtype == dtype
raises(OverflowError, ta.array, x, int)
for x in [-n, min(n-1, np.nextafter(n, 0, dtype=dtype))]:
@@ -215,7 +225,7 @@
if dtype is not float:
# This solicitates the buffer interface.
x = np.array(x)
- assert(x.dtype == dtype)
+ assert x.dtype == dtype
ta.array(x, int)
@@ -387,7 +397,6 @@
assert_equal(op(ta.array(a), ta.array(b)), op(a, b))
-
def test_binary_ufuncs():
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=RuntimeWarning)
@@ -431,12 +440,12 @@
else:
assert ta_func(a.tolist()) == np_func(a)
for x in [-987654322.5, -987654321.5, -4.51, -3.51, -2.5, -2.0,
- -1.7, -1.5, -0.5, -0.3, -0.0, 0.0, 0.3, 0.5, 1.5, 1.7,
- 2.0, 2.5, 3.51, 4.51, 987654321.5, 987654322.5]:
+ -1.7, -1.5, -0.5, -0.3, -0.0, 0.0, 0.3, 0.5, 1.5, 1.7,
+ 2.0, 2.5, 3.51, 4.51, 987654321.5, 987654322.5]:
if x == -0.5 and name == "round":
- # Work around an inconsistency in NumPy: on Unix,
np.round(-0.5)
- # is -0.0, and on Windows it is 0.0, while np.ceil(-0.5) is
-0.0
- # always.
+ # Work around an inconsistency in NumPy: on Unix,
+ # np.round(-0.5) is -0.0, and on Windows it is 0.0, while
+ # np.ceil(-0.5) is -0.0 always.
assert ta.round(-0.5) == -0.0
else:
assert ta_func(x) == np_func(x)
@@ -452,8 +461,7 @@
def test_sizeof():
- obj = object()
- word_size = machine_wordsize()
+ wordsize = machine_wordsize()
for shape in some_shapes:
for dtype in dtypes:
a = ta.zeros(shape, dtype)
@@ -463,7 +471,7 @@
# if the array is > 1D then the shape is stored
# at the start of the buffer
if len(a.shape) > 1:
- n_elements += (a.ndim * machine_wordsize() +
+ n_elements += (a.ndim * wordsize +
ta.dtype_size[dtype] - 1) //
ta.dtype_size[dtype]
buffer_size = n_elements * ta.dtype_size[dtype]
@@ -471,7 +479,7 @@
# debug mode.
debug = hasattr(sys, "gettotalrefcount")
sizeof_should_be = (buffer_size
- + machine_wordsize() * (5 if debug else 3))
+ + wordsize * (5 if debug else 3))
assert sizeof == sizeof_should_be
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/tinyarray.egg-info/PKG-INFO
new/tinyarray-1.2.5/tinyarray.egg-info/PKG-INFO
--- old/tinyarray-1.2.4/tinyarray.egg-info/PKG-INFO 2021-12-17
14:55:14.000000000 +0100
+++ new/tinyarray-1.2.5/tinyarray.egg-info/PKG-INFO 2025-07-26
13:12:37.000000000 +0200
@@ -1,30 +1,12 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.1
Name: tinyarray
-Version: 1.2.4
+Version: 1.2.5
Summary: Arrays of numbers for Python, optimized for small sizes
Home-page: https://gitlab.kwant-project.org/kwant/tinyarray
+Download-URL: http://downloads.kwant-project.org/tinyarray/
Author: Christoph Groth (CEA) and others
Author-email: [email protected]
License: Simplified BSD license
-Download-URL: http://downloads.kwant-project.org/tinyarray/
-Description: Tinyarrays are similar to NumPy arrays, but optimized for small
sizes.
- Common operations on very small arrays are to 3-7 times faster than
with
- NumPy (with NumPy 1.6 it used to be up to 35 times), and 3 times less
- memory is used to store them. Tinyarrays are useful if you need many
- small arrays of numbers, and cannot combine them into a few large ones.
- (The resulting code is still much slower than C, but it may now be fast
- enough.)
-
- Unlike Python's built-in tuples, Tinyarrays support mathematical
- operations like element-wise addition and matrix multiplication.
Unlike
- Numpy arrays, Tinyarrays can be used as dictionary keys because they
are
- hashable and immutable. What is more, tinyarrays are equivalent to
- tuples with regard to hashing and comparisons: a dictionary or set with
- tinyarray keys may by transparently indexed by tuples.
-
- The module's interface is a subset of that of NumPy and thus should be
- familiar to many. Whenever an operation is missing from Tinyarray,
- NumPy functions can be used directly with Tinyarrays.
Platform: Unix
Platform: Linux
Platform: Mac OS-X
@@ -42,3 +24,23 @@
Classifier: Operating System :: Unix
Classifier: Operating System :: MacOS
Classifier: Operating System :: Microsoft :: Windows
+License-File: LICENSE.rst
+
+Tinyarrays are similar to NumPy arrays, but optimized for small sizes.
+Common operations on very small arrays are to 3-7 times faster than with
+NumPy (with NumPy 1.6 it used to be up to 35 times), and 3 times less
+memory is used to store them. Tinyarrays are useful if you need many
+small arrays of numbers, and cannot combine them into a few large ones.
+(The resulting code is still much slower than C, but it may now be fast
+enough.)
+
+Unlike Python's built-in tuples, Tinyarrays support mathematical
+operations like element-wise addition and matrix multiplication. Unlike
+Numpy arrays, Tinyarrays can be used as dictionary keys because they are
+hashable and immutable. What is more, tinyarrays are equivalent to
+tuples with regard to hashing and comparisons: a dictionary or set with
+tinyarray keys may by transparently indexed by tuples.
+
+The module's interface is a subset of that of NumPy and thus should be
+familiar to many. Whenever an operation is missing from Tinyarray,
+NumPy functions can be used directly with Tinyarrays.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/tinyarray.egg-info/SOURCES.txt
new/tinyarray-1.2.5/tinyarray.egg-info/SOURCES.txt
--- old/tinyarray-1.2.4/tinyarray.egg-info/SOURCES.txt 2021-12-17
14:55:14.000000000 +0100
+++ new/tinyarray-1.2.5/tinyarray.egg-info/SOURCES.txt 2025-07-26
13:12:37.000000000 +0200
@@ -1,3 +1,5 @@
+.gitignore
+.gitlab-ci.yml
LICENSE.rst
MANIFEST.in
README.rst
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/tinyarray-1.2.4/version new/tinyarray-1.2.5/version
--- old/tinyarray-1.2.4/version 2021-12-17 14:55:14.562119000 +0100
+++ new/tinyarray-1.2.5/version 2025-07-26 13:12:37.940868400 +0200
@@ -1,2 +1,2 @@
# This file has been generated by setup.py.
-1.2.4
+1.2.5
