pythonic-fp-numpy 0.1.2__tar.gz → 1.1.0__tar.gz

pythonic_fp_numpy-1.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: pythonic-fp-numpy
+Version: 1.1.0
+Summary: FP tools for Numpy
+Keywords: numpy,ndarray,hashable,wrap
+Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: numpy>=2.3.4
+Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-numpy/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp-numpy/release/html/
+Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/
+Project-URL: Source, https://github.com/grscheller/pythonic-fp-numpy
+
+# Pythonic FP - FP Numpy
+
+Python package implementing functional programming tools for NumPy.
+
+PyPI project
+[pythonic-fp-numpy](https://pypi.org/project/pythonic-fp-numpy).
+Part of the
+[pythonic-fp](https://grscheller.github.io/pythonic-fp/)
+PyPI projects.
+
+## Documentation
+
+Documentation and other links for this project are hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/projects/numpy.html).
+
+### Modules
+
+#### Module hashable_wrapped_ndarray
+
+- wrap readonly NDArrays to make them hashable
+- prioritize performance over safety
+- see PyPI project boring-math-abstract-algebra for a use case
+
+## Copyright and License
+
+Copyright (c) 2025-2026 Geoffrey R. Scheller. Licensed under the Apache
+License, Version 2.0. See the LICENSE file for details.
+

pythonic_fp_numpy-1.1.0/README.md

@@ -0,0 +1,27 @@
+# Pythonic FP - FP Numpy
+
+Python package implementing functional programming tools for NumPy.
+
+PyPI project
+[pythonic-fp-numpy](https://pypi.org/project/pythonic-fp-numpy).
+Part of the
+[pythonic-fp](https://grscheller.github.io/pythonic-fp/)
+PyPI projects.
+
+## Documentation
+
+Documentation and other links for this project are hosted on
+[GitHub Pages](https://grscheller.github.io/pythonic-fp/projects/numpy.html).
+
+### Modules
+
+#### Module hashable_wrapped_ndarray
+
+- wrap readonly NDArrays to make them hashable
+- prioritize performance over safety
+- see PyPI project boring-math-abstract-algebra for a use case
+
+## Copyright and License
+
+Copyright (c) 2025-2026 Geoffrey R. Scheller. Licensed under the Apache
+License, Version 2.0. See the LICENSE file for details.

{pythonic_fp_numpy-0.1.2 → pythonic_fp_numpy-1.1.0}/pyproject.toml

@@ -1,10 +1,16 @@
+[build-system]
+requires = ["flit_core>=3.12,<4"]
+build-backend = "flit_core.buildapi"
+
 [project]
 name = "pythonic-fp-numpy"
-version = "0.1.2"
-readme = "README.rst"
-requires-python = ">=3.13"
-license = { file = "LICENSE" }
-authors = [{ name = "Geoffrey R. Scheller", email = "geoffrey@scheller.com" }]
+version = "1.1.0"
+description = "FP tools for Numpy"
+readme = "README.md"
+requires-python = ">=3.14"  # floor: PEP 649/749 deferred annotations — class-level self-reference possible NameErrors on <3.14
+authors = [
+  { name = "Geoffrey R. Scheller", email = "geoffrey@scheller.com" },
+]
 keywords = [
   "numpy",
   "ndarray",
@@ -12,69 +18,76 @@ keywords = [
   "wrap",
 ]
 classifiers = [
-  "Development Status :: 4 - Beta",
+  "Development Status :: 3 - Alpha",
   "Framework :: Pytest",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
   "Operating System :: OS Independent",
-  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Typing :: Typed",
 ]
 dependencies = [
   "numpy>=2.3.4",
 ]
-dynamic = ["description"]
 
 [project.urls]
-Changelog = "https://github.com/grscheller/pythonic-fp-numpy/blob/main/CHANGELOG.rst"
-Documentation = "https://grscheller.github.io/pythonic-fp/numpy/development/build/html/"
-Homepage = "https://grscheller.github.io/pythonic-fp/homepage/build/html/"
+Changelog = "https://github.com/grscheller/pythonic-fp-numpy/blob/main/CHANGELOG.md"
+Documentation ="https://grscheller.github.io/pythonic-fp-numpy/release/html/"
+Homepage = "https://grscheller.github.io/pythonic-fp/"
 Source = "https://github.com/grscheller/pythonic-fp-numpy"
 
-[project.optional-dependencies]
+[dependency-groups]
+docs = [
+  "furo>=2025.12.19",
+  "sphinx>=9.1",
+]
 test = [
-  "boring-math-abstract-algebra>=1.1.0",
   "pytest>=8.4.1",
+  "boring-math-abstract-algebra",
 ]
 
-[build-system]
-requires = ["flit_core>=3.12,<4"]
-build-backend = "flit_core.buildapi"
-
 [tool.flit.module]
 name = "pythonic_fp.numpy"
 
+[tool.flit.sdist]
+exclude = [
+  "docs/",
+  "tests/",
+  "**/.mypy_cache/",
+  "**/.ruff_cache/",
+  "**/.pytest_cache/",
+  "**/__pycache__/",
+  "**/.dmypy.json",
+]
+
+[tool.pytest]
+addopts = ["-ra"]
+consider_namespace_packages = true
+testpaths = ["tests/"]
+
 [tool.mypy]
-enable_incomplete_feature = "NewGenericSyntax"
 explicit_package_bases = true
-implicit_reexport = false
 local_partial_types = true
 namespace_packages = true
 warn_redundant_casts = true
 warn_return_any = true
 warn_unused_configs = true
 
-[tool.pylsp-mypy]
-enabled = true
-live-mode = true
-dmypy = false
-strict = true
-report_progress = true
-
-[tool.pytest.ini_options]
-addopts = "-ra"
-consider_namespace_packages = true
-testpaths = ["tests/"]
-
 [tool.ruff]
-target-version = "py313"
+target-version = "py314"
+
+[tool.ruff.lint]
+ignore = ["RUF022", "E741"]
 
 [tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"
 
 [tool.ruff.lint.per-file-ignores]
-"tests/*" = ["C901"]
-"**/*.py" = ["E741"]
+"tests/**/*.py" = [
+  "E731",
+  "C901",
+]
 
 [tool.ruff.format]
 quote-style = "single"

{pythonic_fp_numpy-0.1.2 → pythonic_fp_numpy-1.1.0}/src/pythonic_fp/numpy/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2024-2025 Geoffrey R. Scheller
+# Copyright 2024-2026 Geoffrey R. Scheller
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,19 +13,14 @@
 # limitations under the License.
 
 """
-FP NumPy Tools
-==============
+NumPy Tools
+-----------
 
-Package implementing functional programming tools for NumPy.
+.. admonition:: Functional Tools for Numpy
 
-Modules
--------
+    Package implementing functional programming tools for NumPy.
 
-+-------------------------------+--------------------------------------+
-| Module                        | Description                          |
-+===============================+======================================+
-| **hashable_wrapped_ndarray**  | Make non-writable NDArrays hashable. |
-+-------------------------------+--------------------------------------+
+    - module **hashable_wrapped_ndarray:** Wrap a non-writable NDArray making result hashable.
 
 """
 

pythonic_fp_numpy-1.1.0/src/pythonic_fp/numpy/hashable_wrapped_ndarray.py

@@ -0,0 +1,411 @@
+# Copyright 2025-2026 Geoffrey R. Scheller
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+from enum import auto, Enum
+import numpy as np
+import numpy.typing as npt
+
+__all__ = [
+    'DTypes',
+    'HWrapNDArray',
+    'HWrapNDArrayNumber',
+    'HWrapNDArrayString',
+    'HWrapNDArrayBytes',
+    'HWrapNDArrayVoid',
+    'HWrapNDArrayObject',
+    'HWrapNDArrayDateTime',
+    'HWrapNDArrayTimeDelta',
+    'HWrapNDArrayBool',
+]
+
+
+class DTypes(Enum):
+    """
+    .. admonition:: Enumeration of closed NumPy datatypes
+
+        Groups (Unions) of NumPy datatypes closed to NumPy operations.
+
+        - number
+        - str\\_
+        - bytes
+        - datetime64
+        - timedelta64
+        - bool\\_
+        - void
+        - object\\_
+
+        While NumPy types are extensively covariant, the NumPy
+        C internals are somewhat invariant. NumPy also suffers
+        from what I call "Fortran Disease", types get "auto-promoted"
+        to compatible "wider types" when necessary. That is fine when
+        dealing with operators on mixed types, but NumPy will
+        auto-promote with operations on the same type.
+
+    """
+
+    number = auto()
+    str_ = auto()
+    bytes = auto()
+    void = auto()
+    object_ = auto()
+    datetime64 = auto()
+    timedelta64 = auto()
+    bool_ = auto()
+
+
+class HWrapNDArray(ABC):
+    """
+    Make NumPy NDArrays hashable.
+
+    Just making an NDArray (np.array) readonly is not enough. This class
+    stores a read-only copy of the NDArray given to the constructor and
+    is hashable.
+
+    """
+
+    __slots__ = '_ndarray', '_type', '_shape', '_hash'
+
+    def __init__(self, ndarray: npt.NDArray[np.generic]) -> None:
+        """
+        .. admonition:: init
+
+            Base class for a hashable wrapped ndarray.
+
+        """
+        self._ndarray = np.array(ndarray, copy=True)
+        self._ndarray.setflags(write=False)
+
+        dtype = self._ndarray.dtype.type
+        if issubclass(dtype, np.number):
+            self._type = DTypes.number
+        elif isinstance(dtype, np.str_):
+            self._type = DTypes.str_
+        elif issubclass(dtype, np.bytes_):
+            self._type = DTypes.bytes
+        elif issubclass(dtype, np.datetime64):
+            self._type = DTypes.datetime64
+        elif issubclass(dtype, np.timedelta64):
+            self._type = DTypes.timedelta64
+        elif issubclass(dtype, np.bool_):
+            self._type = DTypes.bool_
+        elif issubclass(dtype, np.void):
+            self._type = DTypes.void
+        elif issubclass(dtype, np.object_):
+            self._type = DTypes.object_
+        else:
+            msg = f"HWrapNDArray: Unknow np.dtype '{dtype}'"
+            raise TypeError(msg)
+
+        self._shape = self._ndarray.shape
+        self._hash = hash((self._ndarray.tobytes(), hash((self._shape, self._type))))
+
+    def __call__(self) -> npt.NDArray[np.number]:
+        """
+        .. admonition:: call
+
+            Return a reference to the stored NDArray.
+
+            .. warning::
+
+                For efficiency this method returns a reference to the
+                wrapped NDArray, not a copy.
+
+                - Allows for faster slicing and faster operations.
+                - Use the copy method if you want a read-write copy.
+                - Never make the underlying NDArray writable!!!
+
+            """
+        return np.array(self._ndarray)
+
+    def __hash__(self) -> int:
+        """
+        .. admonition:: hash
+
+            Return hash created during initialization. Hash only
+            remains valid if NDArray's flag remains off.
+
+        """
+        return self._hash
+
+    def __eq__(self, other: object) -> bool:
+        """
+        .. admonition:: equality comparison
+
+            :param other: The ``object`` being compared to ``self``.
+            :returns: ``True`` if ``object`` is another ``HWrapNDArray``
+                      all whose corresponding components are equal to
+                      the ones in ``self``.
+
+        """
+        if not isinstance(other, type(self)):
+            return False
+        if self._shape != other._shape or self._type != other._type:
+            return False
+        return np.array_equal(self._ndarray, other._ndarray)
+
+    def _ndarray_repr(self) -> str:
+        ndarray = self._ndarray
+        repr_str = repr(ndarray)
+        repr_str = 'np.' + repr_str.replace('\n', '')
+        repr_str = repr_str.replace(' ', '') 
+        repr_str = repr_str.replace('=', "=np.")
+        return repr_str
+
+    @abstractmethod
+    def __repr__(self) -> str: ...
+
+    def __str__(self) -> str:
+        """
+        .. admonition:: user string
+
+            :returns: String meaningful to an end user.
+
+        """
+        user_str = str(self._ndarray)
+        user_str = user_str.replace('\n ', '\n    ')
+        user_str = '<< ' + user_str + ' >>'
+        return user_str
+
+    def copy(self) -> npt.NDArray[np.number]:
+        """
+        .. admonition:: copy
+
+            Return a copy of the wrapped NDArray.
+
+        """
+        return np.array(self._ndarray, copy=True)
+
+
+class HWrapNDArrayNumber(HWrapNDArray):
+    """
+    .. admonition:: wrapped numeric ndarray
+
+        Class for a hashable wrapped numeric ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.number]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of arbitrary NumPy numeric types.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped numeric ndarray.
+
+        """
+        return 'HWrapNDArrayNumber(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayString(HWrapNDArray):
+    """
+    .. admonition:: wrapped string ndarray
+
+        Class for a hashable wrapped string ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.str_]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of Unicode strings.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped string ndarray.
+
+        """
+        return 'HWrapNDArrayStr(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayBytes(HWrapNDArray):
+    """
+    .. admonition:: wrapped byte ndarray
+
+        Class for a hashable wrapped null-terminated
+        byte sequence ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.bytes_]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of null-terminated byte sequences.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped null-terminated
+                      byte sequence ndarray.
+
+        """
+        return 'HWrapNDArrayBytes(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayVoid(HWrapNDArray):
+    """
+    .. admonition:: wrapped void ndarray
+
+        Class for a hashable wrapped arbitrary byte
+        sequence ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.void]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of arbitrary byte sequences.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped arbitrary
+                      byte sequence ndarray.
+
+        """
+        return 'HWrapNDArrayVoid(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayObject(HWrapNDArray):
+    """
+    .. admonition:: wrapped object reference ndarray
+
+        Class for a hashable wrapped object reference ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.object_]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of references to arbitrary Python objects.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped object
+                      reference ndarray.
+
+        """
+        return 'HWrapNDArrayObject(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayDateTime(HWrapNDArray):
+    """
+    .. admonition:: wrapped datetime ndarray
+
+        Class for a hashable wrapped datatime ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.datetime64]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of datetimes.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped datetime ndarray.
+
+        """
+        return 'HWrapNDArrayTimeDelta(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayTimeDelta(HWrapNDArray):
+    """
+    .. admonition:: wrapped timedelta ndarray
+
+        Class for a hashable wrapped timedelta ndarray.
+
+    """
+    def __init__(self, ndarray: npt.NDArray[np.timedelta64]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of timedeltas.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped timedelta ndarray.
+
+        """
+        return 'HWrapNDArrayTimeDelta(' + self._ndarray_repr() + ')'
+
+
+class HWrapNDArrayBool(HWrapNDArray):
+    """
+    .. admonition:: wrapped Boolean ndarray
+
+        Class for a hashable wrapped Boolean ndarray.
+
+        .. note::
+
+            NumPy Booleans are actual Booleans, unlike Python bools
+            which are subtypes of int.
+
+            - ``*`` uses component-wise Boolean **and**
+            - ``+`` uses component-wise Boolean **or**
+            - ``@`` matrix multiplication using **and** then **or**
+
+    """
+
+    def __init__(self, ndarray: npt.NDArray[np.bool_]) -> None:
+        """
+        .. admonition:: init
+
+            Wrap NDArray of Booleans.
+
+        """
+        super().__init__(ndarray)
+
+    def __repr__(self) -> str:
+        """
+        .. admonition:: repr string
+
+            :returns: String to reproduce the wrapped Boolean ndarray.
+
+        """
+        return 'HWrapNDArrayBool(' + self._ndarray_repr() + ')'

pythonic_fp_numpy-0.1.2/.gitignore

@@ -1,7 +0,0 @@
-# Minimal version - only add to when necessary
-**/__pycache__/
-dist/
-**/.dmypy.json
-**/.mypy_cache/
-**/.pytest_cache/
-**/.ruff_cache

pythonic_fp_numpy-0.1.2/CHANGELOG.rst

@@ -1,54 +0,0 @@
-CHANGELOG
-=========
-
-PyPI pythonic-fp-numpy project.
-
-Semantic Versioning
--------------------
-
-Strict 3 digit semantic versioning
-
-- **MAJOR** version incremented for incompatible API changes
-- **MINOR** version incremented for backward compatible added functionality
-- **PATCH** version incremented for backward compatible bug fixes
-
-See `Semantic Versioning 2.0.0 <https://semver.org>`_.
-
-Releases and Important Milestones
----------------------------------
-
-PyPI v0.1.2 - 2026-01-16
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Fixed some documentation rough edges. Added *.pyi stub files. Updated __repr__
-behavior for HWrapNDArray derived classes. Eliminated spaces.
-
-Future directions.
-
-- define ``+``, ``*``, and ``@`` on wrapped arrays.
-- more tests
-
-
-PyPI v0.1.1 - 2025-12-01
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Fixed problem with the extra test dependencies.
-
-
-PyPI v0.1.0 - 2025-11-30
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Initial PyPI release.
-
-Update - 2025-11-26
-~~~~~~~~~~~~~~~~~~~
-
-Created GitHub repo for this new effort. 
-
-Previously wrote a hashable wrapper for NumPy NDArray for the test suite
-of my boring-math-abstract-algebra PyPI project.
-
-Makes an NDArray readonly and hashable.
-
-Will need to drop the "only requires the Python std library" requirement
-for pythonic-fp projects.

pythonic_fp_numpy-0.1.2/PKG-INFO

@@ -1,62 +0,0 @@
-Metadata-Version: 2.4
-Name: pythonic-fp-numpy
-Version: 0.1.2
-Summary: FP NumPy Tools
-Keywords: numpy,ndarray,hashable,wrap
-Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
-Requires-Python: >=3.13
-Description-Content-Type: text/x-rst
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: Pytest
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
-License-File: LICENSE
-Requires-Dist: numpy>=2.3.4
-Requires-Dist: boring-math-abstract-algebra>=1.1.0 ; extra == "test"
-Requires-Dist: pytest>=8.4.1 ; extra == "test"
-Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-numpy/blob/main/CHANGELOG.rst
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/numpy/development/build/html/
-Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/homepage/build/html/
-Project-URL: Source, https://github.com/grscheller/pythonic-fp-numpy
-Provides-Extra: test
-
-Pythonic FP - FP NumPy
-======================
-
-PyPI project
-`pythonic-fp-numpy
-<https://pypi.org/project/pythonic-fp-numpy>`_.
-
-Python package implementing functional programming for NumPy.
-
-Part of the
-`pythonic-fp
-<https://grscheller.github.io/pythonic-fp>`_
-PyPI projects.
-
-Modules
--------
-
-Module hashable_wrapped_ndarray
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-  - wrap readonly NDArrays to make them hashable
-  - prioritize performance over safety
-  - see PyPI project boring-math-abstract-algebra for a use case
-
-Documentation
--------------
-
-Documentation for this project is hosted on
-`GitHub Pages
-<https://grscheller.github.io/pythonic-fp/numpy>`_.
-
-Copyright and License
----------------------
-
-Copyright (c) 2025-2026 Geoffrey R. Scheller. Licensed under the Apache
-License, Version 2.0. See the LICENSE file for details.
-

pythonic_fp_numpy-0.1.2/README.rst

@@ -1,36 +0,0 @@
-Pythonic FP - FP NumPy
-======================
-
-PyPI project
-`pythonic-fp-numpy
-<https://pypi.org/project/pythonic-fp-numpy>`_.
-
-Python package implementing functional programming for NumPy.
-
-Part of the
-`pythonic-fp
-<https://grscheller.github.io/pythonic-fp>`_
-PyPI projects.
-
-Modules
--------
-
-Module hashable_wrapped_ndarray
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-  - wrap readonly NDArrays to make them hashable
-  - prioritize performance over safety
-  - see PyPI project boring-math-abstract-algebra for a use case
-
-Documentation
--------------
-
-Documentation for this project is hosted on
-`GitHub Pages
-<https://grscheller.github.io/pythonic-fp/numpy>`_.
-
-Copyright and License
----------------------
-
-Copyright (c) 2025-2026 Geoffrey R. Scheller. Licensed under the Apache
-License, Version 2.0. See the LICENSE file for details.

pythonic_fp_numpy-0.1.2/src/pythonic_fp/numpy/hashable_wrapped_ndarray.py

@@ -1,235 +0,0 @@
-# Copyright 2025-2026 Geoffrey R. Scheller
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from abc import ABC, abstractmethod
-from enum import auto, Enum
-import numpy as np
-import numpy.typing as npt
-
-__all__ = [
-    'DTypes',
-    'HWrapNDArray',
-    'HWrapNDArrayNumber',
-    'HWrapNDArrayString',
-    'HWrapNDArrayBytes',
-    'HWrapNDArrayVoid',
-    'HWrapNDArrayObject',
-    'HWrapNDArrayDateTime',
-    'HWrapNDArrayTimeDelta',
-    'HWrapNDArrayBool',
-]
-
-
-class DTypes(Enum):
-    """Enumeration of closed NumPy datatypes.
-
-    .. admonition:: Groups (Unions) of NumPy datatypes closed to NumPy operations.
-
-        - number
-        - str\_
-        - bytes
-        - datetime64
-        - timedelta64
-        - bool\_
-        - void
-        - object\_
-
-    While NumPy types are extensively covariant, the NumPy C internals
-    are somewhat invariant. NumPy also suffers from what I call "Fortran
-    Disease", types get "auto-promoted" to compatible "wider types" when
-    necessary. That is fine when dealing with operators on mixed types,
-    but NumPy will auto-promote with operations on the same type.
-
-    """
-
-    number = auto()
-    str_ = auto()
-    bytes = auto()
-    void = auto()
-    object_ = auto()
-    datetime64 = auto()
-    timedelta64 = auto()
-    bool_ = auto()
-
-
-class HWrapNDArray(ABC):
-    """
-    Make NumPy NDArrays hashable.
-
-    Just making an NDArray (np.array) readonly is not enough. This class
-    stores a read-only copy of the NDArray given to the constructor and
-    is hashable.
-
-    """
-
-    __slots__ = '_ndarray', '_type', '_shape', '_hash'
-
-    def __init__(self, ndarray: npt.NDArray[np.generic]) -> None:
-        self._ndarray = np.array(ndarray, copy=True)
-        self._ndarray.setflags(write=False)
-
-        dtype = self._ndarray.dtype.type
-        if issubclass(dtype, np.number):
-            self._type = DTypes.number
-        elif isinstance(dtype, np.str_):
-            self._type = DTypes.str_
-        elif issubclass(dtype, np.bytes_):
-            self._type = DTypes.bytes
-        elif issubclass(dtype, np.datetime64):
-            self._type = DTypes.datetime64
-        elif issubclass(dtype, np.timedelta64):
-            self._type = DTypes.timedelta64
-        elif issubclass(dtype, np.bool_):
-            self._type = DTypes.bool_
-        elif issubclass(dtype, np.void):
-            self._type = DTypes.void
-        elif issubclass(dtype, np.object_):
-            self._type = DTypes.object_
-        else:
-            msg = f"HWrapNDArray: Unknow np.dtype '{dtype}'"
-            raise TypeError(msg)
-
-        self._shape = self._ndarray.shape
-        self._hash = hash((self._ndarray.tobytes(), hash((self._shape, self._type))))
-
-    @abstractmethod
-    def __repr__(self) -> str: ...
-
-    def __call__(self) -> npt.NDArray[np.number]:
-        """Return a reference to the stored NDArray.
-
-        .. warning::
-
-            For efficiency this method returns a reference to the
-            wrapped NDArray.
-
-            - Allows for faster slicing and faster operations.
-            - Use the copy method if you want a read-write copy.
-            - Never make the underlying NDArray writable!!!
-
-        """
-        return np.array(self._ndarray)
-
-    def __hash__(self) -> int:
-        return self._hash
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, HWrapNDArray):
-            return False
-        if self._shape != other._shape or self._type != other._type:
-            return False
-        return np.array_equal(self._ndarray, other._ndarray)
-
-    def __str__(self) -> str:
-        np_array_str = '  ' + str(self._ndarray).replace('\n', '\n  ')
-        return f'hwrap<\n{np_array_str}\n>'
-
-    def _repr(self) -> str:
-        stripped_repr = ''.join(repr(self._ndarray).split())
-        return f'np.{stripped_repr}'
-
-    def copy(self) -> npt.NDArray[np.number]:
-        """Return a copy of the wrapped NDArray."""
-        return np.array(self._ndarray, copy=True)
-
-
-class HWrapNDArrayNumber(HWrapNDArray):
-    """Wrap NDArrays of arbitrary NumPy numeric types."""
-
-    def __init__(self, ndarray: npt.NDArray[np.number]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayNumber({self._repr()})'
-
-
-class HWrapNDArrayString(HWrapNDArray):
-    """Wrap NDArrays of Unicode strings."""
-
-    def __init__(self, ndarray: npt.NDArray[np.str_]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayStr({self._repr()})'
-
-
-class HWrapNDArrayBytes(HWrapNDArray):
-    """Wrap NDArrays of null-terminated byte sequences."""
-
-    def __init__(self, ndarray: npt.NDArray[np.bytes_]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayBytes({self._repr()})'
-
-
-class HWrapNDArrayDateTime(HWrapNDArray):
-    """Wrap NDArrays of references to arbitrary Python objects."""
-
-    def __init__(self, ndarray: npt.NDArray[np.datetime64]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayTimeDelta({self._repr()})'
-
-
-class HWrapNDArrayTimeDelta(HWrapNDArray):
-    """Wrap NDArrays of references to arbitrary Python objects."""
-
-    def __init__(self, ndarray: npt.NDArray[np.timedelta64]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayTimeDelta({self._repr()})'
-
-
-class HWrapNDArrayVoid(HWrapNDArray):
-    """Wrap NDArrays of arbitrary byte sequences."""
-
-    def __init__(self, ndarray: npt.NDArray[np.void]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayVoid({self._repr()})'
-
-
-class HWrapNDArrayObject(HWrapNDArray):
-    """Wrap NDArrays of references to arbitrary Python objects."""
-
-    def __init__(self, ndarray: npt.NDArray[np.object_]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayObject({self._repr()})'
-
-
-class HWrapNDArrayBool(HWrapNDArray):
-    """Wrap NDArrays of Booleans.
-
-    NumPy Booleans are actual Booleans, unlike Python bools which are
-    subtypes of int.
-
-    .. note::
-
-        - ``*`` uses component-wise Boolean **and**
-        - ``+`` uses component-wise Boolean **or**
-        - ``@`` does matrix multiplication using **and** then **or**
-
-    """
-
-    def __init__(self, ndarray: npt.NDArray[np.bool_]) -> None:
-        super().__init__(ndarray)
-
-    def __repr__(self) -> str:
-        return f'HWrapNDArrayBool({self._repr()})'

pythonic_fp_numpy-0.1.2/src/pythonic_fp/numpy/hashable_wrapped_ndarray.pyi

@@ -1,48 +0,0 @@
-import abc
-import numpy as np
-import numpy.typing as npt
-from abc import ABC
-from enum import Enum
-
-__all__ = ['DTypes', 'HWrapNDArray', 'HWrapNDArrayNumber', 'HWrapNDArrayString', 'HWrapNDArrayBytes', 'HWrapNDArrayVoid', 'HWrapNDArrayObject', 'HWrapNDArrayDateTime', 'HWrapNDArrayTimeDelta', 'HWrapNDArrayBool']
-
-class DTypes(Enum):
-    number = ...
-    str_ = ...
-    bytes = ...
-    void = ...
-    object_ = ...
-    datetime64 = ...
-    timedelta64 = ...
-    bool_ = ...
-
-class HWrapNDArray(ABC, metaclass=abc.ABCMeta):
-    def __init__(self, ndarray: npt.NDArray[np.generic]) -> None: ...
-    def __call__(self) -> npt.NDArray[np.number]: ...
-    def __hash__(self) -> int: ...
-    def __eq__(self, other: object) -> bool: ...
-    def copy(self) -> npt.NDArray[np.number]: ...
-
-class HWrapNDArrayNumber(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.number]) -> None: ...
-
-class HWrapNDArrayString(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.str_]) -> None: ...
-
-class HWrapNDArrayBytes(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.bytes_]) -> None: ...
-
-class HWrapNDArrayVoid(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.void]) -> None: ...
-
-class HWrapNDArrayObject(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.object_]) -> None: ...
-
-class HWrapNDArrayDateTime(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.datetime64]) -> None: ...
-
-class HWrapNDArrayTimeDelta(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.timedelta64]) -> None: ...
-
-class HWrapNDArrayBool(HWrapNDArray):
-    def __init__(self, ndarray: npt.NDArray[np.bool_]) -> None: ...

pythonic_fp_numpy-0.1.2/tests/hashable_wrapped_ndarray/test_HWrapNDArrayNumber.py

@@ -1,86 +0,0 @@
-# Copyright 2025 Geoffrey R. Scheller
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-import numpy.typing as npt
-from boring_math.abstract_algebra.algebras.semigroup import Semigroup
-from pythonic_fp.numpy.hashable_wrapped_ndarray import HWrapNDArrayNumber
-
-type I32_2x2 = HWrapNDArrayNumber[npt.NDArray[np.int32]]
-
-
-def matrix_mult(left: I32_2x2, right: I32_2x2) -> I32_2x2:
-    return HWrapNDArrayNumber(left() @ right())
-
-
-m2x2 = Semigroup[I32_2x2](mult=matrix_mult)
-
-np_eye = HWrapNDArrayNumber(np.eye(2, dtype=np.int32))
-np_zero = HWrapNDArrayNumber(np.zeros((2, 2), dtype=np.int32))
-np_A = HWrapNDArrayNumber(np.array([[5, -1], [0, 2]], dtype=np.int32))
-np_B = HWrapNDArrayNumber(np.array([[2, -1], [-1, 2]], dtype=np.int32))
-np_C = HWrapNDArrayNumber(np.array([[1, 1], [1, 1]], dtype=np.int32))
-np_D = HWrapNDArrayNumber(np.array([[0, 1], [1, 0]], dtype=np.int32))
-np_E = HWrapNDArrayNumber(np.array([[11, -7], [-2, 4]], dtype=np.int32))
-
-
-Eye = m2x2(np_eye)
-Zero = m2x2(np_zero)
-A = m2x2(np_A)
-B = m2x2(np_B)
-C = m2x2(np_C)
-D = m2x2(np_D)
-E = m2x2(np_E)
-
-
-class Test_number_with_int32:
-    def test_equality(self) -> None:
-        assert Eye * Eye == Eye
-        assert Eye * A == A
-        assert B * Eye == B
-        assert E * Zero == Zero
-        assert Zero * E == Zero
-        assert (A * B) * C == A * (B * C)
-        assert D * D == Eye
-        assert A * B == E
-
-    def test_identity(self) -> None:
-        assert Eye * Eye is Eye
-        assert Eye * A is A
-        assert B * Eye is B
-        assert E * Zero is Zero
-        assert Zero * E is Zero
-        assert (A * B) * C is A * (B * C)
-        assert D * D is Eye
-        assert A * B is E
-
-    def test_pow(self) -> None:
-        Eye**5 == Eye
-        Eye**5 is Eye
-
-    def test_str(self) -> None:
-        assert str(A()) == 'hwrap<\n  [[ 5 -1]\n   [ 0  2]]\n>'
-
-    def test_repr(self) -> None:
-        assert repr(np_eye) == 'HWrapNDArrayNumber(np.array([[1,0],[0,1]],dtype=int32))'
-        assert repr(np_A) == 'HWrapNDArrayNumber(np.array([[5,-1],[0,2]],dtype=int32))'
-        assert repr(np_B) == 'HWrapNDArrayNumber(np.array([[2,-1],[-1,2]],dtype=int32))'
-        assert repr(HWrapNDArrayNumber(np_A() @ np_B())) == 'HWrapNDArrayNumber(np.array([[11,-7],[-2,4]],dtype=int32))'
-
-    def test_create(self) -> None:
-        np_see = HWrapNDArrayNumber(np.array([[1, 1], [1, 1]], dtype=np.int32))
-        See = m2x2(np_see)
-        assert See == C
-        assert See is C
-        assert repr(np_see) == 'HWrapNDArrayNumber(np.array([[1,1],[1,1]],dtype=int32))'