ipor-fusion 4.0.0.dev187__tar.gz → 4.0.0.dev191__tar.gz

{ipor_fusion-4.0.0.dev187 → ipor_fusion-4.0.0.dev191}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev187
+Version: 4.0.0.dev191
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py

{ipor_fusion-4.0.0.dev187 → ipor_fusion-4.0.0.dev191}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev187"
+version = "4.0.0.dev191"
 description = "The IPOR Fusion SDK for Python"
 authors = [
     { name = "Adam Mydlarz", email = "amydlarz@gmail.com" },

{ipor_fusion-4.0.0.dev187 → ipor_fusion-4.0.0.dev191}/src/ipor_fusion/core/fuse.py

@@ -8,6 +8,7 @@ without importing that package, whose ``__init__`` loads every encoder.
 
 from abc import ABC
 from collections.abc import Sequence
+from types import MemberDescriptorType
 
 from eth_abi import encode
 from eth_typing import ChecksumAddress
@@ -55,11 +56,33 @@ class Fuse(ABC):  # noqa: B024  # ABC marks intent; no shared abstract method
         if value < 0:
             raise ValueError(f"{name} must not be negative, got {value}")
 
+    def _value_state(self) -> tuple[tuple[str, object], ...]:
+        """Every attribute the instance stores, in its ``__dict__`` or in a
+        subclass's ``__slots__``, sorted by name."""
+        state = dict(vars(self))
+        # Slot storage is a member descriptor in the declaring class's own
+        # namespace (already name-mangled). Reading each one directly, keyed by
+        # its class, keeps a base slot shadowed by a subclass attribute apart.
+        for klass in type(self).__mro__:
+            for name, member in vars(klass).items():
+                if not isinstance(member, MemberDescriptorType):
+                    continue
+                try:
+                    value = member.__get__(self, klass)
+                except AttributeError:
+                    continue
+                state[f"{klass.__module__}.{klass.__qualname__}.{name}"] = value
+        return tuple(sorted(state.items()))
+
     def __eq__(self, other: object) -> bool:
-        return type(self) is type(other) and vars(self) == vars(other)
+        return (
+            isinstance(other, Fuse)
+            and type(self) is type(other)
+            and self._value_state() == other._value_state()
+        )
 
     def __hash__(self) -> int:
-        return hash((type(self), *sorted(vars(self).items())))
+        return hash((type(self), *self._value_state()))
 
     def _action_raw(self, signature: str, values: Sequence[object]) -> FuseAction:
         selector = function_signature_to_4byte_selector(signature)

{ipor_fusion-4.0.0.dev187 → ipor_fusion-4.0.0.dev191}/tests/test_fuse_encoding.py

@@ -10,6 +10,7 @@ from ipor_fusion.core.contract import _parse_param_types
 from ipor_fusion.core.fuse_action import FuseAction
 from ipor_fusion.fuses.aave_v3 import AaveV3BorrowFuse, AaveV3SupplyFuse
 from ipor_fusion.fuses.async_action import AsyncActionFuse, AsyncActionSubstrates
+from ipor_fusion.fuses.base import Fuse
 from ipor_fusion.fuses.compound_v3 import CompoundV3SupplyFuse
 from ipor_fusion.fuses.erc4626 import ERC4626SupplyFuse
 from ipor_fusion.fuses.euler_v2 import (
@@ -893,6 +894,69 @@ class TestFuseEquality:
         assert AaveV3SupplyFuse(FUSE_ADDR) != AaveV3BorrowFuse(FUSE_ADDR)
         assert AaveV3SupplyFuse(FUSE_ADDR) != FUSE_ADDR
 
+    def test_state_kept_in_slots_counts(self):
+        class SlottedFuse(Fuse):
+            __slots__ = ("target", "__secret")
+
+            def __init__(self, address, target, secret):
+                super().__init__(address)
+                self.target = target
+                self.__secret = secret
+
+        one = SlottedFuse(FUSE_ADDR, TOKEN_A, 1)
+        assert one == SlottedFuse(FUSE_ADDR, TOKEN_A, 1)
+        assert hash(one) == hash(SlottedFuse(FUSE_ADDR, TOKEN_A, 1))
+        assert one != SlottedFuse(FUSE_ADDR, TOKEN_B, 1)
+        assert one != SlottedFuse(FUSE_ADDR, TOKEN_A, 2)
+        assert len({one, SlottedFuse(FUSE_ADDR, TOKEN_B, 1)}) == 2
+
+    def test_a_shadowed_base_slot_still_counts(self):
+        class Parent(Fuse):
+            __slots__ = ("target",)
+
+        class Child(Parent):
+            __slots__ = ("target",)
+
+        def child(base_target):
+            fuse = Child(FUSE_ADDR)
+            Parent.__dict__["target"].__set__(fuse, base_target)
+            fuse.target = 3
+            return fuse
+
+        assert child(1) != child(2)
+        assert len({child(1), child(2)}) == 2
+        assert child(1) == child(1)
+
+    def test_a_private_slot_of_an_all_underscore_class_counts(self):
+        class ___(Fuse):  # noqa: N801
+            __slots__ = ("__secret",)
+
+            def __init__(self, address, secret):
+                super().__init__(address)
+                self.__secret = secret
+
+        assert ___(FUSE_ADDR, 1) != ___(FUSE_ADDR, 2)
+        assert ___(FUSE_ADDR, 1) == ___(FUSE_ADDR, 1)
+
+    def test_slots_declared_by_an_iterator_count(self):
+        class IteratorFuse(Fuse):
+            __slots__ = iter(("target",))
+
+        def fuse(target):
+            instance = IteratorFuse(FUSE_ADDR)
+            instance.target = target  # pyright: ignore[reportAttributeAccessIssue]
+            return instance
+
+        assert fuse(1) != fuse(2)
+        assert len({fuse(1), fuse(2)}) == 2
+
+    def test_an_unset_slot_is_left_out(self):
+        class LazyFuse(Fuse):
+            __slots__ = "cached"
+
+        assert LazyFuse(FUSE_ADDR) == LazyFuse(FUSE_ADDR)
+        assert hash(LazyFuse(FUSE_ADDR)) == hash(LazyFuse(FUSE_ADDR))
+
 
 # ── Input Validation ──────────────────────────────────────────────────