params-proto 3.2.3__py3-none-any.whl → 3.3.0__py3-none-any.whl

params_proto/cli/cli_parse.py

@@ -83,6 +83,101 @@ def _get_required_fields(cls) -> List[str]:
   return required
 
 
+def _is_nested_dataclass(annotation) -> bool:
+  """Check if annotation is a nested dataclass type."""
+  import dataclasses
+
+  # Skip primitive types and common non-dataclass types
+  if annotation in {int, str, float, bool, list, dict, tuple, set, Path, type(None)}:
+    return False
+
+  # Check if it's a type and a dataclass
+  if isinstance(annotation, type) and dataclasses.is_dataclass(annotation):
+    return True
+
+  return False
+
+
+def _get_nested_attrs(cls, prefix: str = "") -> Dict[str, tuple]:
+  """Recursively get all nested dataclass attributes.
+
+  Returns dict mapping dotted-kebab-name -> (dotted_underscore_path, leaf_type)
+
+  Example for TrainConfig with nested ModelConfig:
+    {
+      "model.hidden-size": ("model.hidden_size", int),
+      "model.num-layers": ("model.num_layers", int),
+    }
+  """
+  import dataclasses
+
+  result = {}
+  annotations = getattr(cls, "__annotations__", {})
+
+  for attr_name, attr_type in annotations.items():
+    kebab_attr = attr_name.replace("_", "-")
+    full_kebab = f"{prefix}{kebab_attr}" if prefix else kebab_attr
+    full_underscore = f"{prefix.replace('-', '_')}{attr_name}" if prefix else attr_name
+
+    if _is_nested_dataclass(attr_type):
+      # Recursively get nested attributes
+      nested = _get_nested_attrs(attr_type, prefix=f"{full_kebab}.")
+      result.update(nested)
+    else:
+      # Leaf attribute
+      result[full_kebab] = (full_underscore, attr_type)
+
+  return result
+
+
+def _set_nested_value(d: dict, path: str, value: Any) -> None:
+  """Set a value in a nested dict using dot notation path.
+
+  Example: _set_nested_value({}, "model.hidden_size", 512)
+           Results in {"model": {"hidden_size": 512}}
+  """
+  parts = path.split(".")
+  current = d
+  for part in parts[:-1]:
+    if part not in current:
+      current[part] = {}
+    current = current[part]
+  current[parts[-1]] = value
+
+
+def _build_nested_instance(cls, flat_attrs: dict, nested_attrs: dict):
+  """Build a dataclass instance with nested dataclass fields.
+
+  Args:
+      cls: The dataclass class to instantiate
+      flat_attrs: Dict of top-level attribute values
+      nested_attrs: Dict of nested dicts for nested dataclass fields
+
+  Returns:
+      Instance of cls with nested dataclasses properly constructed
+  """
+  import dataclasses
+
+  final_attrs = dict(flat_attrs)
+  annotations = getattr(cls, "__annotations__", {})
+
+  for attr_name, attr_type in annotations.items():
+    if attr_name in nested_attrs and _is_nested_dataclass(attr_type):
+      # Recursively build nested dataclass
+      nested_data = nested_attrs[attr_name]
+      # Separate flat and nested for the nested class
+      nested_flat = {}
+      nested_nested = {}
+      for k, v in nested_data.items():
+        if isinstance(v, dict):
+          nested_nested[k] = v
+        else:
+          nested_flat[k] = v
+      final_attrs[attr_name] = _build_nested_instance(attr_type, nested_flat, nested_nested)
+
+  return cls(**final_attrs)
+
+
 def _match_class_by_name(name: str, classes: list) -> Union[type, None]:
   """Match a string to one of the Union classes.
 
@@ -193,6 +288,7 @@ def parse_cli_args(wrapper) -> Dict[str, Any]:
   # Build unprefixed union attribute map for classes NOT decorated with @proto.prefix
   # Maps attr-name -> (union_param_name, attr_name_underscore)
   # Classes in _SINGLETONS are @proto.prefix decorated and require prefixed attrs
+  # Also includes nested dataclass attributes (e.g., "model.hidden-size")
   unprefixed_attrs = {}
   for kebab_name, (param_name, union_classes) in union_params.items():
     for cls in union_classes:
@@ -201,12 +297,20 @@ def parse_cli_args(wrapper) -> Dict[str, Any]:
       if is_prefix_class:
         continue
       if hasattr(cls, "__annotations__"):
-        for attr_name in cls.__annotations__:
+        for attr_name, attr_type in cls.__annotations__.items():
           kebab_attr = attr_name.replace("_", "-")
           # Map to the union param (first one wins if multiple unions have same attr)
           if kebab_attr not in unprefixed_attrs:
             unprefixed_attrs[kebab_attr] = (param_name, attr_name)
 
+          # Check for nested dataclass and add its attributes
+          if _is_nested_dataclass(attr_type):
+            nested_attrs = _get_nested_attrs(attr_type, prefix=f"{kebab_attr}.")
+            for nested_kebab, (nested_path, nested_type) in nested_attrs.items():
+              full_path = f"{attr_name}.{nested_path.split('.', 1)[1] if '.' in nested_path else nested_path}"
+              if nested_kebab not in unprefixed_attrs:
+                unprefixed_attrs[nested_kebab] = (param_name, full_path)
+
   # Parse arguments
   result = {}
   prefix_values = {}  # (singleton, param_name) -> value
@@ -451,21 +555,65 @@ def parse_cli_args(wrapper) -> Dict[str, Any]:
   # Instantiate Union classes with collected attributes
   for param_name, selected_class in union_selections.items():
     # Collect attributes for this Union parameter
-    attrs = {}
-    for (union_param, attr_name), value_str in union_attrs.items():
+    # Separate flat (top-level) and nested attributes
+    flat_attrs = {}
+    nested_attrs = {}  # For nested dataclass fields
+
+    for (union_param, attr_path), value_str in union_attrs.items():
       if union_param == param_name:
-        # Get the type annotation for this attribute
-        if hasattr(selected_class, "__annotations__"):
-          attr_type = selected_class.__annotations__.get(attr_name, str)
-          try:
-            attrs[attr_name] = _convert_type(value_str, attr_type)
-          except (ValueError, TypeError):
-            raise SystemExit(
-              f"error: invalid value for --{param_name.replace('_', '-')}.{attr_name.replace('_', '-')}: {value_str}"
-            )
+        # Check if this is a nested path (contains dots)
+        if "." in attr_path:
+          # Nested attribute like "model.hidden_size"
+          parts = attr_path.split(".")
+          top_level = parts[0]
+          rest_path = ".".join(parts[1:])
+
+          # Get the type of the nested field
+          if hasattr(selected_class, "__annotations__"):
+            top_type = selected_class.__annotations__.get(top_level)
+            if top_type and _is_nested_dataclass(top_type):
+              # Find the leaf type by traversing the path
+              current_type = top_type
+              for part in parts[1:]:
+                if hasattr(current_type, "__annotations__"):
+                  current_type = current_type.__annotations__.get(part, str)
+                else:
+                  current_type = str
+                  break
+
+              try:
+                value = _convert_type(value_str, current_type)
+              except (ValueError, TypeError):
+                raise SystemExit(
+                  f"error: invalid value for --{attr_path.replace('_', '-')}: {value_str}"
+                )
+
+              # Store in nested structure
+              if top_level not in nested_attrs:
+                nested_attrs[top_level] = {}
+              _set_nested_value(nested_attrs[top_level], rest_path, value)
+              continue
+
+          # Fallback: treat as string
+          if top_level not in nested_attrs:
+            nested_attrs[top_level] = {}
+          _set_nested_value(nested_attrs[top_level], rest_path, value_str)
         else:
-          # No annotations, treat as string
-          attrs[attr_name] = value_str
+          # Top-level attribute
+          if hasattr(selected_class, "__annotations__"):
+            attr_type = selected_class.__annotations__.get(attr_path, str)
+            try:
+              flat_attrs[attr_path] = _convert_type(value_str, attr_type)
+            except (ValueError, TypeError):
+              raise SystemExit(
+                f"error: invalid value for --{param_name.replace('_', '-')}.{attr_path.replace('_', '-')}: {value_str}"
+              )
+          else:
+            # No annotations, treat as string
+            flat_attrs[attr_path] = value_str
+
+    # Merge flat_attrs into attrs for compatibility with existing code
+    attrs = flat_attrs
 
     # Assign positional args to required fields of the selected class
     if param_name in union_positional and union_positional[param_name]:
@@ -508,17 +656,21 @@ def parse_cli_args(wrapper) -> Dict[str, Any]:
               attrs[key] = value
         break
 
-    # Check for missing required fields
+    # Check for missing required fields (only check top-level, nested have defaults)
     required_fields = _get_required_fields(selected_class)
     for field_name in required_fields:
-      if field_name not in attrs:
+      if field_name not in attrs and field_name not in nested_attrs:
         raise SystemExit(
           f"error: {selected_class.__name__} requires argument: {field_name}"
         )
 
     # Instantiate the class with collected attributes
     try:
-      instance = selected_class(**attrs)
+      if nested_attrs:
+        # Build with nested dataclass support
+        instance = _build_nested_instance(selected_class, attrs, nested_attrs)
+      else:
+        instance = selected_class(**attrs)
       result[param_name] = instance
     except TypeError as e:
       raise SystemExit(f"error: failed to instantiate {selected_class.__name__}: {e}")

params_proto/proto.py

@@ -694,59 +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 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__:
-        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
 
 
@@ -869,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.3.dist-info → params_proto-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: params-proto
-Version: 3.2.3
+Version: 3.3.0
 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.3.dist-info → params_proto-3.3.0.dist-info}/RECORD

@@ -3,11 +3,11 @@ params_proto/app.py,sha256=UySpd1op3M44Szk6Ekyn0fJcnZsQvMTMPdaEybwWsLE,19
 params_proto/documentation.py,sha256=mIqmcwGWo8tM1BuNzLIwVTzdbQ3qyPus7yWTaOce4dM,8091
 params_proto/envvar.py,sha256=A87jxSAQ2tjbKLbrm96lblV90zNdtBGCSV6QRe2DrgA,8398
 params_proto/parse_env_template.py,sha256=mXTvKpNhT2jGr3HpwKw42shd18O0QACmSJn6yWMDdKA,1298
-params_proto/proto.py,sha256=CYLLEKT8mDcxi25q75wIjHuoS3U_7cMvWuqFRmeTYAQ,39996
+params_proto/proto.py,sha256=9l_WFj3yfKbW74Jo-247rnJzNsinQHZ2wqW9K158Zeo,38081
 params_proto/type_utils.py,sha256=x68rL5m76ZFRKsCRgH_i_4vLpt6ldWEsEAalgacFIH8,7364
 params_proto/cli/__init__.py,sha256=sLpN3GmaBqd_d0J0nvUNOeGlV74_-jQGW0nDUU34tjA,493
 params_proto/cli/ansi_help.py,sha256=-1gzbvOpi9GjPlqgiINOYQAfIstzg0-ukv1se88TYCQ,10967
-params_proto/cli/cli_parse.py,sha256=kVBSgCCVZk32NOfPfyj-pYWXBLyqitFZzsfme8LspcE,18835
+params_proto/cli/cli_parse.py,sha256=jdywU2wDFsHCShMozvOLe2EUbl7V1Q7wWBMmZvewYSA,24401
 params_proto/cli/help_gen.py,sha256=Iv9MWC7TJT4_OUWozTfCr8-Nmp_-K8Ohoim_dtsN5AY,12921
 params_proto/hyper/__init__.py,sha256=4zMnKk9H7NPlaTTRzbL2MC7anzwkBbd2_kW51aYhCPs,157
 params_proto/hyper/proxies.py,sha256=OMiaKK-gQx-zT1xeCmZevBSDgWUwwkzz0n54A5_wC60,4492
@@ -20,7 +20,7 @@ params_proto/v2/hyper.py,sha256=onBAkT8Ja8IkeHEOq1AwCdTuBzAnthIe766ZE0lAy-M,1146
 params_proto/v2/partial.py,sha256=_ovi4NY8goYgHurfYt1OV0E9DSMXGYucjMVIyG1Q_xc,983
 params_proto/v2/proto.py,sha256=-BTTwFOhJsaPnujwFIDh14QMB8r_ZdridK9I2Jkqd_U,19228
 params_proto/v2/utils.py,sha256=5EWvwboZDTsCYfzSED_J6RVFyNLIlf95nIu4p_ZSVxA,3540
-params_proto-3.2.3.dist-info/METADATA,sha256=bKvvnv82Bs4UkhnDvsNyWXoGPjhX7fDf0U9_IiCoXJA,8959
-params_proto-3.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-params_proto-3.2.3.dist-info/licenses/LICENSE.md,sha256=c2qSYi9tUMZtzj9SEsMeKhub5LJUmHwBtDLiIMM5b6U,1526
-params_proto-3.2.3.dist-info/RECORD,,
+params_proto-3.3.0.dist-info/METADATA,sha256=evqSOimTwLNTpF2OkokqEPbJf-GRQ6o4gVx9denyqGk,8959
+params_proto-3.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+params_proto-3.3.0.dist-info/licenses/LICENSE.md,sha256=c2qSYi9tUMZtzj9SEsMeKhub5LJUmHwBtDLiIMM5b6U,1526
+params_proto-3.3.0.dist-info/RECORD,,