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

array_split-0.6.4/PKG-INFO

@@ -0,0 +1,255 @@
+Metadata-Version: 2.1
+Name: array_split
+Version: 0.6.4
+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.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this
+        software and associated documentation files (the "Software"), to deal in the Software
+        without restriction, including without limitation the rights to use, copy, modify, merge,
+        publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+        to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or
+        substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+        BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+        DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/array-split/array_split
+Project-URL: Documentation, https://array-split.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/array-split/array_split
+Project-URL: Issues, https://github.com/array-split/array_split/issues
+Keywords: multi-dimensional-array,array,sub-array,tile,tiling,splitting,split,partition,partitioning,scipy,numpy,ndarray,domain-decomposition,array-decomposition
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+
+
+=============
+`array_split`
+=============
+
+.. Start of sphinx doc include.
+.. start long description.
+.. start badges.
+
+.. image:: https://img.shields.io/pypi/v/array_split.svg
+   :target: https://pypi.python.org/pypi/array_split/
+   :alt: array_split python package
+.. image:: https://github.com/array-split/array_split/actions/workflows/python-test.yml/badge.svg
+   :target: https://github.com/array-split/array_split/actions/workflows/python-test.yml
+   :alt: array_split python package
+.. image:: https://readthedocs.org/projects/array-split/badge/?version=stable
+   :target: http://array-split.readthedocs.io/en/stable
+   :alt: Documentation Status
+.. image:: https://coveralls.io/repos/github/array-split/array_split/badge.svg
+   :target: https://coveralls.io/github/array-split/array_split
+   :alt: Coveralls Status
+.. image:: https://img.shields.io/pypi/l/array_split.svg
+   :target: https://pypi.python.org/pypi/array_split/
+   :alt: MIT License
+.. image:: https://img.shields.io/pypi/pyversions/array_split.svg
+   :target: https://pypi.python.org/pypi/array_split/
+   :alt: array_split python package
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.889078.svg
+   :target: https://doi.org/10.5281/zenodo.889078
+.. image:: http://joss.theoj.org/papers/10.21105/joss.00373/status.svg
+   :target: http://joss.theoj.org/papers/4b59c7430176ef78c80c6a1100031eb6
+
+.. end badges.
+
+The `array_split <http://array-split.readthedocs.io/en/latest>`_ python package is
+an enhancement to existing
+`numpy.ndarray  <http://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html>`_ functions,
+such as
+`numpy.array_split <http://docs.scipy.org/doc/numpy/reference/generated/numpy.array_split.html>`_,
+`skimage.util.view_as_blocks <http://scikit-image.org/docs/0.13.x/api/skimage.util.html#view-as-blocks>`_
+and
+`skimage.util.view_as_windows <http://scikit-image.org/docs/0.13.x/api/skimage.util.html#view-as-windows>`_,
+which sub-divide a multi-dimensional array into a number of multi-dimensional sub-arrays (slices).
+Example application areas include:
+
+**Parallel Processing**
+   A large (dense) array is partitioned into smaller sub-arrays which can be
+   processed concurrently by multiple processes
+   (`multiprocessing <https://docs.python.org/3/library/multiprocessing.html>`_
+   or `mpi4py <http://pythonhosted.org/mpi4py/>`_) or other memory-limited hardware
+   (e.g. GPGPU using `pyopencl <https://mathema.tician.de/software/pyopencl/>`_,
+   `pycuda <https://mathema.tician.de/software/pycuda/>`_, etc).
+   For GPGPU, it is necessary for sub-array not to exceed the GPU memory and
+   desirable for the sub-array shape to be a multiple of the *work-group*
+   (`OpenCL <https://en.wikipedia.org/wiki/OpenCL>`_)
+   or *thread-block* (`CUDA <https://en.wikipedia.org/wiki/CUDA>`_) size.
+
+**File I/O**
+   A large (dense) array is partitioned into smaller sub-arrays which can be
+   written to individual files
+   (as, for example, a
+   `HDF5 Virtual Dataset <https://support.hdfgroup.org/HDF5/docNewFeatures/NewFeaturesVirtualDatasetDocs.html>`_).
+   It is often desirable for the individual files not to exceed a specified number
+   of (Giga) bytes and, for `HDF5 <https://support.hdfgroup.org/HDF5/>`_, it is desirable
+   to have the individual file sub-array shape a multiple of
+   the `chunk shape <https://support.hdfgroup.org/HDF5/doc1.8/Advanced/Chunking/index.html>`_.
+   Similarly, `out of core <https://en.wikipedia.org/wiki/Out-of-core_algorithm>`_
+   algorithms for large dense arrays often involve processing the entire data-set as
+   a series of *in-core* sub-arrays. Again, it is desirable for the individual sub-array shape
+   to be a multiple of the
+   `chunk shape <https://support.hdfgroup.org/HDF5/doc1.8/Advanced/Chunking/index.html>`_.  
+
+
+The `array_split <http://array-split.readthedocs.io/en/latest>`_ package provides the
+means to partition an array (or array shape) using any of the following criteria:
+
+- Per-axis indices indicating the *cut* positions.
+- Per-axis number of sub-arrays.
+- Total number of sub-arrays (with optional per-axis *number of sections* constraints).
+- Specific sub-array shape.
+- Specification of *halo* (*ghost*) elements for sub-arrays.
+- Arbitrary *start index* for the shape to be partitioned.
+- Maximum number of bytes for a sub-array with constraints:
+
+   - sub-arrays are an even multiple of a specified sub-tile shape
+   - upper limit on the per-axis sub-array shape
+
+
+Quick Start Example
+===================
+
+
+   >>> from array_split import array_split, shape_split
+   >>> import numpy as np
+   >>>
+   >>> ary = np.arange(0, 4*9)
+   >>> 
+   >>> array_split(ary, 4) # 1D split into 4 sections (like numpy.array_split)
+   [array([0, 1, 2, 3, 4, 5, 6, 7, 8]),
+    array([ 9, 10, 11, 12, 13, 14, 15, 16, 17]),
+    array([18, 19, 20, 21, 22, 23, 24, 25, 26]),
+    array([27, 28, 29, 30, 31, 32, 33, 34, 35])]
+   >>> 
+   >>> shape_split(ary.shape, 4) # 1D split into 4 parts, returns slice objects 
+   array([(slice(0, 9, None),), (slice(9, 18, None),), (slice(18, 27, None),), (slice(27, 36, None),)], 
+         dtype=[('0', 'O')])
+   >>> 
+   >>> ary = ary.reshape(4, 9) # Make ary 2D
+   >>> split = shape_split(ary.shape, axis=(2, 3)) # 2D split into 2*3=6 sections
+   >>> split.shape
+   (2, 3)
+   >>> split
+   array([[(slice(0, 2, None), slice(0, 3, None)),
+           (slice(0, 2, None), slice(3, 6, None)),
+           (slice(0, 2, None), slice(6, 9, None))],
+          [(slice(2, 4, None), slice(0, 3, None)),
+           (slice(2, 4, None), slice(3, 6, None)),
+           (slice(2, 4, None), slice(6, 9, None))]], 
+         dtype=[('0', 'O'), ('1', 'O')])
+   >>> sub_arys = [ary[tup] for tup in split.flatten()] # Create sub-array views from slice tuples.
+   >>> sub_arys
+   [array([[ 0,  1,  2], [ 9, 10, 11]]),
+    array([[ 3,  4,  5], [12, 13, 14]]),
+    array([[ 6,  7,  8], [15, 16, 17]]),
+    array([[18, 19, 20], [27, 28, 29]]),
+    array([[21, 22, 23], [30, 31, 32]]),
+    array([[24, 25, 26], [33, 34, 35]])]
+
+
+Latest sphinx documentation (including more examples)
+at http://array-split.readthedocs.io/en/latest/.
+
+.. end long description.
+
+Installation
+============
+
+Using ``pip`` (root access required):
+
+   ``pip install array_split``
+   
+or local user install (no root access required):
+   
+   ``pip install --user array_split``
+
+or local user install from latest github source:
+
+   ``pip install --user git+git://github.com/array-split/array_split.git#egg=array_split``
+
+
+Requirements
+============
+
+Requires `numpy <http://docs.scipy.org/doc/numpy/>`_ version `>= 1.6`,
+python-2 version `>= 2.6` or python-3 version `>= 3.2`.
+
+Testing
+=======
+
+Run tests (unit-tests and doctest module docstring tests) using::
+
+   python -m array_split.tests
+
+or, from the source tree, run::
+
+   python setup.py test
+
+
+Travis CI at:
+
+   https://travis-ci.org/array-split/array_split/
+
+and AppVeyor at:
+
+   https://ci.appveyor.com/project/array-split/array-split
+
+Documentation
+=============
+
+Latest sphinx generated documentation is at:
+
+    http://array-split.readthedocs.io/en/latest
+
+and at github *gh-pages*:
+
+    https://array-split.github.io/array_split/
+
+Sphinx documentation can be built from the source::
+
+   python setup.py build_sphinx
+
+with the HTML generated in ``docs/_build/html``.
+
+
+Latest source code
+==================
+
+Source at github:
+
+   https://github.com/array-split/array_split
+
+
+Bug Reports
+===========
+
+To search for bugs or report them, please use the bug tracker at:
+
+   https://github.com/array-split/array_split/issues
+
+
+Contributing
+============
+
+Check out the `CONTRIBUTING doc <https://github.com/array-split/array_split/blob/dev/CONTRIBUTING.rst>`_.
+
+
+License information
+===================
+
+See the file `LICENSE.txt <https://github.com/array-split/array_split/blob/dev/LICENSE.txt>`_
+for terms & conditions, for usage and a DISCLAIMER OF ALL WARRANTIES.

{array_split-0.5.2 → array_split-0.6.4}/README.rst

@@ -10,12 +10,9 @@
 .. image:: https://img.shields.io/pypi/v/array_split.svg
    :target: https://pypi.python.org/pypi/array_split/
    :alt: array_split python package
-.. image:: https://travis-ci.org/array-split/array_split.svg?branch=dev
-   :target: https://travis-ci.org/array-split/array_split
-   :alt: TravisCI Status
-.. image:: https://ci.appveyor.com/api/projects/status/oprsw5rfr07m77o0?svg=true
-   :target: https://ci.appveyor.com/project/array-split/array-split
-   :alt: AppVeyor Status
+.. image:: https://github.com/array-split/array_split/actions/workflows/python-test.yml/badge.svg
+   :target: https://github.com/array-split/array_split/actions/workflows/python-test.yml
+   :alt: array_split python package
 .. image:: https://readthedocs.org/projects/array-split/badge/?version=stable
    :target: http://array-split.readthedocs.io/en/stable
    :alt: Documentation Status
@@ -28,6 +25,10 @@
 .. image:: https://img.shields.io/pypi/pyversions/array_split.svg
    :target: https://pypi.python.org/pypi/array_split/
    :alt: array_split python package
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.889078.svg
+   :target: https://doi.org/10.5281/zenodo.889078
+.. image:: http://joss.theoj.org/papers/10.21105/joss.00373/status.svg
+   :target: http://joss.theoj.org/papers/4b59c7430176ef78c80c6a1100031eb6
 
 .. end badges.
 

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

@@ -61,14 +61,15 @@ Attributes
 
 """
 from __future__ import absolute_import
-from .license import license as _license, copyright as _copyright, version as _version
+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
 
 __author__ = "Shane J. Latham"
 __license__ = _license()
 __copyright__ = _copyright()
-__version__ = _version()
+__version__ = _version.get_versions()['version']
 
 
 #: See :data:`array_split.split.ARRAY_BOUNDS`

array_split-0.6.4/array_split/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2024-08-04T15:27:48+1000",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "a5b1cb7c6fbd1db5829249f13a00b42267ac865e",
+ "version": "0.6.4"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

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

@@ -4,6 +4,7 @@ To be replaced.
 # pylint: disable=redefined-builtin
 from __future__ import absolute_import
 import pkg_resources as _pkg_resources
+from . import _version
 
 __copyright__ = _pkg_resources.resource_string("array_split", "copyright.txt").decode()
 __license__ = (
@@ -14,7 +15,7 @@ __license__ = (
     _pkg_resources.resource_string("array_split", "license.txt").decode()
 )
 __author__ = "Shane J. Latham"
-__version__ = _pkg_resources.resource_string("array_split", "version.txt").decode().strip()
+__version__ = _version.get_versions()['version']
 
 
 def version():

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

@@ -94,7 +94,7 @@ class _Python2SplitStreamHandler(_builtin_logging.Handler):
             stream.flush()
         except (KeyboardInterrupt, SystemExit):
             raise
-        except:
+        except Exception:
             self.handleError(record)
 
 
@@ -162,7 +162,7 @@ class _Python3SplitStreamHandler(_builtin_logging.Handler):
             self.flush()
         except (KeyboardInterrupt, SystemExit):  # pragma: no cover
             raise
-        except:
+        except Exception:
             self.handleError(record)
 
 

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

@@ -179,7 +179,7 @@ def pad_with_none(sequence, new_length):
 def shape_factors(n, dim=2):
     """
     Returns a :obj:`numpy.ndarray` of factors :samp:`f` such
-    that :samp:`(len(f) == {dim}) and (numpy.product(f) == {n})`.
+    that :samp:`(len(f) == {dim}) and (numpy.prod(f) == {n})`.
     The returned factors are as *square* (*cubic*, etc) as possible.
     For example::
 
@@ -225,7 +225,7 @@ def calculate_tile_shape_for_max_bytes(
 ):
     """
     Returns a tile shape :samp:`tile_shape`
-    such that :samp:`numpy.product(tile_shape)*numpy.sum({array_itemsize}) <= {max_tile_bytes}`.
+    such that :samp:`numpy.prod(tile_shape)*numpy.sum({array_itemsize}) <= {max_tile_bytes}`.
     Also, if :samp:`{max_tile_shape} is not None`
     then :samp:`numpy.all(tile_shape <= {max_tile_shape}) is True` and
     if :samp:`{sub_tile_shape} is not None`
@@ -340,7 +340,7 @@ def calculate_tile_shape_for_max_bytes(
         and
         (
             (
-                _np.product(tile_sub_tile_split_shape * sub_tile_shape + _np.sum(halo, axis=1))
+                _np.prod(tile_sub_tile_split_shape * sub_tile_shape + _np.sum(halo, axis=1))
                 *
                 array_itemsize
             )
@@ -355,7 +355,7 @@ def calculate_tile_shape_for_max_bytes(
                     max_tile_bytes
                     //
                     (
-                        _np.product(
+                        _np.prod(
                             tile_sub_tile_split_shape *
                             sub_tile_shape +
                             _np.sum(
@@ -375,10 +375,10 @@ def calculate_tile_shape_for_max_bytes(
                     (
                         (max_tile_bytes / float(array_itemsize))
                         -
-                        _np.sum(halo[current_axis]) * _np.product(sub_tile_shape_h[0:current_axis])
+                        _np.sum(halo[current_axis]) * _np.prod(sub_tile_shape_h[0:current_axis])
                     )
                     /
-                    float(_np.product(sub_tile_shape_h))
+                    float(_np.prod(sub_tile_shape_h))
                 ))
         current_axis += 1
 
@@ -399,7 +399,7 @@ def calculate_num_slices_per_axis(num_slices_per_axis, num_slices, max_slices_pe
     """
     Returns a :obj:`numpy.ndarray` (:samp:`return_array` say) where non-positive elements of
     the :samp:`{num_slices_per_axis}` sequence have been replaced with
-    positive integer values such that :samp:`numpy.product(return_array) == num_slices`
+    positive integer values such that :samp:`numpy.prod(return_array) == num_slices`
     and::
 
        numpy.all(
@@ -417,13 +417,13 @@ def calculate_num_slices_per_axis(num_slices_per_axis, num_slices, max_slices_pe
     :type num_slices: integer
     :param num_slices: Indicates the number of slices (rectangular sub-arrays)
        formed by performing sub-divisions per axis. The returned array :samp:`return_array`
-       has elements assigned such that :samp:`numpy.product(return_array) == {num_slices}`.
+       has elements assigned such that :samp:`numpy.prod(return_array) == {num_slices}`.
     :type max_slices_per_axis: sequence of :obj:`int` (or :samp:`None`)
     :param max_slices_per_axis: Constraint specifying maximum number of per-axis sub-divisions.
        If :samp:`None` defaults to :samp:`numpy.array([numpy.inf,]*len({num_slices_per_axis}))`.
     :rtype: :obj:`numpy.ndarray`
     :return: An array :samp:`return_array`
-       such that :samp:`numpy.product(return_array) == num_slices`.
+       such that :samp:`numpy.prod(return_array) == num_slices`.
 
 
     Examples::
@@ -451,7 +451,7 @@ def calculate_num_slices_per_axis(num_slices_per_axis, num_slices, max_slices_pe
         raise ValueError("Got non-positive value in max_slices_per_axis=%s" % max_slices_per_axis)
 
     while _np.any(ret_array <= 0):
-        prd = _np.product(ret_array[_np.where(ret_array > 0)])  # returns 1 for zero-length array
+        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(
                 (
@@ -470,10 +470,10 @@ def calculate_num_slices_per_axis(num_slices_per_axis, num_slices, max_slices_pe
             for i in range(ridx[0].shape[0]):
                 if f[i] >= max_slices_per_axis[ridx[0][i]]:
                     ret_array[ridx[0][i]] = max_slices_per_axis[ridx[0][i]]
-                    prd = _np.product(ret_array[_np.where(ret_array > 0)])
+                    prd = _np.prod(ret_array[_np.where(ret_array > 0)])
                     while (num_slices % prd) > 0:
                         ret_array[ridx[0][i]] -= 1
-                        prd = _np.product(ret_array[_np.where(ret_array > 0)])
+                        prd = _np.prod(ret_array[_np.where(ret_array > 0)])
         logger.debug(
             "ridx=%s, f=%s, ret_array=%s, max_slices_per_axis=%s",
             ridx, f, ret_array, max_slices_per_axis
@@ -670,7 +670,7 @@ class ShapeSplitter(object):
        >>> split
        array([(slice(0, 4, None),), (slice(4, 7, None),), (slice(7, 10, None),)],
              dtype=[('0', 'O')])
-       >>> [ary[slyce] for slyce in split.flatten()]
+       >>> [ary[slyce] for slyce in split.flatten().tolist()]
        [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]
        >>>
        >>> splitter.split_shape # equivalent to split.shape above
@@ -1229,20 +1229,20 @@ class ShapeSplitter(object):
                     tuple(
                         [
                             slice(
-                                max([
+                                int(max([
                                     self.split_begs[d][idx[d]]
                                     + self.array_start[d]
                                     - self.halo[d, 0]
                                     * (self.split_ends[d][idx[d]] > self.split_begs[d][idx[d]]),
                                     self.tile_beg_min[d]
-                                ]),
-                                min([
+                                ])),
+                                int(min([
                                     self.split_ends[d][idx[d]]
                                     + self.array_start[d]
                                     + self.halo[d, 1]
                                     * (self.split_ends[d][idx[d]] > self.split_begs[d][idx[d]]),
                                     self.tile_end_max[d]
-                                ])
+                                ]))
                             )
                             for d in range(len(self.split_shape))
                         ]
@@ -1250,8 +1250,8 @@ class ShapeSplitter(object):
                     for idx in
                     _np.array(
                         _np.unravel_index(
-                            _np.arange(0, _np.product(self.split_shape)),
-                            self.split_shape
+                            _np.arange(0, _np.prod(self.split_shape)),
+                            self.split_shape if self.split_shape is not None else tuple()
                         )
                     ).T
                 ],
@@ -1302,8 +1302,8 @@ class ShapeSplitter(object):
                     for idx in
                     _np.array(
                         _np.unravel_index(
-                            _np.arange(0, _np.product(self.split_shape)),
-                            self.split_shape
+                            _np.arange(0, _np.prod(self.split_shape)),
+                            self.split_shape if self.split_shape is not None else tuple()
                         )
                     ).T
                 ],
@@ -1373,7 +1373,7 @@ class ShapeSplitter(object):
                 and
                 _np.all([s > 0 for s in self.split_num_slices_per_axis])
             ):
-                self.split_size = _np.product(self.split_num_slices_per_axis)
+                self.split_size = _np.prod(self.split_num_slices_per_axis)
             else:
                 raise ValueError(
                     (
@@ -1517,7 +1517,10 @@ class ShapeSplitter(object):
         """
 
         self.set_split_extents()
-        return self.calculate_split_from_extents()
+        slyces = self.calculate_split_from_extents()
+        self.logger.debug("type(slyces)=%s", type(slyces))
+        self.logger.debug("slyces=%s", slyces)
+        return slyces
 
 
 ShapeSplitter([0, ]).__init__.__func__.__doc__ = \
@@ -1596,7 +1599,7 @@ def array_split(
     halo=None
 ):
     "To be replaced."
-    return [
+    return list(
         ary[slyce]
         for slyce in
         shape_split(
@@ -1611,8 +1614,8 @@ def array_split(
             sub_tile_shape=sub_tile_shape,
             halo=halo,
             tile_bounds_policy=ARRAY_BOUNDS
-        ).flatten()
-    ]
+        ).flatten().tolist()
+    )
 
 
 array_split.__doc__ =\

array_split-0.6.4/array_split/split_plot.py

@@ -0,0 +1,43 @@
+"""
+========================================
+The :mod:`array_split.split_plot` Module
+========================================
+
+Uses :mod:`matplotlib` to plot a split.
+
+Classes and Functions
+=====================
+
+.. autosummary::
+   :toctree: generated/
+
+   SplitPlotter - Plots a split.
+   plot - Plots split shapes.
+
+"""
+
+from __future__ import absolute_import
+
+from .license import license as _license, copyright as _copyright, version as _version
+
+__author__ = "Shane J. Latham"
+__license__ = _license()
+__copyright__ = _copyright()
+__version__ = _version()
+
+
+class SplitPlotter(object):
+    """
+    Plots a split.
+    """
+
+    def __init__(self):
+        """
+        """
+        pass
+
+
+def plot(split):
+    """
+    Plots a split.
+    """

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

@@ -1455,7 +1455,7 @@ class SplitTest(_unittest.TestCase):
         splt = splitter.calculate_split()
         splt_halos = splitter.calculate_split_halos_from_extents()
         self.assertSequenceEqual(splt.shape, splt_halos.shape)
-        self.assertTrue(_np.all(splt_halos.astype(_np.int64) == 0))
+        self.assertTrue(_np.all(_np.asarray(splt_halos.tolist()) == 0))
 
         # Some tiles narrower than halo width
         splitter = ShapeSplitter((15, 13), axis=[3, 3], halo=5, tile_bounds_policy=ARRAY_BOUNDS)
@@ -1474,7 +1474,7 @@ class SplitTest(_unittest.TestCase):
         splt = splitter.calculate_split()
         splt_halos = splitter.calculate_split_halos_from_extents()
         self.assertSequenceEqual(splt.shape, splt_halos.shape)
-        self.assertTrue(_np.all(splt_halos.astype(_np.int64) == 0))
+        self.assertTrue(_np.all(_np.asarray(splt_halos.tolist()) == 0))
 
         # Tiles narrower than halo width
         splitter = ShapeSplitter((5, 13), axis=[5, 3], halo=5, tile_bounds_policy=ARRAY_BOUNDS)

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

@@ -142,4 +142,6 @@ def load_tests(loader, tests, pattern):  # pylint: disable=unused-argument
 __all__ = [s for s in dir() if not s.startswith('_')]
 
 if __name__ == "__main__":
+    # import logging
+    # logging.basicConfig(level=logging.DEBUG)
     _unittest.main()