oprattr 0.2.0__tar.gz → 0.4.0__tar.gz

oprattr-0.4.0/CHANGELOG.md

@@ -0,0 +1,19 @@
+## NEXT
+
+## v0.4.0
+
+- Replace local `operators` module with equivalent module from `numerical` package
+- Redefine equality to always return a single boolean value
+
+## v0.3.0
+
+- Incorporate `numerical` package
+- Add `typeface` module
+
+## v0.2.0
+
+- Rename `_types` submodule to `abstract`
+
+## v0.1.0
+
+- Hello world!

oprattr-0.4.0/LICENSE

@@ -0,0 +1,32 @@
+
+
+BSD 3-Clause License
+
+Copyright (c) 2025, Matt Young
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

{oprattr-0.2.0 → oprattr-0.4.0}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: oprattr
-Version: 0.2.0
+Version: 0.4.0
 Summary: Add your description here
 Author-email: Matthew Young <myoung.space.science@gmail.com>
+License-File: LICENSE
 Requires-Python: >=3.10
+Requires-Dist: numerical
 Requires-Dist: numpy>=2.2.1
 Requires-Dist: scipy>=1.15.0
 Description-Content-Type: text/markdown

{oprattr-0.2.0 → oprattr-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oprattr"
-version = "0.2.0"
+version = "0.4.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -8,6 +8,7 @@ authors = [
 ]
 requires-python = ">=3.10"
 dependencies = [
+    "numerical",
     "numpy>=2.2.1",
     "scipy>=1.15.0",
 ]
@@ -21,3 +22,6 @@ dev = [
     "ipython>=8.31.0",
     "pytest>=8.3.4",
 ]
+
+[tool.uv.sources]
+numerical = { git = "https://github.com/myoung-space-science/numerical", rev = "v0.2.0" }

{oprattr-0.2.0 → oprattr-0.4.0}/src/oprattr/__init__.py

@@ -1,12 +1,13 @@
+import collections.abc
 import functools
 import numbers
-import typing
 
+from numerical import operators
 import numpy
 
-from . import mixins
-from . import operators
 from . import abstract
+from . import mixins
+from . import typeface
 from ._operations import (
     unary,
     equality,
@@ -16,7 +17,7 @@ from ._operations import (
 )
 
 
-T = typing.TypeVar('T')
+T = typeface.TypeVar('T')
 
 
 class Operand(abstract.Object[T], mixins.Numpy):
@@ -114,12 +115,21 @@ class Operand(abstract.Object[T], mixins.Numpy):
 
     def __rpow__(self, other):
         """Called for other ** self."""
-        return super().__rpow__(other)
+        return NotImplemented
 
     def __array__(self, *args, **kwargs):
         """Called for numpy.array(self)."""
         return numpy.array(self._data, *args, **kwargs)
 
+    def _apply_ufunc(self, ufunc, method, *args, **kwargs):
+        if ufunc in (numpy.equal, numpy.not_equal):
+            # NOTE: We are probably here because the left operand is a
+            # `numpy.ndarray`, which would otherwise take control and return the
+            # pure `numpy` result.
+            f = getattr(ufunc, method)
+            return equality(f, *args)
+        return super()._apply_ufunc(ufunc, method, *args, **kwargs)
+
 
 @Operand.implementation(numpy.array_equal)
 def array_equal(
@@ -155,7 +165,7 @@ def gradient(x: Operand[T], *args, **kwargs):
     return type(x)(data, **meta)
 
 
-def wrapnumpy(f: typing.Callable):
+def wrapnumpy(f: collections.abc.Callable):
     """Implement a numpy function for objects with metadata."""
     @functools.wraps(f)
     def method(x: Operand[T], **kwargs):

{oprattr-0.2.0 → oprattr-0.4.0}/src/oprattr/_operations.py

@@ -1,7 +1,6 @@
-import typing
+from numerical import operators
 
-from . import operators
-from .abstract import Object
+from .abstract import Quantity
 
 
 class MetadataError(TypeError):
@@ -11,8 +10,8 @@ class MetadataError(TypeError):
         self,
         f: operators.Operator,
         *args,
-        error: typing.Optional[str]=None,
-        key: typing.Optional[str]=None,
+        error: str | None = None,
+        key: str | None = None,
     ) -> None:
         super().__init__(*args)
         self._f = f
@@ -33,8 +32,8 @@ class MetadataError(TypeError):
 def _build_error_message(
     f: operators.Operator,
     *types: type,
-    error: typing.Optional[str]=None,
-    key: typing.Optional[str]=None,
+    error: str | None = None,
+    key: str | None = None,
 ) -> str:
     """Helper for `_raise_metadata_exception`.
     
@@ -50,9 +49,9 @@ def _build_error_message(
         if len(types) == 2:
             a, b = types
             endstr = "because {} has metadata"
-            if issubclass(a, Object):
+            if issubclass(a, Quantity):
                 return f"{errmsg} between {a} and {b} {endstr.format(str(a))}"
-            if issubclass(b, Object):
+            if issubclass(b, Quantity):
                 return f"{errmsg} between {a} and {b} {endstr.format(str(b))}"
     if errstr == 'type':
         if key is None:
@@ -71,7 +70,7 @@ def _build_error_message(
 
 def unary(f: operators.Operator, a):
     """Compute the unary operation f(a)."""
-    if isinstance(a, Object):
+    if isinstance(a, Quantity):
         meta = {}
         for key, value in a._meta.items():
             try:
@@ -86,32 +85,42 @@ def unary(f: operators.Operator, a):
 
 def equality(f: operators.Operator, a, b):
     """Compute the equality operation f(a, b)."""
-    if isinstance(a, Object) and isinstance(b, Object):
+    x = a._data if isinstance(a, Quantity) else a
+    y = b._data if isinstance(b, Quantity) else b
+    fxy = f(x, y)
+    try:
+        iter(fxy)
+    except TypeError:
+        r = bool(fxy)
+    else:
+        r = all(fxy)
+    isne = f(1, 2)
+    if isinstance(a, Quantity) and isinstance(b, Quantity):
         if a._meta != b._meta:
-            return f is operators.ne
-        return f(a._data, b._data)
-    if isinstance(a, Object):
+            return isne
+        return r
+    if isinstance(a, Quantity):
         if not a._meta:
-            return f(a._data, b)
-        return f is operators.ne
-    if isinstance(b, Object):
+            return r
+        return isne
+    if isinstance(b, Quantity):
         if not b._meta:
-            return f(a, b._data)
-        return f is operators.ne
-    return f(a, b)
+            return r
+        return isne
+    return r
 
 
 def ordering(f: operators.Operator, a, b):
     """Compute the ordering operation f(a, b)."""
-    if isinstance(a, Object) and isinstance(b, Object):
+    if isinstance(a, Quantity) and isinstance(b, Quantity):
         if a._meta == b._meta:
             return f(a._data, b._data)
         raise MetadataError(f, a, b, error='unequal') from None
-    if isinstance(a, Object):
+    if isinstance(a, Quantity):
         if not a._meta:
             return f(a._data, b)
         raise MetadataError(f, a, b, error='non-empty') from None
-    if isinstance(b, Object):
+    if isinstance(b, Quantity):
         if not b._meta:
             return f(a, b._data)
         raise MetadataError(f, a, b, error='non-empty') from None
@@ -120,15 +129,15 @@ def ordering(f: operators.Operator, a, b):
 
 def additive(f: operators.Operator, a, b):
     """Compute the additive operation f(a, b)."""
-    if isinstance(a, Object) and isinstance(b, Object):
+    if isinstance(a, Quantity) and isinstance(b, Quantity):
         if a._meta == b._meta:
             return type(a)(f(a._data, b._data), **a._meta)
         raise MetadataError(f, a, b, error='unequal') from None
-    if isinstance(a, Object):
+    if isinstance(a, Quantity):
         if not a._meta:
             return type(a)(f(a._data, b))
         raise MetadataError(f, a, b, error='non-empty') from None
-    if isinstance(b, Object):
+    if isinstance(b, Quantity):
         if not b._meta:
             return type(b)(f(a, b._data))
         raise MetadataError(f, a, b, error='non-empty') from None
@@ -137,7 +146,7 @@ def additive(f: operators.Operator, a, b):
 
 def multiplicative(f: operators.Operator, a, b):
     """Compute the multiplicative operation f(a, b)."""
-    if isinstance(a, Object) and isinstance(b, Object):
+    if isinstance(a, Quantity) and isinstance(b, Quantity):
         keys = set(a._meta) & set(b._meta)
         meta = {}
         for key in keys:
@@ -154,7 +163,7 @@ def multiplicative(f: operators.Operator, a, b):
             if key not in keys:
                 meta[key] = value
         return type(a)(f(a._data, b._data), **meta)
-    if isinstance(a, Object):
+    if isinstance(a, Quantity):
         meta = {}
         for key, value in a._meta.items():
             try:
@@ -164,7 +173,7 @@ def multiplicative(f: operators.Operator, a, b):
             else:
                 meta[key] = v
         return type(a)(f(a._data, b), **meta)
-    if isinstance(b, Object):
+    if isinstance(b, Quantity):
         meta = {}
         for key, value in b._meta.items():
             try:

oprattr-0.4.0/src/oprattr/abstract.py

@@ -0,0 +1,56 @@
+import collections.abc
+import numbers
+
+import numerical
+import numpy.typing
+
+from . import typeface
+
+
+DataType = typeface.TypeVar(
+    'DataType',
+    int,
+    float,
+    numbers.Number,
+    numpy.number,
+    numpy.typing.ArrayLike,
+    numpy.typing.NDArray,
+)
+
+
+@typeface.runtime_checkable
+class Quantity(numerical.Quantity[DataType], typeface.Protocol):
+    """Protocol for numerical objects with metadata."""
+
+    _meta: collections.abc.Mapping[str, typeface.Any]
+
+
+class Object(numerical.Real, typeface.Generic[DataType]):
+    """A real-valued object with metadata attributes."""
+
+    def __init__(
+        self,
+        __data: DataType,
+        **metadata,
+    ) -> None:
+        if not isinstance(__data, numerical.Real):
+            raise TypeError("Data input to Object must be real-valued")
+        self._data = __data
+        self._meta = metadata
+
+    def __repr__(self):
+        """Called for repr(self)."""
+        try:
+            datastr = numpy.array2string(
+                self._data,
+                separator=", ",
+                threshold=6,
+                edgeitems=2,
+                prefix=f"{self.__class__.__qualname__}(",
+                suffix=")"
+            )
+        except Exception:
+            datastr = str(self._data)
+        metastr = "metadata={" + ", ".join(f"{k!r}" for k in self._meta) + "}"
+        return f"{self.__class__.__qualname__}({datastr}, {metastr})"
+

{oprattr-0.2.0 → oprattr-0.4.0}/src/oprattr/mixins.py

@@ -1,12 +1,13 @@
+import collections.abc
 import numbers
-import typing
 
 import numpy
 
 from . import abstract
+from . import typeface
 
 
-T = typing.TypeVar('T')
+T = typeface.TypeVar('T')
 
 
 class Real:
@@ -82,7 +83,7 @@ class Real:
         return self
 
 
-UserFunction = typing.Callable[..., T]
+UserFunction = collections.abc.Callable[..., T]
 
 
 class Numpy:
@@ -127,7 +128,7 @@ class Numpy:
         numpy.ndarray,
         numbers.Number,
         list,
-        abstract.Object,
+        abstract.Quantity,
     }
 
     def __array_ufunc__(self, ufunc, method, *args, **kwargs):
@@ -162,7 +163,7 @@ class Numpy:
             return NotImplemented
         if out:
             kwargs['out'] = tuple(
-                x._data if isinstance(x, abstract.Object)
+                x._data if isinstance(x, abstract.Quantity)
                 else x for x in out
             )
         if self._implements(ufunc):
@@ -285,7 +286,7 @@ class Numpy:
         types = self._get_numpy_types(types)
         return array.__array_function__(func, types, args, kwargs)
 
-    def _get_numpy_array(self) -> typing.Optional[numpy.typing.NDArray]:
+    def _get_numpy_array(self) -> numpy.typing.NDArray | None:
         """Convert the data interface to an array for `numpy` mixin methods.
         
         Notes
@@ -324,7 +325,7 @@ class Numpy:
           `arg` if `arg` is an instance of the base object class; otherwise, it
           will return the unmodified argument.
         """
-        if isinstance(arg, abstract.Object):
+        if isinstance(arg, abstract.Quantity):
             return arg._data
         return arg
 
@@ -344,7 +345,7 @@ class Numpy:
         )
 
     @classmethod
-    def _implements(cls, operation: typing.Callable):
+    def _implements(cls, operation: collections.abc.Callable):
         """True if this class defines a custom implementation for `operation`.
         
         This is a helper methods that gracefully handles the case in which a
@@ -356,11 +357,11 @@ class Numpy:
             return False
         return result
 
-    _FUNCTIONS: typing.Dict[str, typing.Callable]=None
+    _FUNCTIONS: dict[str, collections.abc.Callable]=None
     """Internal collection of custom `numpy` function implementations."""
 
     @classmethod
-    def implementation(cls, numpy_function: typing.Callable, /):
+    def implementation(cls, numpy_function: collections.abc.Callable, /):
         """Register a custom implementation of this `numpy` function.
 
         Parameters
@@ -424,7 +425,7 @@ class Numpy:
     @classmethod
     def implement(
         cls,
-        numpy_function: typing.Callable,
+        numpy_function: collections.abc.Callable,
         user_function: UserFunction,
         /,
     ) -> None:

oprattr-0.4.0/src/oprattr/typeface.py

@@ -0,0 +1,42 @@
+"""
+Support for type annotations.
+
+This module provides a single interface to type annotations, including those
+that are not defined by the operative Python version and those that this package
+prefers to use from future versions.
+
+Examples
+--------
+* Suppose `BestType` is available in the `typing` module starting with Python
+  version 3.X and is available in the `typing_extensions` module for earlier
+  versions. If the user is running with Python version <3.X, this module will
+  import `BestType` from `typing_extensions`. Otherwise, it will import
+  `BestType` from `typing`.
+* Support `UpdatedType` is available in the `typing` module for the user's
+  version of Python, but this package wishes to take advantage of updates since
+  that version. This module will automatically import the version from
+  `typing_extensions`.
+"""
+
+import typing
+import typing_extensions
+
+
+__all__ = ()
+
+EXTENDED = [
+    'Protocol',
+]
+
+def __getattr__(name: str) -> type:
+    """Get a built-in type annotation."""
+    if name in EXTENDED:
+        return getattr(typing_extensions, name)
+    try:
+        attr = getattr(typing, name)
+    except AttributeError:
+        attr = getattr(typing_extensions, name)
+    return attr
+
+
+

oprattr-0.4.0/src/oprattr/typeface.pyi

@@ -0,0 +1,5 @@
+"""
+Type help for our custom type-annotation interface.
+"""
+from typing_extensions import *
+from typing import *

{oprattr-0.2.0 → oprattr-0.4.0}/tests/test_object.py

@@ -196,10 +196,20 @@ def test_equality():
     assert x(1) != x(-1)
     assert x(1) == 1
     assert x(1) != -1
-    assert x(1, name=Symbol('A')) == x(1, name=Symbol('A'))
-    assert x(1, name=Symbol('A')) != x(1, name=Symbol('B'))
-    assert x(1, name=Symbol('A')) != 1
-    assert 1 != x(1, name=Symbol('A'))
+    sA = Symbol('A')
+    sB = Symbol('B')
+    assert x(1, name=sA) == x(1, name=sA)
+    assert x(1, name=sA) != x(1, name=sB)
+    assert x(1, name=sA) != 1
+    assert 1 != x(1, name=sA)
+    array = numpy.array([-1, +1])
+    assert x(array) == x(array)
+    assert x(array, name=sA) == x(array, name=sA)
+    assert x(array, name=sA) != x(array, name=sB)
+    assert x(array, name=sA) != array
+    assert x(array) == array
+    assert array == x(array)
+    assert array != x(array, name=sA)
 
 
 def test_ordering():