srforge 0.16.2__tar.gz → 0.16.3__tar.gz

{srforge-0.16.2 → srforge-0.16.3}/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.3] - 2026-11-08
+
+### Added
+
+- **Dotted module paths in `srforge.utils.model_ops`.** `replace_module`,
+  `get_submodule` and `replace_with_modules_from_another_model` accept a
+  path to a nested module — `sr.regnet` is `model.sr.regnet`, `blocks.0` a
+  `ModuleList` entry — so a config can swap a module deep inside a wrapper
+  model. Plain names behave as before; the root model is still returned, so
+  an `io:` block on the node binds the whole model; a missing segment is
+  named in the error, with what exists at that level.
+
 ## [0.16.2] - 2026-10-19
 
 ### Added
@@ -1602,7 +1614,8 @@ likelihood of affecting a given codebase:
 - `Preprocessor` and `TransformationSpec` removed; `EntryTransform` is standalone.
 - Codebase cleanup: `assert` replaced with proper exceptions, `super()` modernized.
 
-[Unreleased]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.16.2...HEAD
+[Unreleased]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.16.3...HEAD
+[0.16.3]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.16.2...v0.16.3
 [0.16.2]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.16.1...v0.16.2
 [0.16.1]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.16.0...v0.16.1
 [0.16.0]: https://gitlab.com/tarasiewicztomasz/sr-forge/-/compare/v0.15.4...v0.16.0

{srforge-0.16.2/srforge.egg-info → srforge-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srforge
-Version: 0.16.2
+Version: 0.16.3
 Summary: Super‑resolution research framework for PyTorch with a focus on simplicity and flexibility using config files.
 Author-email: Tomasz Tarasiewicz <tomasz.tarasiewicz@polsl.pl>
 Project-URL: Homepage, https://gitlab.com/tarasiewicztomasz/sr-forge

{srforge-0.16.2 → srforge-0.16.3}/srforge/utils/model_ops.py

@@ -5,16 +5,44 @@ import torch
 
 logger = logging.getLogger(__name__)
 
+def _resolve(model: torch.nn.Module, path: str, role: str):
+    """``(parent, last_name)`` for a dotted *path* such as ``"sr.regnet"``.
+
+    Walks one attribute per segment, so ``"sr.regnet"`` is
+    ``model.sr.regnet`` and a ``ModuleList`` index works too
+    (``"blocks.0"``). A plain name (no dot) resolves to ``(model, name)``,
+    exactly as before dotted paths were supported. A missing segment raises,
+    naming it and what the module at that point does have.
+    """
+    segments = path.split(".")
+    parent = model
+    for depth, segment in enumerate(segments):
+        if not hasattr(parent, segment):
+            where = ".".join(segments[:depth]) or "the model itself"
+            children = ([n for n, _ in parent.named_children()]
+                        if isinstance(parent, torch.nn.Module) else [])
+            raise ValueError(
+                f"Module '{path}' not found in {role} "
+                f"'{model.__class__.__name__}': '{segment}' does not exist "
+                f"under {where}"
+                + (f" (it has: {', '.join(children)})" if children else "") + "."
+            )
+        if depth < len(segments) - 1:
+            parent = getattr(parent, segment)
+    last = segments[-1]
+    return parent, last
+
+
 def get_submodule(source_module: torch.nn.Module, submodule_name: str) -> torch.nn.Module:
     """
     Get a submodule from a module by name.
     :param source_module: The model instance.
-    :param submodule_name: The name of the module to get.
+    :param submodule_name: The name of the module to get — a plain attribute
+        name, or a dotted path to a nested one (``"sr.regnet"``).
     :return: The module instance (torch.nn.Module).
     """
-    if not hasattr(source_module, submodule_name):
-        raise ValueError(f"Module '{submodule_name}' not found in model '{source_module.__class__.__name__}'.")
-    module = getattr(source_module, submodule_name)
+    parent, name = _resolve(source_module, submodule_name, "model")
+    module = getattr(parent, name)
     logger.info(f"Extracted module '{submodule_name}' from model '{source_module.__class__.__name__}'.")
     return module
 
@@ -27,11 +55,12 @@ def replace_with_modules_from_another_model(target_model: torch.nn.Module,
     Replace a single or multiple modules in a target model with modules from a source model.
     :param target_model: The model instance to modify.
     :param target_module_name: The name(s) of the module(s) in the target model to replace.
+        Plain names or dotted paths to nested modules (``"sr.regnet"``).
     :param source_model: The model instance to copy modules from.
-    :param source_module_name: The name(s) of the module(s) in the source model to copy.
-                               If None, the same names as target_module_name are used.
+    :param source_module_name: The name(s) of the module(s) in the source model to copy,
+        plain or dotted. If None, the same names as target_module_name are used.
 
-    :return: The modified target model instance.
+    :return: The modified target model instance (the root, not the replaced module).
     """
     if source_module_name is None:
         source_module_name = target_module_name
@@ -43,11 +72,9 @@ def replace_with_modules_from_another_model(target_model: torch.nn.Module,
         raise ValueError("'target_module_name' and 'source_module_name' parameters must have the same length if provided as lists.")
 
     for t_name, s_name in zip(target_module_name, source_module_name):
-        if not hasattr(target_model, t_name):
-            raise ValueError(f"Module '{t_name}' not found in target model '{target_model.__class__.__name__}'.")
-        if not hasattr(source_model, s_name):
-            raise ValueError(f"Module '{s_name}' not found in source model '{source_model.__class__.__name__}'.")
-        setattr(target_model, t_name, get_submodule(source_model, s_name))
+        parent, last = _resolve(target_model, t_name, "target model")
+        s_parent, s_last = _resolve(source_model, s_name, "source model")
+        setattr(parent, last, getattr(s_parent, s_last))
         logger.info(f"Replaced module '{t_name}' in target model with module '{s_name}' from source model.")
 
     return target_model
@@ -58,14 +85,16 @@ def replace_module(target_model: torch.nn.Module,
     """
     Replace a module in a target model with a new module.
     :param target_model: The model instance to modify.
-    :param target_module_name: The name of the module in the target model to replace.
+    :param target_module_name: The name of the module in the target model to
+        replace — a plain attribute name, or a dotted path to a nested one
+        (``"sr.regnet"`` replaces ``target_model.sr.regnet``).
     :param new_module: The new module instance to insert.
 
-    :return: The modified target model instance.
+    :return: The modified target model instance — always the root model, so
+        an ``io:`` block on this config node binds the whole model.
     """
-    if not hasattr(target_model, target_module_name):
-        raise ValueError(f"Module '{target_module_name}' not found in target model '{target_model.__class__.__name__}'.")
-    setattr(target_model, target_module_name, new_module)
+    parent, last = _resolve(target_model, target_module_name, "target model")
+    setattr(parent, last, new_module)
     logger.info(f"Replaced module '{target_module_name}' in target model with new module '{new_module.__class__.__name__}'.")
 
-    return target_model
+    return target_model

{srforge-0.16.2 → srforge-0.16.3/srforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srforge
-Version: 0.16.2
+Version: 0.16.3
 Summary: Super‑resolution research framework for PyTorch with a focus on simplicity and flexibility using config files.
 Author-email: Tomasz Tarasiewicz <tomasz.tarasiewicz@polsl.pl>
 Project-URL: Homepage, https://gitlab.com/tarasiewicztomasz/sr-forge

{srforge-0.16.2 → srforge-0.16.3}/srforge.egg-info/SOURCES.txt

@@ -321,6 +321,7 @@ tests/utils/test_child_processes.py
 tests/utils/test_init_audit.py
 tests/utils/test_io_parsing.py
 tests/utils/test_iospec.py
+tests/utils/test_model_ops_dotted.py
 tests/utils/test_multigpu.py
 tests/utils/test_utils_coverage.py
 tests/utils/test_version_check.py

{srforge-0.16.2 → srforge-0.16.3}/srforge.egg-info/scm_file_list.json

@@ -315,6 +315,7 @@
     "tests/utils/test_init_audit.py",
     "tests/utils/test_io_parsing.py",
     "tests/utils/test_iospec.py",
+    "tests/utils/test_model_ops_dotted.py",
     "tests/utils/test_multigpu.py",
     "tests/utils/test_utils_coverage.py",
     "tests/utils/test_version_check.py"

srforge-0.16.3/srforge.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.16.3",
+  "distance": 0,
+  "node": "g4ce74f192d3127977c356930d2db82f78ea2b6fd",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-11-08"
+}

srforge-0.16.3/tests/utils/test_model_ops_dotted.py

@@ -0,0 +1,106 @@
+"""Dotted module paths in srforge.utils.model_ops ("sr.regnet")."""
+import pytest
+import torch
+from omegaconf import OmegaConf
+
+from srforge.config import ConfigResolver
+from srforge.models import Model
+from srforge.registry import register_class
+from srforge.utils.model_ops import (get_submodule, replace_module,
+                                     replace_with_modules_from_another_model)
+
+
+class _Inner(torch.nn.Module):
+    def __init__(self, scale: float = 1.0):
+        super().__init__()
+        self.regnet = torch.nn.Linear(2, 2)
+        self.blocks = torch.nn.ModuleList([torch.nn.Identity(), torch.nn.Identity()])
+        self.scale = scale
+
+
+@register_class
+class DottedProbeModel(Model):
+    """An outer model holding an inner one as ``sr``, like a joint model."""
+
+    def __init__(self):
+        super().__init__()
+        self.sr = _Inner()
+        self.head = torch.nn.Linear(2, 2)
+
+    def _forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.head(self.sr.regnet(x))
+
+
+def test_get_submodule_follows_a_dotted_path():
+    model = DottedProbeModel()
+    assert get_submodule(model, "sr.regnet") is model.sr.regnet
+    assert get_submodule(model, "sr.blocks.1") is model.sr.blocks[1]
+
+
+def test_replace_module_replaces_the_nested_module_and_returns_the_root():
+    model = DottedProbeModel()
+    new = torch.nn.Linear(2, 2)
+    out = replace_module(model, "sr.regnet", new)
+    assert out is model
+    assert model.sr.regnet is new
+
+
+def test_replace_with_modules_from_another_model_accepts_dotted_paths():
+    target, source = DottedProbeModel(), DottedProbeModel()
+    replace_with_modules_from_another_model(target, "sr.regnet", source, "sr.regnet")
+    assert target.sr.regnet is source.sr.regnet
+    replace_with_modules_from_another_model(target, ["head"], source)
+    assert target.head is source.head
+
+
+def test_plain_names_behave_as_before():
+    model = DottedProbeModel()
+    assert get_submodule(model, "head") is model.head
+    new = torch.nn.Linear(2, 2)
+    assert replace_module(model, "head", new) is model and model.head is new
+
+
+@pytest.mark.parametrize("path, missing, where", [
+    ("sr.regnett", "regnett", "under sr"),
+    ("srr.regnet", "srr", "under the model itself"),
+    ("nope", "nope", "under the model itself"),
+])
+def test_a_missing_segment_is_named(path, missing, where):
+    with pytest.raises(ValueError, match=rf"'{missing}' does not exist {where}"):
+        replace_module(DottedProbeModel(), path, torch.nn.Identity())
+
+
+def test_the_error_lists_what_is_there():
+    with pytest.raises(ValueError, match=r"it has: regnet, blocks"):
+        get_submodule(DottedProbeModel(), "sr.regnett")
+
+
+def test_an_outer_replace_module_node_keeps_its_io_binding():
+    """The CD config shape: replace_module outermost, nested target, the
+    new module taken from another model, and io: on the outer node."""
+    cfg = OmegaConf.create("""
+    donor:
+      _target: DottedProbeModel
+    model:
+      _target: srforge.utils.model_ops.replace_module
+      params:
+        target_model:
+          _target: DottedProbeModel
+        target_module_name: sr.regnet
+        new_module:
+          _target: srforge.utils.model_ops.get_submodule
+          params:
+            source_module: ${ref:donor}
+            submodule_name: sr.regnet
+      io:
+        inputs: {x: lr}
+        outputs: sr_out
+    """)
+    resolver = ConfigResolver(cfg)
+    model = resolver(cfg.model)
+    donor = resolver(cfg.donor)
+    assert isinstance(model, DottedProbeModel)
+    assert model.sr.regnet is donor.sr.regnet
+    from srforge.data import Entry
+    out = model(Entry(lr=torch.rand(1, 2)))
+    assert out["sr_out"].shape == (1, 2)

srforge-0.16.2/srforge.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.16.2",
-  "distance": 0,
-  "node": "g7a5781d22b88e838359eed91e66df950fa1030a5",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-19"
-}