Merge master into update_elementwise_docs

Author: vlad-perevezentsev

doc/_templates/autosummary/attribute.rst

@@ -0,0 +1,9 @@
+:orphan:
+
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+attribute
+
+.. auto{{ objtype }}:: {{ objname }}

doc/_templates/autosummary/base.rst

@@ -0,0 +1,13 @@
+{% if objtype == 'property' %}
+:orphan:
+{% endif %}
+
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+{% if objtype == 'property' %}
+property
+{% endif %}
+
+.. auto{{ objtype }}:: {{ objname }}

doc/_templates/autosummary/class.rst

@@ -1,53 +1,27 @@
-{{ fullname }}
-{{ underline }}
-
-.. currentmodule:: {{ module }}
-
-.. autoclass:: {{ objname }}
-
-   ..
-      Methods
+{% extends "!autosummary/class.rst" %}
 
 {% block methods %}
-
-   .. rubric:: Methods
-
-   ..
-      Special methods
-
-{% for item in ('__getitem__', '__setitem__', '__len__', '__next__', '__iter__') %}
-{% if item in all_methods or item in all_attributes %}
-   .. automethod:: {{ item }}
+{% if methods %}
+   .. HACK -- the point here is that we don't want this to appear in the output, but the autosummary should still generate the pages.
+      .. autosummary::
+         :toctree:
+      {% for item in all_methods %}
+         {%- if not item.startswith('_') or item in ['__call__'] %}
+         {{ name }}.{{ item }}
+         {%- endif -%}
+      {%- endfor %}
 {% endif %}
-{%- endfor %}
-
-   ..
-      Ordinary methods
-
-{% for item in methods %}
-{% if item not in ('__init__',) %}
-   .. automethod:: {{ item }}
-{% endif %}
-{%- endfor %}
-
-   ..
-      Special methods
+{% endblock %}
 
-{% for item in ('__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__') %}
-{% if item in all_methods %}
-   .. automethod:: {{ item }}
+{% block attributes %}
+{% if attributes %}
+   .. HACK -- the point here is that we don't want this to appear in the output, but the autosummary should still generate the pages.
+      .. autosummary::
+         :toctree:
+      {% for item in all_attributes %}
+         {%- if not item.startswith('_') %}
+         {{ name }}.{{ item }}
+         {%- endif -%}
+      {%- endfor %}
 {% endif %}
-{%- endfor %}
 {% endblock %}
-
-   ..
-      Attributes
-
-{% block attributes %} {% if attributes %}
-
-   .. rubric:: Attributes
-
-{% for item in attributes %}
-   .. autoattribute:: {{ item }}
-{%- endfor %}
-{% endif %} {% endblock %}

doc/_templates/autosummary/member.rst

@@ -0,0 +1,9 @@
+:orphan:
+
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+member
+
+.. auto{{ objtype }}:: {{ objname }}

doc/_templates/autosummary/method.rst

@@ -0,0 +1,9 @@
+:orphan:
+
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+method
+
+.. auto{{ objtype }}:: {{ objname }}

doc/_templates/autosummary/minimal_module.rst

@@ -0,0 +1,6 @@
+{{ fullname | escape | underline}}
+
+.. automodule:: {{ fullname }}
+
+   {% block docstring %}
+   {% endblock %}

doc/_templates/autosummary/module.rst

@@ -0,0 +1,41 @@
+{% extends "!autosummary/module.rst" %}
+
+{# This file is almost the same as the default, but adds :toctree: to the
+   autosummary directives. The original can be found at
+   ``sphinx/ext/autosummary/templates/autosummary/module.rst``. #}
+
+{% block attributes %}
+{% if attributes %}
+   .. rubric:: Module Attributes
+
+   .. autosummary::
+      :toctree:
+   {% for item in attributes %}
+      {{ item }}
+   {%- endfor %}
+{% endif %}
+{% endblock %}
+
+{% block functions %}
+{% if functions %}
+   .. rubric:: Functions
+
+   .. autosummary::
+      :toctree:
+   {% for item in functions %}
+      {{ item }}
+   {%- endfor %}
+{% endif %}
+{% endblock %}
+
+{% block classes %}
+{% if classes %}
+   .. rubric:: Classes
+
+   .. autosummary::
+      :toctree:
+   {% for item in classes %}
+      {{ item }}
+   {%- endfor %}
+{% endif %}
+{% endblock %}

doc/conf.py

@@ -6,6 +6,8 @@
 # full list see the documentation:
 # http://www.sphinx-doc.org/en/master/config
 
+from datetime import datetime
+
 from sphinx.ext.autodoc import FunctionDocumenter
 
 from dpnp.dpnp_algo.dpnp_elementwise_common import DPNPBinaryFunc, DPNPUnaryFunc
@@ -32,7 +34,8 @@
 # -- Project information -----------------------------------------------------
 
 project = "Data Parallel Extension for NumPy"
-copyright = "2020-2024, Intel Corporation"
+year = datetime.now().year
+copyright = f"2020-{year}, Intel Corporation"
 author = "Intel"
 
 version = dpnp.__version__.strip(".dirty")

dpnp/dpnp_iface_functional.py

@@ -37,7 +37,6 @@
 """
 
 
-import numpy
 from dpctl.tensor._numpy_helper import (
     normalize_axis_index,
     normalize_axis_tuple,
@@ -151,8 +150,7 @@ def apply_along_axis(func1d, axis, arr, *args, **kwargs):
 
     # compute indices for the iteration axes, and append a trailing ellipsis to
     # prevent 0d arrays decaying to scalars
-    # TODO: replace with dpnp.ndindex
-    inds = numpy.ndindex(inarr_view.shape[:-1])
+    inds = dpnp.ndindex(inarr_view.shape[:-1])
     inds = (ind + (Ellipsis,) for ind in inds)
 
     # invoke the function on the first item

dpnp/dpnp_iface_indexing.py

@@ -64,6 +64,7 @@
     "indices",
     "ix_",
     "mask_indices",
+    "ndindex",
     "nonzero",
     "place",
     "put",
@@ -1057,6 +1058,77 @@ def mask_indices(
     return nonzero(a != 0)
 
 
+# pylint: disable=invalid-name
+# pylint: disable=too-few-public-methods
+class ndindex:
+    """
+    An N-dimensional iterator object to index arrays.
+
+    Given the shape of an array, an :obj:`dpnp.ndindex` instance iterates over
+    the N-dimensional index of the array. At each iteration a tuple of indices
+    is returned, the last dimension is iterated over first.
+
+    For full documentation refer to :obj:`numpy.ndindex`.
+
+    Parameters
+    ----------
+    shape : ints, or a single tuple of ints
+        The size of each dimension of the array can be passed as individual
+        parameters or as the elements of a tuple.
+
+    See Also
+    --------
+    :obj:`dpnp.ndenumerate` : Multidimensional index iterator.
+    :obj:`dpnp.flatiter` : Flat iterator object to iterate over arrays.
+
+    Examples
+    --------
+    >>> import dpnp as np
+
+    Dimensions as individual arguments
+
+    >>> for index in np.ndindex(3, 2, 1):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    Same dimensions - but in a tuple ``(3, 2, 1)``
+
+    >>> for index in np.ndindex((3, 2, 1)):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    """
+
+    def __init__(self, *shape):
+        self.ndindex_ = numpy.ndindex(*shape)
+
+    def __iter__(self):
+        return self.ndindex_
+
+    def __next__(self):
+        """
+        Standard iterator method, updates the index and returns the index tuple.
+
+        Returns
+        -------
+        val : tuple of ints
+            Returns a tuple containing the indices of the current iteration.
+
+        """
+
+        return self.ndindex_.__next__()
+
+
 def nonzero(a):
     """
     Return the indices of the elements that are non-zero.

dpnp/dpnp_utils/dpnp_utils_pad.py

@@ -642,8 +642,7 @@ def dpnp_pad(array, pad_width, mode="constant", **kwargs):
 
             # compute indices for the iteration axes, and append a trailing
             # ellipsis to prevent 0d arrays decaying to scalars
-            # TODO: replace with dpnp.ndindex when implemented
-            inds = numpy.ndindex(view.shape[:-1])
+            inds = dpnp.ndindex(view.shape[:-1])
             inds = (ind + (Ellipsis,) for ind in inds)
             for ind in inds:
                 function(view[ind], pad_width[axis], axis, kwargs)

dpnp/tests/test_indexing.py

@@ -335,6 +335,32 @@ def test_ix_error(self, xp, shape):
         assert_raises(ValueError, xp.ix_, xp.ones(shape))
 
 
+@pytest.mark.parametrize(
+    "shape", [[1, 2, 3], [(1, 2, 3)], [(3,)], [3], [], [()], [0]]
+)
+class TestNdindex:
+    def test_basic(self, shape):
+        result = dpnp.ndindex(*shape)
+        expected = numpy.ndindex(*shape)
+
+        for x, y in zip(result, expected):
+            assert x == y
+
+    def test_next(self, shape):
+        dind = dpnp.ndindex(*shape)
+        nind = numpy.ndindex(*shape)
+
+        while True:
+            try:
+                ditem = next(dind)
+            except StopIteration:
+                assert_raises(StopIteration, next, nind)
+                break  # both reach ends
+            else:
+                nitem = next(nind)
+                assert ditem == nitem
+
+
 class TestNonzero:
     @pytest.mark.parametrize("list_val", [[], [0], [1]])
     def test_trivial(self, list_val):