array-split 0.6.4__tar.gz → 0.7.1__tar.gz

{array_split-0.6.4 → array_split-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: array_split
-Version: 0.6.4
+Version: 0.7.1
 Summary: The array_split python package is an enhancement to existing numpy.ndarray functions (such as numpy.array_split) which sub-divide a multi-dimensional array into a number of multi-dimensional sub-arrays (slices)
 Author-email: Shane-J-Latham <array.split@gmail.com>, array-split <array.split@gmail.com>
 License: Copyright (C) 2017 The Australian National University.
@@ -31,6 +31,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Requires-Dist: numpy>=1.6
+Dynamic: license-file
 
 
 =============

{array_split-0.6.4 → array_split-0.7.1}/array_split/__init__.py

@@ -60,11 +60,13 @@ Attributes
 
 
 """
-from __future__ import absolute_import
-from .license import license as _license, copyright as _copyright
-from . import split  # noqa: E402,F401
-from .split import array_split, shape_split, ShapeSplitter  # noqa: E402,F401
-from . import _version
+
+from . import (
+    _version,
+    split,
+)
+from .license import copyright as _copyright, license as _license
+from .split import ShapeSplitter, array_split, shape_split  # noqa: F401
 
 __author__ = "Shane J. Latham"
 __license__ = _license()

{array_split-0.6.4 → array_split-0.7.1}/array_split/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-08-04T15:27:48+1000",
+ "date": "2026-10-10T18:49:13+1100",
  "dirty": false,
  "error": null,
- "full-revisionid": "a5b1cb7c6fbd1db5829249f13a00b42267ac865e",
- "version": "0.6.4"
+ "full-revisionid": "c83a57c07a2873a72c451ec55c9088f6938cbe87",
+ "version": "0.7.1"
 }
 '''  # END VERSION_JSON
 

{array_split-0.6.4 → array_split-0.7.1}/array_split/license.py

@@ -2,17 +2,17 @@
 To be replaced.
 """
 # pylint: disable=redefined-builtin
-from __future__ import absolute_import
-import pkg_resources as _pkg_resources
+from importlib.resources import files
+
 from . import _version
 
-__copyright__ = _pkg_resources.resource_string("array_split", "copyright.txt").decode()
+__copyright__ = files("array_split").joinpath("copyright.txt").read_bytes().decode()
 __license__ = (
     __copyright__
     +
     "\n\n"
     +
-    _pkg_resources.resource_string("array_split", "license.txt").decode()
+    files("array_split").joinpath("license.txt").read_bytes().decode()
 )
 __author__ = "Shane J. Latham"
 __version__ = _version.get_versions()['version']
@@ -78,6 +78,6 @@ Functions
    copyright - Returns :mod:`array_split` copyright string.
    version - Returns :mod:`array_split` version string.
 
-""" % (license(), copyright())
+""" % (license(), copyright())  # noqa: UP031
 
 __all__ = [s for s in dir() if not s.startswith('_')]

{array_split-0.6.4 → array_split-0.7.1}/array_split/logging.py

@@ -26,12 +26,11 @@ Classes and Functions
 # pylint: disable=wildcard-import
 # pylint: disable=invalid-name
 
-from __future__ import absolute_import
-
-import sys
 import logging as _builtin_logging
-from logging import *  # noqa: F401,F403
-from .license import license as _license, copyright as _copyright, version as _version
+import sys
+from logging import *
+
+from .license import copyright as _copyright, license as _license, version as _version
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
@@ -39,66 +38,7 @@ __copyright__ = _copyright()
 __version__ = _version()
 
 
-class _Python2SplitStreamHandler(_builtin_logging.Handler):
-
-    """
-    A python :obj:`logging.handlers` :samp:`Handler` class for
-    splitting logging messages to different streams depending on
-    the logging-level.
-    """
-
-    def __init__(self, outstr=sys.stdout, errstr=sys.stderr, splitlevel=_builtin_logging.WARNING):
-        """
-        Initialise with a pair of streams and a threshold level which determines
-        the stream where the messages are writting.
-
-        :type outstr: file-like
-        :param outstr: Logging messages are written to this stream if
-           the message level is less than :samp:`self.splitLevel`.
-        :type errstr: stream
-        :param errstr: Logging messages are written to this stream if
-           the message level is greater-than-or-equal-to :samp:`self.splitLevel`.
-        :type splitlevel: int
-        :param splitlevel: Logging level threshold determining split streams for log messages.
-        """
-        self.outStream = outstr
-        self.errStream = errstr
-        self.splitLevel = splitlevel
-        _builtin_logging.Handler.__init__(self)
-
-    def emit(self, record):
-        """
-        Mostly copy-paste from :obj:`logging.StreamHandler`.
-        """
-        try:
-            msg = self.format(record)
-            if record.levelno < self.splitLevel:
-                stream = self.outStream
-            else:
-                stream = self.errStream
-            fs = "%s\n"
-
-            try:
-                if (isinstance(msg, unicode) and  # noqa: F405
-                        getattr(stream, 'encoding', None)):
-                    ufs = fs.decode(stream.encoding)
-                    try:
-                        stream.write(ufs % msg)
-                    except UnicodeEncodeError:
-                        stream.write((ufs % msg).encode(stream.encoding))
-                else:
-                    stream.write(fs % msg)
-            except UnicodeError:
-                stream.write(fs % msg.encode("UTF-8"))
-
-            stream.flush()
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except Exception:
-            self.handleError(record)
-
-
-class _Python3SplitStreamHandler(_builtin_logging.Handler):
+class SplitStreamHandler(_builtin_logging.Handler):
 
     """
     A python :obj:`logging.handlers` :samp:`Handler` class for
@@ -162,28 +102,10 @@ class _Python3SplitStreamHandler(_builtin_logging.Handler):
             self.flush()
         except (KeyboardInterrupt, SystemExit):  # pragma: no cover
             raise
-        except Exception:
+        except Exception:  # noqa: BLE001
             self.handleError(record)
 
 
-if sys.version_info[0] <= 2:
-    class SplitStreamHandler(_Python2SplitStreamHandler):
-
-        """
-        To be replaced.
-        """
-
-        __doc__ = _Python2SplitStreamHandler.__doc__
-else:
-    class SplitStreamHandler(_Python3SplitStreamHandler):
-
-        """
-        To be replaced.
-        """
-
-        __doc__ = _Python3SplitStreamHandler.__doc__
-
-
 def get_formatter(prefix_string="ARRSPLT| "):
     """
     Returns :obj:`logging.Formatter` object which produces messages

{array_split-0.6.4 → array_split-0.7.1}/array_split/split.py

@@ -40,10 +40,10 @@ Utilities
    pad_with_none - End pads a sequence with :samp:`None` elements.
 
 """
-from __future__ import absolute_import
 import numpy as _np
-from .license import license as _license, copyright as _copyright, version as _version
+
 from . import logging as _logging
+from .license import copyright as _copyright, license as _license, version as _version
 
 __copyright__ = _copyright()
 __version__ = _version()
@@ -151,9 +151,7 @@ def pad_with_object(sequence, new_length, obj=None):
             list(sequence) + [obj, ] * (new_length - len(sequence))
     elif len(sequence) > new_length:
         raise ValueError(
-            "Got len(sequence)=%s which exceeds new_length=%s"
-            %
-            (len(sequence), new_length)
+            f"Got len(sequence)={len(sequence)} which exceeds new_length={new_length}"
         )
 
     return sequence
@@ -302,12 +300,8 @@ def calculate_tile_shape_for_max_bytes(
 
     if _np.any(array_shape < sub_tile_shape):
         raise ValueError(
-            "Got array_shape=%s element less than corresponding sub_tile_shape=%s element."
-            %
-            (
-                array_shape,
-                sub_tile_shape
-            )
+            f"Got array_shape={array_shape} element less than corresponding"
+            f" sub_tile_shape={sub_tile_shape} element."
         )
 
     logger.debug("max_tile_shape=%s", max_tile_shape)
@@ -448,19 +442,15 @@ def calculate_num_slices_per_axis(num_slices_per_axis, num_slices, max_slices_pe
     max_slices_per_axis = _np.array(max_slices_per_axis)
 
     if _np.any(max_slices_per_axis <= 0):
-        raise ValueError("Got non-positive value in max_slices_per_axis=%s" % max_slices_per_axis)
+        raise ValueError(f"Got non-positive value in max_slices_per_axis={max_slices_per_axis}")
 
     while _np.any(ret_array <= 0):
         prd = _np.prod(ret_array[_np.where(ret_array > 0)])  # returns 1 for zero-length array
         if (num_slices < prd) or ((num_slices % prd) > 0):
             raise ValueError(
-                (
-                    "Unable to construct grid of num_slices=%s elements from "
-                    +
-                    "num_slices_per_axis=%s (with max_slices_per_axis=%s)"
-                )
-                %
-                (num_slices, num_slices_per_axis, max_slices_per_axis)
+                f"Unable to construct grid of num_slices={num_slices} elements from "
+                f"num_slices_per_axis={num_slices_per_axis}"
+                f" (with max_slices_per_axis={max_slices_per_axis})"
             )
         ridx = _np.where(ret_array <= 0)
         f = shape_factors(num_slices // prd, ridx[0].shape[0])[::-1]
@@ -634,15 +624,13 @@ def convert_halo_to_array_form(halo, ndim):
 
     if halo.shape[0] != ndim:
         raise ValueError(
-            "Got halo.shape=%s, expecting halo.shape=(%s, 2)"
-            %
-            (halo.shape, ndim)
+            f"Got halo.shape={halo.shape}, expecting halo.shape=({ndim}, 2)"
         )
 
     return halo
 
 
-class ShapeSplitter(object):
+class ShapeSplitter:
 
     """
     Implements array shape splitting. There are three main (top-level) methods:
@@ -687,7 +675,7 @@ class ShapeSplitter(object):
 
     #: Class attribute indicating list of valid values for :attr:`tile_bound_policy`.
     #: See :data:`ARRAY_BOUNDS` and :data:`NO_BOUNDS`.
-    valid_tile_bounds_policies = [ARRAY_BOUNDS, NO_BOUNDS]
+    valid_tile_bounds_policies = (ARRAY_BOUNDS, NO_BOUNDS)
 
     def __init__(
         self,
@@ -1026,9 +1014,8 @@ class ShapeSplitter(object):
         """
         if self.tile_bounds_policy not in self.valid_tile_bounds_policies:
             raise ValueError(
-                "Got self.tile_bounds_policy=%s, which is not in %s."
-                %
-                (self.tile_bounds_policy, self.valid_tile_bounds_policies)
+                f"Got self.tile_bounds_policy={self.tile_bounds_policy},"
+                f" which is not in {self.valid_tile_bounds_policies}."
             )
 
     def check_consistent_parameter_dimensions(self):
@@ -1038,55 +1025,55 @@ class ShapeSplitter(object):
 
         :raises ValueError: For inconsistent parameter dimensions.
         """
-        if self.indices_per_axis is not None:
-            if len(self.indices_per_axis) > len(self.array_shape):
-                raise ValueError(
-                    "Got len(self.indices_per_axis)=%s > len(self.array_shape)=%s, should be equal."
-                    %
-                    (len(self.indices_per_axis), len(self.array_shape))
-                )
-        if self.split_num_slices_per_axis is not None:
-            if len(self.split_num_slices_per_axis) > len(self.array_shape):
-                raise ValueError(
-                    (
-                        "Got len(self.split_num_slices_per_axis)=%s > len(self.array_shape)=%s,"
-                        +
-                        " should be equal."
-                    )
-                    %
-                    (len(self.split_num_slices_per_axis), len(self.array_shape))
-                )
-        if self.tile_shape is not None:
-            if len(self.tile_shape) != len(self.array_shape):
-                raise ValueError(
-                    "Got len(self.tile_shape)=%s > len(self.array_shape)=%s, should be equal."
-                    %
-                    (len(self.tile_shape), len(self.array_shape))
-                )
+        if (
+            (self.indices_per_axis is not None)
+            and
+            (len(self.indices_per_axis) > len(self.array_shape))
+        ):
+            raise ValueError(
+                f"Got len(self.indices_per_axis)={len(self.indices_per_axis)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
+        if (
+            (self.split_num_slices_per_axis is not None)
+            and
+            (len(self.split_num_slices_per_axis) > len(self.array_shape))
+        ):
+            raise ValueError(
+                f"Got len(self.split_num_slices_per_axis)={len(self.split_num_slices_per_axis)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
+        if (self.tile_shape is not None) and (len(self.tile_shape) != len(self.array_shape)):
+            raise ValueError(
+                f"Got len(self.tile_shape)={len(self.tile_shape)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
 
-        if self.sub_tile_shape is not None:
-            if len(self.sub_tile_shape) != len(self.array_shape):
-                raise ValueError(
-                    "Got len(self.sub_tile_shape)=%s > len(self.array_shape)=%s, should be equal."
-                    %
-                    (len(self.sub_tile_shape), len(self.array_shape))
-                )
+        if (
+            (self.sub_tile_shape is not None)
+            and
+            (len(self.sub_tile_shape) != len(self.array_shape))
+        ):
+            raise ValueError(
+                f"Got len(self.sub_tile_shape)={len(self.sub_tile_shape)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
 
-        if self.max_tile_shape is not None:
-            if len(self.max_tile_shape) != len(self.array_shape):
-                raise ValueError(
-                    "Got len(self.max_tile_shape)=%s > len(self.array_shape)=%s, should be equal."
-                    %
-                    (len(self.max_tile_shape), len(self.array_shape))
-                )
+        if (
+            (self.max_tile_shape is not None)
+            and
+            (len(self.max_tile_shape) != len(self.array_shape))
+        ):
+            raise ValueError(
+                f"Got len(self.max_tile_shape)={len(self.max_tile_shape)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
 
-        if self.array_start is not None:
-            if len(self.array_start) != len(self.array_shape):
-                raise ValueError(
-                    "Got len(self.array_start)=%s > len(self.array_shape)=%s, should be equal."
-                    %
-                    (len(self.array_start), len(self.array_shape))
-                )
+        if (self.array_start is not None) and (len(self.array_start) != len(self.array_shape)):
+            raise ValueError(
+                f"Got len(self.array_start)={len(self.array_start)}"
+                f" > len(self.array_shape)={len(self.array_shape)}, should be equal."
+            )
 
     def check_consistent_parameter_grouping(self):
         """
@@ -1111,11 +1098,11 @@ class ShapeSplitter(object):
             parameter_groups["max_tile_bytes"] = \
                 {"self.max_tile_bytes": self.max_tile_bytes}
         if self.max_tile_shape is not None:
-            if "max_tile_bytes" not in parameter_groups.keys():
+            if "max_tile_bytes" not in parameter_groups:
                 parameter_groups["max_tile_bytes"] = {}
             parameter_groups["max_tile_bytes"]["self.max_tile_shape"] = self.max_tile_shape
         if self.sub_tile_shape is not None:
-            if "max_tile_bytes" not in parameter_groups.keys():
+            if "max_tile_bytes" not in parameter_groups:
                 parameter_groups["max_tile_bytes"] = {}
             parameter_groups["max_tile_bytes"]["self.sub_tile_shape"] = self.sub_tile_shape
 
@@ -1132,7 +1119,7 @@ class ShapeSplitter(object):
                     "\n".join(
                         [
                             (
-                                ("Group %18s: " % ("'%s'" % group_key))
+                                f"Group {group_key!r:>18}: "
                                 +
                                 str(parameter_groups[group_key])
                             )
@@ -1251,11 +1238,11 @@ class ShapeSplitter(object):
                     _np.array(
                         _np.unravel_index(
                             _np.arange(0, _np.prod(self.split_shape)),
-                            self.split_shape if self.split_shape is not None else tuple()
+                            self.split_shape if self.split_shape is not None else ()
                         )
                     ).T
                 ],
-                dtype=[("%d" % d, "object") for d in range(len(self.split_shape))]
+                dtype=[(f"{d:d}", "object") for d in range(len(self.split_shape))]
             ).reshape(self.split_shape)
 
         return ret
@@ -1303,11 +1290,11 @@ class ShapeSplitter(object):
                     _np.array(
                         _np.unravel_index(
                             _np.arange(0, _np.prod(self.split_shape)),
-                            self.split_shape if self.split_shape is not None else tuple()
+                            self.split_shape if self.split_shape is not None else ()
                         )
                     ).T
                 ],
-                dtype=[("%d" % d, "2int64") for d in range(len(self.split_shape))]
+                dtype=[(f"{d:d}", "2int64") for d in range(len(self.split_shape))]
             ).reshape(self.split_shape)
 
         return ret
@@ -1533,7 +1520,7 @@ Initialises parameters which define a split.
 
 .. seealso:: :ref:`array_split-examples`
 
-""" % (
+""" % (  # noqa: UP031
     _array_shape_param_doc,
     (
         _ShapeSplitter__init__params_doc
@@ -1573,7 +1560,7 @@ Splits specified :samp:`{array_shape}` in tiles, returns array of :obj:`slice` t
    :ref:`array_split-examples`
 
 
-""" % (
+""" % (  # noqa: UP031
         _array_shape_param_doc,
         (
             _ShapeSplitter__init__params_doc
@@ -1599,7 +1586,7 @@ def array_split(
     halo=None
 ):
     "To be replaced."
-    return list(
+    return [
         ary[slyce]
         for slyce in
         shape_split(
@@ -1615,7 +1602,7 @@ def array_split(
             halo=halo,
             tile_bounds_policy=ARRAY_BOUNDS
         ).flatten().tolist()
-    )
+    ]
 
 
 array_split.__doc__ =\

{array_split-0.6.4 → array_split-0.7.1}/array_split/split_plot.py

@@ -16,9 +16,7 @@ Classes and Functions
 
 """
 
-from __future__ import absolute_import
-
-from .license import license as _license, copyright as _copyright, version as _version
+from .license import copyright as _copyright, license as _license, version as _version
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
@@ -26,15 +24,15 @@ __copyright__ = _copyright()
 __version__ = _version()
 
 
-class SplitPlotter(object):
+class SplitPlotter:
     """
     Plots a split.
     """
 
     def __init__(self):
         """
+        Initialise.
         """
-        pass
 
 
 def plot(split):

{array_split-0.6.4 → array_split-0.7.1}/array_split/split_test.py

@@ -23,18 +23,24 @@ Classes
 
 
 """
-from __future__ import absolute_import
-import array_split as _array_split
 import numpy as _np
 
-from .license import license as _license, copyright as _copyright, version as _version
-from . import unittest as _unittest
-from . import logging as _logging
+import array_split as _array_split
 
-from .split import ShapeSplitter, array_split, shape_split
-from .split import calculate_num_slices_per_axis, shape_factors
-from .split import calculate_tile_shape_for_max_bytes, pad_with_object, convert_halo_to_array_form
-from .split import ARRAY_BOUNDS, NO_BOUNDS
+from . import logging as _logging, unittest as _unittest
+from .license import copyright as _copyright, license as _license, version as _version
+from .split import (
+    ARRAY_BOUNDS,
+    NO_BOUNDS,
+    ShapeSplitter,
+    array_split,
+    calculate_num_slices_per_axis,
+    calculate_tile_shape_for_max_bytes,
+    convert_halo_to_array_form,
+    pad_with_object,
+    shape_factors,
+    shape_split,
+)
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
@@ -1424,7 +1430,7 @@ class SplitTest(_unittest.TestCase):
             split[4, 0].tolist()
         )
         for i in range(5, 8):
-            for j in range(0, 12):
+            for j in range(12):
                 self.assertEqual(
                     slice(5, 5, None),
                     split[i, j].tolist()[0]
@@ -1437,7 +1443,7 @@ class SplitTest(_unittest.TestCase):
                     ),
                     split[i, j].tolist()
                 )
-        for i in range(0, 5):
+        for i in range(5):
             for j in range(12, 15):
                 self.assertEqual(
                     slice(12, 12, None),

{array_split-0.6.4 → array_split-0.7.1}/array_split/tests.py

@@ -24,17 +24,16 @@ Classes and Functions
 
 """
 # pylint: disable=unused-import
-from __future__ import absolute_import
-import sys as _sys
-import re as _re
-import unittest as _unittest
 import doctest as _doctest
 import os.path
+import re as _re
+import unittest as _unittest
+
 import array_split as _array_split
 from array_split import split as _split
 
-from .license import license as _license, copyright as _copyright, version as _version
-from .split_test import SplitTest  # noqa: F401,F403
+from .license import copyright as _copyright, license as _license, version as _version
+from .split_test import SplitTest  # noqa: F401
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
@@ -53,15 +52,11 @@ class MultiPlatformAnd23Checker(_doctest_OuputChecker):
 
     def check_output(self, want, got, optionflags):
         """
-        For python-2 replaces "124L" with "124". For python 2 and 3,
-        replaces :samp:`", dtype=int64)"` with :samp:`")"`.
+        Replaces :samp:`", dtype=int64)"` with :samp:`")"`.
 
         See :meth:`doctest.OutputChecker.check_output`.
 
         """
-        if _sys.version_info[0] <= 2:
-            got = _re.sub("([0-9]+)L", "\\1", got)
-
         got = _re.sub(", dtype=int64\\)", ")", got)
 
         return _doctest_OuputChecker.check_output(self, want, got, optionflags)

array_split-0.7.1/array_split/unittest.py

@@ -0,0 +1,184 @@
+"""
+======================================
+The :mod:`array_split.unittest` Module
+======================================
+
+Some simple wrappers of python built-in :mod:`unittest` module
+for :mod:`array_split` unit-tests.
+
+.. currentmodule:: array_split.unittest
+
+Classes and Functions
+=====================
+
+.. autosummary::
+   :toctree: generated/
+
+   main - Convenience command-line test-case *search and run* function.
+   TestCase - Extends :obj:`unittest.TestCase` with :obj:`TestCase.assertArraySplitEqual`.
+
+"""
+
+import unittest as _builtin_unittest
+
+import numpy as _np
+
+from . import logging as _logging
+from .license import copyright as _copyright, license as _license, version as _version
+
+__author__ = "Shane J. Latham"
+__license__ = _license()
+__copyright__ = _copyright()
+__version__ = _version()
+
+# pylint: disable=invalid-name
+# pylint: disable=arguments-differ
+# pylint: disable=trailing-whitespace
+# pylint: disable=no-member
+# pylint: disable=deprecated-method
+# pylint: disable=broad-except
+# pylint: disable=too-many-locals
+# pylint: disable=protected-access
+# pylint: disable=too-many-branches
+
+
+def main(module_name, log_level=_logging.DEBUG, init_logger_names=None):
+    """
+    Small wrapper for :func:`unittest.main` which initialises :mod:`logging.Logger` objects.
+    Loads a set of tests from module and runs them;
+    this is primarily for making test modules conveniently executable.
+    The simplest use for this function is to include the following line at
+    the end of a test module::
+
+       array_split.unittest.main(__name__)
+
+    If :samp:`__name__ == "__main__"`, then *discoverable* :obj:`unittest.TestCase`
+    test cases are executed.
+    Logging level can be explicitly set for a group of modules using::
+
+       import logging
+
+       array_split.unittest.main(
+           __name__,
+           logging.DEBUG,
+           [__name__, "module_name_0", "module_name_1", "package.module_name_2"]
+       )
+
+
+    :type module_name: :obj:`str`
+    :param module_name: If :samp:`{module_name} == "__main__"` then unit-tests
+       are *discovered* and run.
+    :type log_level: :obj:`int`
+    :param log_level: The default logging level for all
+       :obj:`array_split.logging.Logger` objects.
+    :type init_logger_names: sequence of :obj:`str`
+    :param init_logger_names: List of logger names to initialise
+       (using :func:`array_split.logging.initialise_loggers`). If :samp:`None`,
+       then the list defaults to :samp:`[{module_name}, "array_split"]`. If list
+       is empty no loggers are initialised.
+
+    """
+    if module_name == "__main__":
+        if init_logger_names is None:
+            init_logger_names = [module_name, "array_split"]
+
+        if len(init_logger_names) > 0:
+            _logging.initialise_loggers(
+                init_logger_names, log_level=log_level)
+
+        _builtin_unittest.main()
+
+
+def _fix_docstring_for_sphinx(docstr):
+    """
+    Remove 8-space indentation from lines of specified :samp:`{docstr}` string.
+    """
+    lines = docstr.split("\n")
+    for i in range(len(lines)):
+        if lines[i].find(" " * 8) == 0:
+            lines[i] = lines[i][8:]
+    return "\n".join(lines)
+
+
+class TestCase(_builtin_unittest.TestCase):
+
+    """
+    Extends :obj:`unittest.TestCase` with the :meth:`assertArraySplitEqual`.
+    """
+
+    def assertArraySplitEqual(self, splt1, splt2):
+        """
+        Compares :obj:`list` of :obj:`numpy.ndarray` results returned by :func:`numpy.array_split`
+        and :func:`array_split.split.array_split` functions.
+
+        :type splt1: :obj:`list` of :obj:`numpy.ndarray`
+        :param splt1: First object in equality comparison.
+        :type splt2: :obj:`list` of :obj:`numpy.ndarray`
+        :param splt2: Second object in equality comparison.
+        :raises unittest.AssertionError: If any element of :samp:`{splt1}` is not equal to
+            the corresponding element of :samp:`splt2`.
+        """
+        self.assertEqual(len(splt1), len(splt2))
+        for i in range(len(splt1)):
+            self.assertTrue(
+                (
+                    _np.all(_np.array(splt1[i]) == _np.array(splt2[i]))
+                    or
+                    ((_np.array(splt1[i]).size == 0) and (_np.array(splt2[i]).size == 0))
+                ),
+                msg=(
+                    f"element {i:d} of split is not equal"
+                    f" {_np.array(splt1[i])} != {_np.array(splt2[i])}"
+                )
+            )
+
+    #
+    # Method over-rides below are just to avoid sphinx warnings
+    #
+    def assertItemsEqual(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertItemsEqual`.
+        """
+        _builtin_unittest.TestCase.assertItemsEqual(self, *args, **kwargs)
+
+    def assertListEqual(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertListEqual`.
+        """
+        _builtin_unittest.TestCase.assertListEqual(self, *args, **kwargs)
+
+    def assertRaisesRegexp(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertRaisesRegexp`.
+        """
+        _builtin_unittest.TestCase.assertRaisesRegexp(self, *args, **kwargs)
+
+    def assertRaisesRegex(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertRaisesRegex`.
+        """
+        _builtin_unittest.TestCase.assertRaisesRegex(self, *args, **kwargs)
+
+    def assertSetEqual(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertSetEqual`.
+        """
+        _builtin_unittest.TestCase.assertSetEqual(self, *args, **kwargs)
+
+    def assertTupleEqual(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertTupleEqual`.
+        """
+        _builtin_unittest.TestCase.assertTupleEqual(self, *args, **kwargs)
+
+    def assertWarnsRegex(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertWarnsRegex`.
+        """
+        _builtin_unittest.TestCase.assertWarnsRegex(self, *args, **kwargs)
+
+    def assertSequenceEqual(self, *args, **kwargs):
+        """
+        See :obj:`unittest.TestCase.assertSequenceEqual`.
+        """
+        _builtin_unittest.TestCase.assertSequenceEqual(self, *args, **kwargs)

{array_split-0.6.4 → array_split-0.7.1}/array_split.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: array-split
-Version: 0.6.4
+Metadata-Version: 2.4
+Name: array_split
+Version: 0.7.1
 Summary: The array_split python package is an enhancement to existing numpy.ndarray functions (such as numpy.array_split) which sub-divide a multi-dimensional array into a number of multi-dimensional sub-arrays (slices)
 Author-email: Shane-J-Latham <array.split@gmail.com>, array-split <array.split@gmail.com>
 License: Copyright (C) 2017 The Australian National University.
@@ -31,6 +31,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Requires-Dist: numpy>=1.6
+Dynamic: license-file
 
 
 =============

{array_split-0.6.4 → array_split-0.7.1}/pyproject.toml

@@ -46,3 +46,10 @@ versionfile_source = "array_split/_version.py"
 versionfile_build = "array_split/_version.py"
 tag_prefix = "v"
 parentdir_prefix = "array_split-"
+
+[tool.ruff]
+# Generated by versioneer.
+extend-exclude = ["array_split/_version.py"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true

array_split-0.6.4/array_split/unittest.py

@@ -1,352 +0,0 @@
-"""
-======================================
-The :mod:`array_split.unittest` Module
-======================================
-
-Some simple wrappers of python built-in :mod:`unittest` module
-for :mod:`array_split` unit-tests.
-
-.. currentmodule:: array_split.unittest
-
-Classes and Functions
-=====================
-
-.. autosummary::
-   :toctree: generated/
-
-   main - Convenience command-line test-case *search and run* function.
-   TestCase - Extends :obj:`unittest.TestCase` with :obj:`TestCase.assertArraySplitEqual`.
-
-"""
-from __future__ import absolute_import
-
-import unittest as _builtin_unittest
-import numpy as _np
-from .license import license as _license, copyright as _copyright, version as _version
-from . import logging as _logging
-
-__author__ = "Shane J. Latham"
-__license__ = _license()
-__copyright__ = _copyright()
-__version__ = _version()
-
-# pylint: disable=invalid-name
-# pylint: disable=arguments-differ
-# pylint: disable=trailing-whitespace
-# pylint: disable=no-member
-# pylint: disable=deprecated-method
-# pylint: disable=broad-except
-# pylint: disable=too-many-locals
-# pylint: disable=protected-access
-# pylint: disable=too-many-branches
-
-
-def main(module_name, log_level=_logging.DEBUG, init_logger_names=None):
-    """
-    Small wrapper for :func:`unittest.main` which initialises :mod:`logging.Logger` objects.
-    Loads a set of tests from module and runs them;
-    this is primarily for making test modules conveniently executable.
-    The simplest use for this function is to include the following line at
-    the end of a test module::
-
-       array_split.unittest.main(__name__)
-
-    If :samp:`__name__ == "__main__"`, then *discoverable* :obj:`unittest.TestCase`
-    test cases are executed.
-    Logging level can be explicitly set for a group of modules using::
-
-       import logging
-
-       array_split.unittest.main(
-           __name__,
-           logging.DEBUG,
-           [__name__, "module_name_0", "module_name_1", "package.module_name_2"]
-       )
-
-
-    :type module_name: :obj:`str`
-    :param module_name: If :samp:`{module_name} == "__main__"` then unit-tests
-       are *discovered* and run.
-    :type log_level: :obj:`int`
-    :param log_level: The default logging level for all
-       :obj:`array_split.logging.Logger` objects.
-    :type init_logger_names: sequence of :obj:`str`
-    :param init_logger_names: List of logger names to initialise
-       (using :func:`array_split.logging.initialise_loggers`). If :samp:`None`,
-       then the list defaults to :samp:`[{module_name}, "array_split"]`. If list
-       is empty no loggers are initialised.
-
-    """
-    if module_name == "__main__":
-        if init_logger_names is None:
-            init_logger_names = [module_name, "array_split"]
-
-        if len(init_logger_names) > 0:
-            _logging.initialise_loggers(
-                init_logger_names, log_level=log_level)
-
-        _builtin_unittest.main()
-
-
-def _fix_docstring_for_sphinx(docstr):
-    """
-    Remove 8-space indentation from lines of specified :samp:`{docstr}` string.
-    """
-    lines = docstr.split("\n")
-    for i in range(len(lines)):
-        if lines[i].find(" " * 8) == 0:
-            lines[i] = lines[i][8:]
-    return "\n".join(lines)
-
-
-class TestCase(_builtin_unittest.TestCase):
-
-    """
-    Extends :obj:`unittest.TestCase` with the :meth:`assertArraySplitEqual`.
-    """
-
-    def assertArraySplitEqual(self, splt1, splt2):
-        """
-        Compares :obj:`list` of :obj:`numpy.ndarray` results returned by :func:`numpy.array_split`
-        and :func:`array_split.split.array_split` functions.
-
-        :type splt1: :obj:`list` of :obj:`numpy.ndarray`
-        :param splt1: First object in equality comparison.
-        :type splt2: :obj:`list` of :obj:`numpy.ndarray`
-        :param splt2: Second object in equality comparison.
-        :raises unittest.AssertionError: If any element of :samp:`{splt1}` is not equal to
-            the corresponding element of :samp:`splt2`.
-        """
-        self.assertEqual(len(splt1), len(splt2))
-        for i in range(len(splt1)):
-            self.assertTrue(
-                (
-                    _np.all(_np.array(splt1[i]) == _np.array(splt2[i]))
-                    or
-                    ((_np.array(splt1[i]).size == 0) and (_np.array(splt2[i]).size == 0))
-                ),
-                msg=(
-                    "element %d of split is not equal %s != %s"
-                    %
-                    (i, _np.array(splt1[i]), _np.array(splt2[i]))
-                )
-            )
-
-    #
-    # Method over-rides below are just to avoid sphinx warnings
-    #
-    def assertItemsEqual(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertItemsEqual`.
-        """
-        _builtin_unittest.TestCase.assertItemsEqual(self, *args, **kwargs)
-
-    def assertListEqual(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertListEqual`.
-        """
-        _builtin_unittest.TestCase.assertListEqual(self, *args, **kwargs)
-
-    def assertRaisesRegexp(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertRaisesRegexp`.
-        """
-        _builtin_unittest.TestCase.assertRaisesRegexp(self, *args, **kwargs)
-
-    def assertRaisesRegex(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertRaisesRegex`.
-        """
-        _builtin_unittest.TestCase.assertRaisesRegex(self, *args, **kwargs)
-
-    def assertSetEqual(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertSetEqual`.
-        """
-        _builtin_unittest.TestCase.assertSetEqual(self, *args, **kwargs)
-
-    def assertTupleEqual(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertTupleEqual`.
-        """
-        _builtin_unittest.TestCase.assertTupleEqual(self, *args, **kwargs)
-
-    def assertWarnsRegex(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertWarnsRegex`.
-        """
-        _builtin_unittest.TestCase.assertWarnsRegex(self, *args, **kwargs)
-
-
-if not hasattr(TestCase, "assertSequenceEqual"):
-    # code from python-2.7 unitest.case.TestCase
-    _MAX_LENGTH = 80
-
-    def safe_repr(obj, short=False):
-        """
-        Returns :func:`repr` string for :samp:`{obj}`.
-        """
-        try:
-            result = repr(obj)
-        except Exception:
-            result = object.__repr__(obj)
-        if not short or len(result) < _MAX_LENGTH:
-            return result
-        return result[:_MAX_LENGTH] + ' [truncated]...'
-
-    def strclass(cls):
-        """
-        Returns name string of :samp:`{cls}` as `<modulename>.<classname>`.
-        """
-        return "%s.%s" % (cls.__module__, cls.__name__)
-
-    def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
-        """An equality assertion for ordered sequences (like lists and tuples).
-
-        For the purposes of this function, a valid ordered sequence type is one
-        which can be indexed, has a length, and has an equality operator.
-
-        :param seq1: The first sequence to compare.
-        :param seq2: The second sequence to compare.
-        :param seq_type: The expected datatype of the sequences, or None if no
-                    datatype should be enforced.
-        :param msg: Optional message to use on failure instead of a list of
-                    differences.
-        """
-
-        import pprint
-        import difflib
-        if seq_type is not None:
-            seq_type_name = seq_type.__name__
-            if not isinstance(seq1, seq_type):
-                raise self.failureException('First sequence is not a %s: %s'
-                                            % (seq_type_name, safe_repr(seq1)))
-            if not isinstance(seq2, seq_type):
-                raise self.failureException('Second sequence is not a %s: %s'
-                                            % (seq_type_name, safe_repr(seq2)))
-        else:
-            seq_type_name = "sequence"
-
-        differing = None
-        try:
-            len1 = len(seq1)
-        except (TypeError, NotImplementedError):
-            differing = 'First %s has no length.    Non-sequence?' % (
-                seq_type_name)
-
-        if differing is None:
-            try:
-                len2 = len(seq2)
-            except (TypeError, NotImplementedError):
-                differing = 'Second %s has no length.    Non-sequence?' % (
-                    seq_type_name)
-
-        if differing is None:
-            if seq1 == seq2:
-                return
-
-            seq1_repr = safe_repr(seq1)
-            seq2_repr = safe_repr(seq2)
-
-            if len(seq1_repr) > 30:
-                seq1_repr = seq1_repr[:30] + '...'
-            if len(seq2_repr) > 30:
-                seq2_repr = seq2_repr[:30] + '...'
-            elements = (seq_type_name.capitalize(), seq1_repr, seq2_repr)
-            differing = '%ss differ: %s != %s\n' % elements
-
-            for i in range(min(len1, len2)):
-                try:
-                    item1 = seq1[i]
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('\nUnable to index element %d of first %s\n' %
-                                  (i, seq_type_name))
-                    break
-
-                try:
-                    item2 = seq2[i]
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('\nUnable to index element %d of second %s\n' %
-                                  (i, seq_type_name))
-                    break
-
-                if item1 != item2:
-                    differing += ('\nFirst differing element %d:\n%s\n%s\n' %
-                                  (i, item1, item2))
-                    break
-            else:
-                if (len1 == len2 and seq_type is None and
-                        not isinstance(seq1, type(seq2))):
-                    # The sequences are the same, but have differing types.
-                    return
-
-            if len1 > len2:
-                differing += ('\nFirst %s contains %d additional '
-                              'elements.\n' % (seq_type_name, len1 - len2))
-                try:
-                    differing += ('First extra element %d:\n%s\n' %
-                                  (len2, seq1[len2]))
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('Unable to index element %d '
-                                  'of first %s\n' % (len2, seq_type_name))
-            elif len1 < len2:
-                differing += ('\nSecond %s contains %d additional '
-                              'elements.\n' % (seq_type_name, len2 - len1))
-                try:
-                    differing += ('First extra element %d:\n%s\n' %
-                                  (len1, seq2[len1]))
-                except (TypeError, IndexError, NotImplementedError):
-                    differing += ('Unable to index element %d '
-                                  'of second %s\n' % (len1, seq_type_name))
-        standardMsg = differing
-        diffMsg = '\n' + '\n'.join(
-            difflib.ndiff(pprint.pformat(seq1).splitlines(),
-                          pprint.pformat(seq2).splitlines()))
-        standardMsg = self._truncateMessage(standardMsg, diffMsg)
-        msg = self._formatMessage(msg, standardMsg)
-        self.fail(msg)
-
-    def _formatMessage(self, msg, standardMsg):
-        """Honour the longMessage attribute when generating failure messages.
-        If longMessage is False this means:
-        * Use only an explicit message if it is provided
-        * Otherwise use the standard message for the assert
-
-        If longMessage is True:
-        * Use the standard message
-        * If an explicit message is provided, plus ' : ' and the explicit message
-        """
-        if not self.longMessage:
-            return msg or standardMsg
-        if msg is None:
-            return standardMsg
-        try:
-            # don't switch to '{}' formatting in Python 2.X
-            # it changes the way unicode input is handled
-            return '%s : %s' % (standardMsg, msg)
-        except UnicodeDecodeError:
-            return '%s : %s' % (safe_repr(standardMsg), safe_repr(msg))
-
-    def _truncateMessage(self, message, diff):
-        DIFF_OMITTED = ('\nDiff is %s characters long. '
-                        'Set self.maxDiff to None to see it.')
-
-        max_diff = self.maxDiff
-        if max_diff is None or len(diff) <= max_diff:
-            return message + diff
-        return message + (DIFF_OMITTED % len(diff))
-
-    _maxDiff = 80 * 8
-    setattr(TestCase, "maxDiff", _maxDiff)
-    setattr(TestCase, "_truncateMessage", _truncateMessage)
-    setattr(TestCase, "_formatMessage", _formatMessage)
-    setattr(TestCase, "assertSequenceEqual", assertSequenceEqual)
-else:
-
-    def assertSequenceEqual(self, *args, **kwargs):
-        """
-        See :obj:`unittest.TestCase.assertSequenceEqual`.
-        """
-        _builtin_unittest.TestCase.assertSequenceEqual(self, *args, **kwargs)
-
-    setattr(TestCase, "assertSequenceEqual", assertSequenceEqual)