array-split 0.6.4__py2.py3-none-any.whl → 0.7.0__py2.py3-none-any.whl

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/_version.py

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

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/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/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/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/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/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/unittest.py

@@ -18,12 +18,13 @@ Classes and Functions
    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
+from .license import copyright as _copyright, license as _license, version as _version
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
@@ -126,9 +127,8 @@ class TestCase(_builtin_unittest.TestCase):
                     ((_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]))
+                    f"element {i:d} of split is not equal"
+                    f" {_np.array(splt1[i])} != {_np.array(splt2[i])}"
                 )
             )
 
@@ -177,176 +177,8 @@ class TestCase(_builtin_unittest.TestCase):
         """
         _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)

{array_split-0.6.4.dist-info → array_split-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: array_split
-Version: 0.6.4
+Version: 0.7.0
 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,7 +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
+Requires-Dist: numpy>=1.6
+Dynamic: license-file
 
 
 =============

array_split-0.7.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+array_split/__init__.py,sha256=y6bfgsztfoFp7BYPeKd47aacmuGErOU1Opf2NXhhV_k,2593
+array_split/_version.py,sha256=WXLm9rJd0DCoORZ3dx3UvfuISQNobXkNOaq6KptNas4,497
+array_split/copyright.txt,sha256=Kn1cZDiLPzgR9O6e-_OT2q_BELBKeFLEyMja8X3YOpU,55
+array_split/license.py,sha256=E835AMFAGxWGAb4SX-nSEU3lSvjjPzVYRIJrVXL5elY,1491
+array_split/license.txt,sha256=voJkgFtk2zV9dBOftdZ7NW3a_aXOLYErZcWZAK812-A,1022
+array_split/logging.py,sha256=6YGQUFcPjTCWgeQHP-XEiPQfwk38J8YPvIgNLTuly9A,5462
+array_split/split.py,sha256=kFOqiQLLI7LGDuUIApEJ6ePNvF85DPlrwsks3XvquW4,59533
+array_split/split_plot.py,sha256=vgNDifvqTU59L91rBTUKg1zY52DRaezhF9GRSktoMz4,703
+array_split/split_test.py,sha256=l2Gf7TqwEMZCc8p_5Qijl8P3QmsLhJoTjLbUh8RJczw,54544
+array_split/tests.py,sha256=8en7bwXrr9ZbQvyVh3LW1sXBRqlj4EhVbV6gUTGSvOw,4030
+array_split/unittest.py,sha256=Y-PWbRrBxCJ9MPTRw2pmaEHb4UoToveFaZTJJXQyRA8,6162
+array_split-0.7.0.dist-info/licenses/LICENSE.txt,sha256=IyUbQpVqCKhPOzm6BVhZ2fJ_Uj7xr6NBhvlBq7rN3wQ,1079
+array_split-0.7.0.dist-info/METADATA,sha256=tziSHKqtfwRmdMqP41cYqlVc7eGFeTKGhucKmuS9Jx4,10167
+array_split-0.7.0.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
+array_split-0.7.0.dist-info/top_level.txt,sha256=exjaJ5xH8Dhtj-gpoxxGnXIn4gga7_gnAmF7y3v0PBs,12
+array_split-0.7.0.dist-info/RECORD,,

{array_split-0.6.4.dist-info → array_split-0.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

array_split-0.6.4.dist-info/RECORD

@@ -1,16 +0,0 @@
-array_split/__init__.py,sha256=MhUT1vAjdCj_7TanAParWfHu8KmIEYEV5XqmeGorcoI,2655
-array_split/_version.py,sha256=89zuw6m__XlOJrBK-nmTfqTRi6pBEVV4ZDUvP622Evo,497
-array_split/copyright.txt,sha256=Kn1cZDiLPzgR9O6e-_OT2q_BELBKeFLEyMja8X3YOpU,55
-array_split/license.py,sha256=p09v3AawXDoucFQ0vfZm7fYPtA6v48ssP0iR1Y8eU4c,1521
-array_split/license.txt,sha256=voJkgFtk2zV9dBOftdZ7NW3a_aXOLYErZcWZAK812-A,1022
-array_split/logging.py,sha256=siuVTYdxAmRxdwjhrxnSZA4AimNmlOlCHC3Ns9hZ4Sc,8017
-array_split/split.py,sha256=diCJ2Ob_oPhj8khWhqspeuTBhY1MA1vmTUBTbsONNPI,59998
-array_split/split_plot.py,sha256=kQb-j080rtNoIJn9HT-gRdjDnrmfaqcWtwJlXAOmp68,744
-array_split/split_test.py,sha256=oeI5dtGZ-8mm9lvJj-I6ErZRMZu3Nio2xWL7hKrqeOI,54611
-array_split/tests.py,sha256=-T6yGN9NOGHbfxVyYW2y_QrCWskG3m8rZtTeVfay39I,4251
-array_split/unittest.py,sha256=3kf8oFLX-CikKnv2gswfp4tutn-FV773-L6alnvPmiM,13031
-array_split-0.6.4.dist-info/LICENSE.txt,sha256=IyUbQpVqCKhPOzm6BVhZ2fJ_Uj7xr6NBhvlBq7rN3wQ,1079
-array_split-0.6.4.dist-info/METADATA,sha256=Gz_jLyZ2KHR0QnrjGN_EaZJNBkjZkNACjeJ3O5YJIVk,10146
-array_split-0.6.4.dist-info/WHEEL,sha256=XRxW4r1PNiVhMpP4bT9oWtu3HyndxpJ84SkubFgzp_Y,109
-array_split-0.6.4.dist-info/top_level.txt,sha256=exjaJ5xH8Dhtj-gpoxxGnXIn4gga7_gnAmF7y3v0PBs,12
-array_split-0.6.4.dist-info/RECORD,,