oprattr 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

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/_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/abstract.py

@@ -1,108 +1,13 @@
-import abc
+import collections.abc
 import numbers
-import typing
 
+import numerical
 import numpy.typing
 
+from . import typeface
 
-@typing.runtime_checkable
-class Real(typing.Protocol):
-    """Abstract protocol for real-valued objects."""
 
-    @abc.abstractmethod
-    def __abs__(self):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __pos__(self):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __neg__(self):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __eq__(self, other):
-        return False
-
-    @abc.abstractmethod
-    def __ne__(self, other):
-        return True
-
-    @abc.abstractmethod
-    def __le__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __lt__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __ge__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __gt__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __add__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __radd__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __sub__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rsub__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __mul__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rmul__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __truediv__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rtruediv__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __floordiv__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rfloordiv__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __mod__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rmod__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __pow__(self, other):
-        return NotImplemented
-
-    @abc.abstractmethod
-    def __rpow__(self, other):
-        return NotImplemented
-
-
-DataType = typing.TypeVar(
+DataType = typeface.TypeVar(
     'DataType',
     int,
     float,
@@ -113,7 +18,14 @@ DataType = typing.TypeVar(
 )
 
 
-class Object(Real, typing.Generic[DataType]):
+@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__(
@@ -121,7 +33,7 @@ class Object(Real, typing.Generic[DataType]):
         __data: DataType,
         **metadata,
     ) -> None:
-        if not isinstance(__data, Real):
+        if not isinstance(__data, numerical.Real):
             raise TypeError("Data input to Object must be real-valued")
         self._data = __data
         self._meta = metadata

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/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/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.dist-info → oprattr-0.4.0.dist-info}/METADATA

@@ -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.4.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+oprattr/__init__.py,sha256=NPLnNea_NmyxQUX7DLqaC7YB67XATQ2gEhkPmBGpRpo,6044
+oprattr/_operations.py,sha256=UruyOQGERwfiKgJTjJkt_C00BBVFvJMXes2tFxEkXJI,5985
+oprattr/abstract.py,sha256=I3AYc8F79IMgH2esaKSvCTFelV_jFxWRuvXDuTZ8E94,1407
+oprattr/mixins.py,sha256=_qqhReZu9Ta83irVihUrhggcObEj4lyp-3_S9K2hEog,16875
+oprattr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oprattr/typeface.py,sha256=FPGAdTZUmS_jd56PcZ5tCcUE_rXNubINBpVMQLRenvg,1214
+oprattr/typeface.pyi,sha256=6gVdlDXtwl6Qyv07JWuRhM78VTGzds0pJ2KZUAAGcXs,113
+oprattr-0.4.0.dist-info/METADATA,sha256=uCu_KrutswZW3e1YyOGuPa_ywL3dO818GJpBmRBFfwI,375
+oprattr-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+oprattr-0.4.0.dist-info/licenses/LICENSE,sha256=m2oXG0JDq5RzaKTS57TvGyNq5cWcV4_nfmLZjzLdYTg,1513
+oprattr-0.4.0.dist-info/RECORD,,

oprattr-0.4.0.dist-info/licenses/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/operators.py

@@ -1,41 +0,0 @@
-"""
-A namespace for operators used by this package's `Object` class.
-"""
-
-import builtins
-import operator
-import typing
-
-
-class Operator:
-    """Base class for enhanced operators."""
-    def __init__(self, __f: typing.Callable, operation: str):
-        self._f = __f
-        self._operation = operation
-
-    def __repr__(self):
-        """Called for repr(self)."""
-        return self._operation
-
-    def __call__(self, *args, **kwds):
-        """Called for self(*args, **kwds)."""
-        return self._f(*args, **kwds)
-
-
-eq = Operator(operator.eq, r'a == b')
-ne = Operator(operator.ne, r'a != b')
-lt = Operator(operator.lt, r'a < b')
-le = Operator(operator.le, r'a <= b')
-gt = Operator(operator.gt, r'a > b')
-ge = Operator(operator.ge, r'a >= b')
-abs = Operator(builtins.abs, r'abs(a)')
-pos = Operator(operator.pos, r'+a')
-neg = Operator(operator.neg, r'-a')
-add = Operator(operator.add, r'a + b')
-sub = Operator(operator.sub, r'a - b')
-mul = Operator(operator.mul, r'a * b')
-truediv = Operator(operator.truediv, r'a / b')
-floordiv = Operator(operator.floordiv, r'a // b')
-mod = Operator(operator.mod, r'a % b')
-pow = Operator(builtins.pow, r'a ** b')
-

oprattr-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-oprattr/__init__.py,sha256=RSJjoTQWRT-C_OYYKHKlzHVQgvnA7yM1aDTs1k4XtjM,5557
-oprattr/_operations.py,sha256=DiWIXLaTFQfI_IKHB89DqEgDLgxzeWpyY1CrbxLtQqI,5831
-oprattr/abstract.py,sha256=TzTt9GkQ5KZc5kqajdLnn8EcvxzMj3SALSI5iJrB6Vk,3182
-oprattr/mixins.py,sha256=KLgCsqIbE3WglZ3psrdRGb-agmVwBEqrASIpkGkDL54,16807
-oprattr/operators.py,sha256=skqQpIezGSDbsmB2h-UNnxG_7aDGT6PsnvUkondpwOg,1154
-oprattr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oprattr-0.2.0.dist-info/METADATA,sha256=PwniUyhE28lVnnRoAcZCNAEgVF50AdxbqqND9Jdil_s,328
-oprattr-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-oprattr-0.2.0.dist-info/RECORD,,