oprattr 0.3.0__tar.gz → 0.4.0__tar.gz

{oprattr-0.3.0 → oprattr-0.4.0}/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oprattr
-Version: 0.3.0
+Version: 0.4.0
 Summary: Add your description here
 Author-email: Matthew Young <myoung.space.science@gmail.com>
 License-File: LICENSE

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

@@ -1,6 +1,6 @@
 [project]
 name = "oprattr"
-version = "0.3.0"
+version = "0.4.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [

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

@@ -2,11 +2,11 @@ import collections.abc
 import functools
 import numbers
 
+from numerical import operators
 import numpy
 
 from . import abstract
 from . import mixins
-from . import operators
 from . import typeface
 from ._operations import (
     unary,
@@ -121,6 +121,15 @@ class Operand(abstract.Object[T], mixins.Numpy):
         """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(

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

@@ -1,4 +1,5 @@
-from . import operators
+from numerical import operators
+
 from .abstract import Quantity
 
 
@@ -84,19 +85,29 @@ def unary(f: operators.Operator, a):
 
 def equality(f: operators.Operator, a, b):
     """Compute the equality operation f(a, b)."""
+    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)
+            return isne
+        return r
     if isinstance(a, Quantity):
         if not a._meta:
-            return f(a._data, b)
-        return f is operators.ne
+            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):

{oprattr-0.3.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():

oprattr-0.3.0/src/oprattr/operators.py

@@ -1,41 +0,0 @@
-"""
-A namespace for operators used by this package's `Object` class.
-"""
-
-import collections.abc
-import builtins
-import operator
-
-
-class Operator:
-    """Base class for enhanced operators."""
-    def __init__(self, __f: collections.abc.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')
-