params-proto 3.2.1__tar.gz → 3.2.3__tar.gz

{params_proto-3.2.1 → params_proto-3.2.3}/.idea/workspace.xml

@@ -257,7 +257,9 @@
       <workItem from="1768382679094" duration="3000" />
       <workItem from="1769135684123" duration="4247000" />
       <workItem from="1769569263076" duration="1863000" />
-      <workItem from="1769933004821" duration="3502000" />
+      <workItem from="1769933004821" duration="4284000" />
+      <workItem from="1770101044881" duration="1209000" />
+      <workItem from="1770110071925" duration="622000" />
     </task>
     <task id="LOCAL-00001" summary="add design specs">
       <option name="closed" value="true" />
@@ -298,7 +300,7 @@
     <SUITE FILE_PATH="coverage/params_proto$scratch.coverage" NAME="scratch Coverage Results" MODIFIED="1762422882594" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/params_proto$demo_params_proto.coverage" NAME="demo_params_proto Coverage Results" MODIFIED="1762230413342" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/scratch" />
     <SUITE FILE_PATH="coverage/params_proto$pytest_for_tests_test_v3_test_proto_cli_test_proto_cli.coverage" NAME="pytest for tests.test_v3.test_proto_cli.test_proto_cli Coverage Results" MODIFIED="1762386112096" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/params_proto$pytest_in_tests.coverage" NAME="pytest in tests Coverage Results" MODIFIED="1769934711414" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/tests" />
+    <SUITE FILE_PATH="coverage/params_proto$pytest_in_tests.coverage" NAME="pytest in tests Coverage Results" MODIFIED="1769937166592" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/tests" />
     <SUITE FILE_PATH="coverage/params_proto$pytest_in_test_parse_env_template_py.coverage" NAME="pytest in test_parse_env_template.py Coverage Results" MODIFIED="1762242493577" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/params_proto$pytest_in_test_v2.coverage" NAME="pytest in test_v2 Coverage Results" MODIFIED="1762232660046" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/tests/test_v2" />
     <SUITE FILE_PATH="coverage/params_proto$pytest_in_test_neo_proto_py.coverage" NAME="pytest in test_neo_proto.py Coverage Results" MODIFIED="1762233469671" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />

{params_proto-3.2.1 → params_proto-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: params-proto
-Version: 3.2.1
+Version: 3.2.3
 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
@@ -23,7 +23,6 @@ Requires-Dist: argcomplete
 Requires-Dist: argparse
 Requires-Dist: expandvars
 Requires-Dist: termcolor
-Requires-Dist: waterbear>=2.6.8
 Provides-Extra: dev
 Requires-Dist: pandas; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'

{params_proto-3.2.1 → params_proto-3.2.3}/docs/release_notes.md

@@ -2,6 +2,36 @@
 
 This page contains the release history and changelog for params-proto.
 
+## Version 3.2.3 (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 other user-defined protocol methods: `__call__`, `__iter__`, `__next__`, `__getitem__`, `__len__`, etc.
+  - Root cause: method copying skipped all dunder methods, but should preserve user-defined ones
+
+### 🧪 Testing
+
+- Added comprehensive tests for context manager and other Python protocol preservation
+
+---
+
+## Version 3.2.2 (2025-02-03)
+
+### 🐛 Bug Fixes
+
+- **`super()` in `@proto` Methods**: Fixed `super()` calls failing with `TypeError: super(type, obj): obj must be an instance or subtype of type`
+  - Methods using `super()` in `@proto` or `@proto.prefix` decorated classes now work correctly
+  - Root cause: decorated class was recreated as sibling instead of subclass of original
+  - Fix: decorated class is now a proper subclass, preserving the MRO chain
+
+- **`@proto` Inheriting from `@proto`**: Fixed `TypeError: duplicate base class ptype` when a `@proto` class inherits from another `@proto` class
+  - Nested `@proto` inheritance now works correctly
+  - Metaclass merging skips duplicate `ptype` bases
+
+---
+
 ## Version 3.2.1 (2025-02-01)
 
 ### 🐛 Bug Fixes

{params_proto-3.2.1 → params_proto-3.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "params-proto"
-version = "3.2.1"
+version = "3.2.3"
 description = "Modern Hyper Parameter Management for Machine Learning"
 authors = [
     { name = "Ge Yang" }
@@ -32,7 +32,6 @@ classifiers = [
 ]
 
 dependencies = [
-    "waterbear>=2.6.8",
     "argparse",
     "argcomplete",
     "expandvars",

params_proto-3.2.3/scratch/test_super.py

@@ -0,0 +1,146 @@
+"""Test super() calls inside @proto and @proto.prefix decorated classes."""
+
+from params_proto import proto
+
+
+# Test 1: Basic inheritance with @proto
+class BaseClass:
+    base_value: int = 10
+
+    def base_method(self):
+        return f"base: {self.base_value}"
+
+
+@proto
+class ChildProto(BaseClass):
+    child_value: int = 20
+
+    def child_method(self):
+        base_result = super().base_method()
+        return f"{base_result}, child: {self.child_value}"
+
+
+# Test 2: Inheritance with @proto.prefix
+class BaseConfig:
+    lr: float = 0.01
+
+    def describe(self):
+        return f"lr={self.lr}"
+
+
+@proto.prefix
+class ChildConfig(BaseConfig):
+    batch_size: int = 32
+
+    def describe(self):
+        base = super().describe()
+        return f"{base}, batch_size={self.batch_size}"
+
+
+# Test 3: Inheritance between two @proto decorated classes
+@proto
+class ParentProto:
+    parent_attr: str = "parent"
+
+    def get_info(self):
+        return f"Parent: {self.parent_attr}"
+
+
+@proto
+class GrandchildProto(ParentProto):
+    grandchild_attr: str = "grandchild"
+
+    def get_info(self):
+        parent_info = super().get_info()
+        return f"{parent_info}, Grandchild: {self.grandchild_attr}"
+
+
+# Test 4: __post_init__ with super() (undecorated base)
+class BaseWithInit:
+    value: int = 1
+    processed: bool = False
+
+    def __post_init__(self):
+        self.processed = True
+
+
+@proto
+class ChildWithInit(BaseWithInit):
+    multiplier: int = 2
+    child_processed: bool = False
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.child_processed = True
+        self.value *= self.multiplier
+
+
+def main():
+    print("=" * 60)
+    print("Testing super() in @proto and @proto.prefix classes")
+    print("=" * 60)
+
+    # Test 1
+    print("\n--- Test 1: Basic inheritance with @proto ---")
+    try:
+        child = ChildProto()
+        print(f"child class: {child.__class__}")
+        print(f"child MRO: {child.__class__.__mro__}")
+        print(f"ChildProto: {ChildProto}")
+        print(f"ChildProto MRO: {ChildProto.__mro__}")
+        print(f"isinstance(child, ChildProto): {isinstance(child, ChildProto)}")
+        print(f"isinstance(child, BaseClass): {isinstance(child, BaseClass)}")
+        result = child.child_method()
+        print(f"Result: {result}")
+        assert "base: 10" in result, f"Expected 'base: 10' in result"
+        assert "child: 20" in result, f"Expected 'child: 20' in result"
+        print("✓ PASSED")
+    except Exception as e:
+        import traceback
+        print(f"✗ FAILED: {e}")
+        traceback.print_exc()
+
+    # Test 2
+    print("\n--- Test 2: Inheritance with @proto.prefix ---")
+    try:
+        config = ChildConfig()
+        result = config.describe()
+        print(f"Result: {result}")
+        assert "lr=" in result, f"Expected 'lr=' in result"
+        assert "batch_size=" in result, f"Expected 'batch_size=' in result"
+        print("✓ PASSED")
+    except Exception as e:
+        print(f"✗ FAILED: {e}")
+
+    # Test 3
+    print("\n--- Test 3: Inheritance between @proto classes ---")
+    try:
+        grandchild = GrandchildProto()
+        result = grandchild.get_info()
+        print(f"Result: {result}")
+        assert "Parent:" in result, f"Expected 'Parent:' in result"
+        assert "Grandchild:" in result, f"Expected 'Grandchild:' in result"
+        print("✓ PASSED")
+    except Exception as e:
+        import traceback
+        print(f"✗ FAILED: {e}")
+        traceback.print_exc()
+
+    # Test 4
+    print("\n--- Test 4: __post_init__ with super() ---")
+    try:
+        obj = ChildWithInit()
+        print(f"value={obj.value}, processed={obj.processed}, child_processed={obj.child_processed}")
+        assert obj.processed, "Expected processed=True from parent __post_init__"
+        assert obj.child_processed, "Expected child_processed=True from child __post_init__"
+        assert obj.value == 2, f"Expected value=2 (1*2), got {obj.value}"
+        print("✓ PASSED")
+    except Exception as e:
+        print(f"✗ FAILED: {e}")
+
+    print("\n" + "=" * 60)
+    print("All tests completed!")
+
+
+if __name__ == "__main__":
+    main()

params_proto-3.2.3/scratch/test_super_minimal.py

@@ -0,0 +1,53 @@
+"""Minimal test for super() issue."""
+
+from params_proto import proto
+
+
+class Base:
+    def method(self):
+        return "base"
+
+
+@proto
+class Child(Base):
+    attr: int = 1
+
+    def method(self):
+        # This should call Base.method()
+        return f"child + {super().method()}"
+
+
+# Test without instantiation
+print("Child class:", Child)
+print("Child id:", id(Child))
+print("Child.__mro__:", Child.__mro__)
+print("Child.__proto_original_class__:", Child.__proto_original_class__)
+print("Original class id:", id(Child.__proto_original_class__))
+print("Same class?", Child is Child.__proto_original_class__)
+
+# Test instantiation
+print("\nCreating instance...")
+child = Child()
+print("Instance class:", child.__class__)
+print("Instance type:", type(child))
+
+# Check what method is on the instance
+print("\nMethod on instance:", child.method)
+
+# Try calling
+print("\nCalling method...")
+try:
+    result = child.method()
+    print(f"Result: {result}")
+except Exception as e:
+    print(f"Error: {e}")
+
+    # Debug: manually call the original method
+    print("\nDebug: Trying to call original method directly...")
+    original_cls = Child.__proto_original_class__
+    print(f"Original class: {original_cls}")
+    print(f"Original method: {original_cls.method}")
+
+    # Create instance via original class
+    from params_proto.proto import _SINGLETONS
+    print(f"\nSINGLETONS: {_SINGLETONS}")

{params_proto-3.2.1 → params_proto-3.2.3}/src/params_proto/proto.py

@@ -698,10 +698,23 @@ class ptype(type):
 
     # 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:
+      # Skip proto fields (fields are handled above)
+      if name in annotations:
         continue
 
+      # For dunder methods, only copy user-defined ones (not inherited from object/type)
+      if name.startswith("__"):
+        # Check if this dunder method is user-defined (not from object or type)
+        is_user_defined = False
+        for klass in original_cls.__mro__:
+          if klass is object or klass is type:
+            break
+          if name in klass.__dict__:
+            is_user_defined = True
+            break
+        if not is_user_defined:
+          continue
+
       # Check raw descriptor in MRO to detect staticmethod/classmethod (handles inheritance)
       raw_attr = None
       for klass in original_cls.__mro__:
@@ -844,10 +857,15 @@ def proto(
       # Handle existing metaclass
       existing_meta = type(obj)
       if existing_meta is not type:
-        # Merge with existing metaclass
-        class MergedMeta(existing_meta, ptype):
-          pass
-        metaclass = MergedMeta
+        # Check if existing metaclass is already ptype or a subclass of ptype
+        if issubclass(existing_meta, ptype):
+          # Already using ptype, no need to merge
+          metaclass = existing_meta
+        else:
+          # Merge with existing metaclass
+          class MergedMeta(existing_meta, ptype):
+            pass
+          metaclass = MergedMeta
       else:
         metaclass = ptype
 
@@ -872,9 +890,12 @@ def proto(
         namespace[key] = value
 
       # 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).
       new_cls = metaclass(
         obj.__name__,
-        obj.__bases__,
+        (obj,),
         namespace
       )
 

{params_proto-3.2.1 → params_proto-3.2.3}/src/params_proto/v1/params_proto.py

@@ -17,7 +17,13 @@ import inspect
 import re
 from typing import Callable, TypeVar, Union
 
-from waterbear import DefaultBear
+try:
+    from waterbear import DefaultBear
+except ImportError:
+    raise ImportError(
+        "params_proto.v1 requires waterbear. Install it with: pip install waterbear\n"
+        "Note: The v3 API (from params_proto import proto) does not require waterbear."
+    )
 
 
 def _strtobool(val):

{params_proto-3.2.1 → params_proto-3.2.3}/src/params_proto/v2/proto.py

@@ -8,7 +8,13 @@ from types import BuiltinFunctionType, SimpleNamespace
 from warnings import warn
 
 from expandvars import expandvars
-from waterbear import Bear
+try:
+    from waterbear import Bear
+except ImportError:
+    raise ImportError(
+        "params_proto.v2 requires waterbear. Install it with: pip install waterbear\n"
+        "Note: The v3 API (from params_proto import proto) does not require waterbear."
+    )
 
 from params_proto.parse_env_template import all_available
 from params_proto.v2.utils import dot_to_deps

params_proto-3.2.3/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