params-proto 3.2.2__tar.gz → 3.2.4__tar.gz

{params_proto-3.2.2 → params_proto-3.2.4}/.idea/workspace.xml

@@ -4,7 +4,10 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="7a053ece-f497-4c97-ac58-a86c807155ac" name="Changes" comment="add design specs" />
+    <list default="true" id="7a053ece-f497-4c97-ac58-a86c807155ac" name="Changes" comment="add design specs">
+      <change beforePath="$PROJECT_DIR$/src/params_proto/proto.py" beforeDir="false" afterPath="$PROJECT_DIR$/src/params_proto/proto.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/tests/test_v3/test_class_level_methods.py" beforeDir="false" afterPath="$PROJECT_DIR$/tests/test_v3/test_class_level_methods.py" afterDir="false" />
+    </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@@ -224,8 +227,8 @@
   <component name="SharedIndexes">
     <attachedChunks>
       <set>
-        <option value="bundled-js-predefined-d6986cc7102b-9b0f141eb926-JavaScript-PY-253.30387.127" />
-        <option value="bundled-python-sdk-3944b0c99280-6d6dccd035ac-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-253.30387.127" />
+        <option value="bundled-js-predefined-d6986cc7102b-9b0f141eb926-JavaScript-PY-253.30387.173" />
+        <option value="bundled-python-sdk-4762d8aabb82-6d6dccd035ac-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-253.30387.173" />
       </set>
     </attachedChunks>
   </component>
@@ -260,6 +263,8 @@
       <workItem from="1769933004821" duration="4284000" />
       <workItem from="1770101044881" duration="1209000" />
       <workItem from="1770110071925" duration="622000" />
+      <workItem from="1770163240415" duration="5903000" />
+      <workItem from="1770274540569" duration="373000" />
     </task>
     <task id="LOCAL-00001" summary="add design specs">
       <option name="closed" value="true" />

{params_proto-3.2.2 → params_proto-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: params-proto
-Version: 3.2.2
+Version: 3.2.4
 Summary: Modern Hyper Parameter Management for Machine Learning
 Project-URL: Homepage, https://github.com/geyang/params-proto
 Project-URL: Documentation, https://params-proto.readthedocs.io

{params_proto-3.2.2 → params_proto-3.2.4}/docs/release_notes.md

@@ -2,6 +2,25 @@
 
 This page contains the release history and changelog for params-proto.
 
+## Version 3.2.4 (2025-02-04)
+
+### 🐛 Bug Fixes
+
+- **Context Manager Protocol**: Fixed regression where `__enter__` and `__exit__` methods were stripped from `@proto` and `@proto.prefix` decorated classes
+  - Classes implementing context managers now work correctly with `with` statements
+  - Also preserves all user-defined protocol methods: `__call__`, `__iter__`, `__next__`, `__getitem__`, `__len__`, etc.
+
+- **Simplified Implementation**: Removed method wrapping that caused issues
+  - Decorated class is now a proper subclass of the original, so methods are inherited naturally
+  - No more wrapping of methods to return `self` - use explicit `return self` if needed
+  - Standard Python semantics: classmethods receive `cls`, not bound to instance
+
+### 🧪 Testing
+
+- Added comprehensive tests for context manager and other Python protocol preservation
+
+---
+
 ## Version 3.2.2 (2025-02-03)
 
 ### 🐛 Bug Fixes

{params_proto-3.2.2 → params_proto-3.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "params-proto"
-version = "3.2.2"
+version = "3.2.4"
 description = "Modern Hyper Parameter Management for Machine Learning"
 authors = [
     { name = "Ge Yang" }

{params_proto-3.2.2 → params_proto-3.2.4}/src/params_proto/proto.py

@@ -694,46 +694,9 @@ class ptype(type):
 
     # Update the instance's class to the decorated class
     # This allows isinstance(instance, DecoratedClass) to work
+    # Since cls is a subclass of original_cls, methods are inherited naturally
     object.__setattr__(instance, "__class__", cls)
 
-    # Copy methods from original class and wrap to return self
-    for name in dir(original_cls):
-      # Skip dunder methods and proto fields (fields are handled above)
-      if name.startswith("__") or name in annotations:
-        continue
-
-      # Check raw descriptor in MRO to detect staticmethod/classmethod (handles inheritance)
-      raw_attr = None
-      for klass in original_cls.__mro__:
-        if name in klass.__dict__:
-          raw_attr = klass.__dict__[name]
-          break
-
-      attr = getattr(original_cls, name)
-
-      # Only process actual methods (staticmethod, classmethod, or function)
-      if isinstance(raw_attr, staticmethod):
-        # For staticmethod, use directly (no binding needed)
-        method = attr
-      elif isinstance(raw_attr, classmethod) or inspect.isfunction(raw_attr) or inspect.ismethod(attr):
-        # For instance methods and classmethods, bind to instance
-        # Note: classmethods bound to instance is intentional for @proto
-        # semantics where instances have all attributes accessible
-        method = attr.__get__(instance, original_cls)
-      else:
-        # Not a method (e.g., _EnvVar, property, or other callable), skip
-        continue
-
-      # Wrap it to return self if it returns None
-      def make_wrapper(m):
-        def wrapper(*args, **kwargs):
-          result = m(*args, **kwargs)
-          return instance if result is None else result
-
-        return wrapper
-
-      setattr(instance, name, make_wrapper(method))
-
     return instance
 
 
@@ -856,30 +819,32 @@ def proto(
       else:
         metaclass = ptype
 
-      # Recreate the class with ptype as its metaclass
-      # Collect class namespace (attributes and methods)
-      namespace = {}
-      for key in dir(obj):
-        if not key.startswith("__") or key in ("__annotations__", "__module__", "__qualname__", "__doc__"):
-          try:
-            # Use __dict__ to preserve classmethod/staticmethod descriptors
-            # getattr() would return bound methods instead of descriptors
-            if key in obj.__dict__:
-              namespace[key] = obj.__dict__[key]
-            else:
-              namespace[key] = getattr(obj, key)
-          except AttributeError:
-            pass
+      # Create new class with metaclass as subclass of original
+      # Since new class inherits from obj, methods are inherited naturally.
+      # We only need to provide:
+      # - Module/qualname metadata
+      # - Annotations (so annotated fields are visible on the class)
+      # - Resolved default values (with EnvVars resolved)
+      namespace = {
+        "__module__": obj.__module__,
+        "__qualname__": obj.__qualname__,
+        "__doc__": obj.__doc__,
+        "__annotations__": annotations,
+      }
 
-      # Replace _EnvVar objects with resolved values from defaults
-      # This ensures the descriptor doesn't interfere with class attribute access
-      for key, value in defaults.items():
-        namespace[key] = value
+      # Add resolved default values (EnvVars are already resolved in defaults dict)
+      # Also set None for annotated fields without defaults so they're accessible
+      for key in annotations.keys():
+        if key in defaults:
+          namespace[key] = defaults[key]
+        else:
+          namespace[key] = None
 
-      # Create new class with metaclass
-      # IMPORTANT: Use (obj,) as bases to make new class a SUBCLASS of original.
-      # This ensures super() works correctly - the original class is in the MRO,
-      # so Python's super() validation passes when checking isinstance(self, original_class).
+      # Create new class as SUBCLASS of original.
+      # This ensures:
+      # 1. super() works correctly (original class is in MRO)
+      # 2. Methods, staticmethods, classmethods are inherited naturally
+      # 3. isinstance(instance, DecoratedClass) works
       new_cls = metaclass(
         obj.__name__,
         (obj,),

{params_proto-3.2.2 → params_proto-3.2.4}/tests/test_v3/test_class_level_methods.py

@@ -150,13 +150,15 @@ class TestProtoPrefixWithMethods:
 
     obj = Config()
 
-    # Classmethod should have access to config attributes via instance
+    # Classmethod should have access to config attributes via class
     assert obj.get_lr() == 0.01
 
-    # Note: classmethods on instances are bound to the instance,
-    # so they see instance attributes (not class-level updates)
-    obj.lr = 0.001
-    assert obj.get_lr() == 0.001
+    # Note: classmethods receive the class (cls), not instance,
+    # so they see class-level values (standard Python behavior)
+    obj.lr = 0.001  # Instance attribute
+    assert obj.get_lr() == 0.01  # Still sees class default
+    Config.lr = 0.002  # Class attribute
+    assert obj.get_lr() == 0.002  # Now sees class update
 
   def test_proto_prefix_with_instance_method(self):
     """Test @proto.prefix on class with regular instance method."""

{params_proto-3.2.2 → params_proto-3.2.4}/tests/test_v3/test_nested_cli.py

@@ -172,19 +172,20 @@ class TestThreeLayerNesting:
       """)
 
     # Try to override nested model config via deep dot notation
-    # This tests if --config.model.hidden_size works
+    # Plain dataclasses use unprefixed syntax (--epochs, not --config.epochs)
+    # Only @proto.prefix decorated classes require prefixed syntax
     result = run_cli(
       script,
       [
-        "--config:TrainConfig",
-        "--config.epochs",
+        "train-config",  # subcommand name (kebab-case)
+        "--epochs",
         "200",
-        "--config.model.hidden_size",
+        "--model.hidden_size",
         "512",
-        "--config.model.num_layers",
+        "--model.num_layers",
         "8",
       ],
-      expect_error=True,  # This may not be supported yet
+      expect_error=True,  # Deep nested dot notation may not be supported yet
     )
 
     # Check if it succeeded or failed
@@ -196,7 +197,7 @@ class TestThreeLayerNesting:
     else:
       # If it failed, this documents the current limitation
       pytest.skip(
-        "Deep nested dot notation (--config.model.hidden_size) not yet supported"
+        "Deep nested dot notation (--model.hidden_size) not yet supported"
       )
 
 

params_proto-3.2.4/tests/test_v3/test_proto_context_manager.py

@@ -0,0 +1,179 @@
+"""Test that @proto and @proto.prefix preserve context manager protocol."""
+
+import pytest
+from params_proto import proto
+
+
+class TestContextManager:
+    """Test context manager protocol preservation."""
+
+    def test_proto_prefix_context_manager(self):
+        """Test that @proto.prefix preserves __enter__ and __exit__."""
+
+        @proto.prefix
+        class RUN:
+            prefix: str = "test"
+            entered: bool = False
+            exited: bool = False
+
+            def __enter__(self):
+                self.entered = True
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                self.exited = True
+                return False
+
+        run = RUN()
+
+        # Check methods exist
+        assert hasattr(run, "__enter__"), "Should have __enter__ method"
+        assert hasattr(run, "__exit__"), "Should have __exit__ method"
+
+        # Test actual context manager usage
+        with run as r:
+            assert r.entered, "Should have called __enter__"
+            assert not r.exited, "Should not have called __exit__ yet"
+
+        assert run.exited, "Should have called __exit__"
+
+    def test_proto_context_manager(self):
+        """Test that @proto preserves __enter__ and __exit__."""
+
+        @proto
+        class Session:
+            name: str = "session"
+            active: bool = False
+
+            def __enter__(self):
+                self.active = True
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                self.active = False
+                return False
+
+        session = Session()
+
+        with session as s:
+            assert s.active, "Should be active inside context"
+
+        assert not session.active, "Should be inactive after context"
+
+    def test_context_manager_with_exception(self):
+        """Test context manager handles exceptions correctly."""
+
+        @proto.prefix
+        class RUN:
+            prefix: str = "test"
+            exc_info: tuple = None
+
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                self.exc_info = (exc_type, exc_val, exc_tb)
+                return True  # Suppress exception
+
+        run = RUN()
+
+        with run:
+            raise ValueError("test error")
+
+        # Exception should have been captured
+        assert run.exc_info[0] is ValueError
+        assert str(run.exc_info[1]) == "test error"
+
+    def test_context_manager_inheritance(self):
+        """Test context manager works with inheritance."""
+
+        class BaseContext:
+            def __enter__(self):
+                self.entered = True
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                self.exited = True
+                return False
+
+        @proto.prefix
+        class ChildRUN(BaseContext):
+            prefix: str = "child"
+            entered: bool = False
+            exited: bool = False
+
+        run = ChildRUN()
+
+        with run as r:
+            assert r.entered
+
+        assert run.exited
+
+
+class TestOtherProtocols:
+    """Test other Python protocol methods are preserved."""
+
+    def test_callable_protocol(self):
+        """Test __call__ is preserved."""
+
+        @proto.prefix
+        class Callable:
+            value: int = 0
+            call_count: int = 0
+
+            def __call__(self, x):
+                self.call_count += 1
+                return self.value + x
+
+        c = Callable()
+        c.value = 10
+
+        result = c(5)
+        assert result == 15
+        assert c.call_count == 1
+
+    def test_iterator_protocol(self):
+        """Test __iter__ and __next__ are preserved."""
+
+        @proto.prefix
+        class Counter:
+            start: int = 0
+            end: int = 3
+            _current: int = 0
+
+            def __iter__(self):
+                self._current = self.start
+                return self
+
+            def __next__(self):
+                if self._current >= self.end:
+                    raise StopIteration
+                value = self._current
+                self._current += 1
+                return value
+
+        counter = Counter()
+        result = list(counter)
+        assert result == [0, 1, 2]
+
+    def test_container_protocol(self):
+        """Test __getitem__ and __len__ are preserved."""
+
+        @proto.prefix
+        class Container:
+            items: list = None
+
+            def __post_init__(self):
+                if self.items is None:
+                    self.items = [1, 2, 3]
+
+            def __getitem__(self, index):
+                return self.items[index]
+
+            def __len__(self):
+                return len(self.items)
+
+        c = Container()
+        assert len(c) == 3
+        assert c[0] == 1
+        assert c[1] == 2

{params_proto-3.2.2 → params_proto-3.2.4}/tests/test_v3/test_proto_core.py

@@ -71,7 +71,8 @@ def test_canonical_usage():
   Nerf.lr = 0.001
 
   # main function
-  nerf = Nerf().main()
+  nerf = Nerf()
+  nerf.main()
   assert nerf.seed == 100, "should be overriden"
   assert nerf.lr == 0.001, "should be overriden"