objectstate 2.0.0__tar.gz → 2.1.1__tar.gz

{objectstate-2.0.0 → objectstate-2.1.1}/.github/badges/coverage.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 74.21%"><title>coverage: 74.21%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#ea7233"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">74.21%</text><text x="865" y="150" fill-opacity=".3" textLength="430">74.21%</text></g><text x="865" y="140" textLength="430">74.21%</text></g></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="coverage: 75.78%"><title>coverage: 75.78%</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#67ac09"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">coverage</text><text x="315" y="150" fill-opacity=".3" textLength="510">coverage</text></g><text x="315" y="140" textLength="510">coverage</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">75.78%</text><text x="865" y="150" fill-opacity=".3" textLength="430">75.78%</text></g><text x="865" y="140" textLength="430">75.78%</text></g></g></svg>

{objectstate-2.0.0 → objectstate-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objectstate
-Version: 2.0.0
+Version: 2.1.1
 Summary: Generic lazy dataclass configuration framework with dual-axis inheritance and contextvars-based resolution
 Project-URL: Homepage, https://github.com/OpenHCSDev/objectstate
 Project-URL: Documentation, https://objectstate.readthedocs.io
@@ -21,6 +21,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.11
 Requires-Dist: dill>=0.4.0
+Requires-Dist: pycodify<0.3,>=0.2.0
 Requires-Dist: python-introspect<0.3,>=0.2.0
 Provides-Extra: dev
 Requires-Dist: black==26.5.1; extra == 'dev'
@@ -136,6 +137,22 @@ ensure_global_config_context(GlobalPipelineConfig, global_config)
 pip install objectstate
 ```
 
+## Saving Configs as Python Source
+
+`objectstate.codegen` registers a [pycodify](https://github.com/OpenHCSDev/pycodify)
+formatter for lazy dataclasses. Source is written from raw field values, so an
+inherited `None` stays inherited when the file is loaded back:
+
+```python
+import objectstate.codegen  # registers the formatter
+from pycodify import Assignment, generate_python_source
+
+source = generate_python_source(Assignment("config", lazy_config), clean_mode=True)
+```
+
+Clean mode writes only constructor-set fields and concrete values; full mode
+writes every field.
+
 ## ObjectState Registry
 
 ObjectState separates mutable working state from saved baseline, enabling dirty tracking and undo/redo:
@@ -290,19 +307,19 @@ class GlobalPipelineConfig:
 # Use the decorator on a new config class
 @global_pipeline_config
 @dataclass
-class WellFilterConfig:
-    well_filter: str = None
+class PartitionFilterConfig:
+    partition_filter: str = None
     mode: str = "include"
 
 # After module loading, GlobalPipelineConfig automatically has:
-# - well_filter_config: WellFilterConfig = WellFilterConfig()
-# And LazyWellFilterConfig is auto-created
+# - partition_filter_config: PartitionFilterConfig = PartitionFilterConfig()
+# And LazyPartitionFilterConfig is auto-created
 ```
 
 **How it works:**
 - Decorated classes are injected as fields into `GlobalPipelineConfig`
-- Field name is snake_case of class name (e.g., `WellFilterConfig` → `well_filter_config`)
-- Lazy version is automatically created (e.g., `LazyWellFilterConfig`)
+- Field name is snake_case of class name (e.g., `PartitionFilterConfig` → `partition_filter_config`)
+- Lazy version is automatically created (e.g., `LazyPartitionFilterConfig`)
 - Injection happens at end of module loading via `_inject_all_pending_fields()`
 
 This enables a clean, modular configuration structure where each component's config is automatically part of the global configuration.

{objectstate-2.0.0 → objectstate-2.1.1}/README.md

@@ -100,6 +100,22 @@ ensure_global_config_context(GlobalPipelineConfig, global_config)
 pip install objectstate
 ```
 
+## Saving Configs as Python Source
+
+`objectstate.codegen` registers a [pycodify](https://github.com/OpenHCSDev/pycodify)
+formatter for lazy dataclasses. Source is written from raw field values, so an
+inherited `None` stays inherited when the file is loaded back:
+
+```python
+import objectstate.codegen  # registers the formatter
+from pycodify import Assignment, generate_python_source
+
+source = generate_python_source(Assignment("config", lazy_config), clean_mode=True)
+```
+
+Clean mode writes only constructor-set fields and concrete values; full mode
+writes every field.
+
 ## ObjectState Registry
 
 ObjectState separates mutable working state from saved baseline, enabling dirty tracking and undo/redo:
@@ -254,19 +270,19 @@ class GlobalPipelineConfig:
 # Use the decorator on a new config class
 @global_pipeline_config
 @dataclass
-class WellFilterConfig:
-    well_filter: str = None
+class PartitionFilterConfig:
+    partition_filter: str = None
     mode: str = "include"
 
 # After module loading, GlobalPipelineConfig automatically has:
-# - well_filter_config: WellFilterConfig = WellFilterConfig()
-# And LazyWellFilterConfig is auto-created
+# - partition_filter_config: PartitionFilterConfig = PartitionFilterConfig()
+# And LazyPartitionFilterConfig is auto-created
 ```
 
 **How it works:**
 - Decorated classes are injected as fields into `GlobalPipelineConfig`
-- Field name is snake_case of class name (e.g., `WellFilterConfig` → `well_filter_config`)
-- Lazy version is automatically created (e.g., `LazyWellFilterConfig`)
+- Field name is snake_case of class name (e.g., `PartitionFilterConfig` → `partition_filter_config`)
+- Lazy version is automatically created (e.g., `LazyPartitionFilterConfig`)
 - Injection happens at end of module loading via `_inject_all_pending_fields()`
 
 This enables a clean, modular configuration structure where each component's config is automatically part of the global configuration.

{objectstate-2.0.0 → objectstate-2.1.1}/docs/architectural_fixes.rst

@@ -65,8 +65,8 @@ Fix 2: Enable Real-Time MRO Inheritance
 
 **Problem:** During ``_recompute_invalid_fields()``, the code was using
 ``self.object_instance`` (original saved state) instead of reconstructing from current
-parameters. This broke real-time MRO inheritance—editing ``WellFilterConfig.well_filter``
-wouldn't update placeholders for inheriting fields like ``PathPlanningConfig.well_filter``.
+parameters. This broke real-time MRO inheritance—editing ``PartitionFilterConfig.partition_filter``
+wouldn't update placeholders for inheriting fields like ``PathPlanningConfig.partition_filter``.
 
 **Solution:** Reconstruct current object from parameters without delegate sync:
 
@@ -233,7 +233,7 @@ Testing & Validation
 These fixes were validated through:
 
 1. **Manual testing**: Save GlobalPipelineConfig → no crash, descendants clear dirty markers
-2. **Real-time inheritance**: Edit WellFilterConfig → inheriting fields update immediately
+2. **Real-time inheritance**: Edit PartitionFilterConfig → inheriting fields update immediately
 3. **Legacy compatibility**: Old snapshots with ``saved_parameters=None`` load correctly
 4. **Multi-level inheritance**: Global → Pipeline → Step inheritance works correctly
 

{objectstate-2.0.0 → objectstate-2.1.1}/docs/architecture.rst

@@ -348,20 +348,20 @@ When you use the generated decorator, the decorated class is automatically injec
 
    @global_pipeline_config
    @dataclass
-   class WellFilterConfig:
-       well_filter: str = None
+   class PartitionFilterConfig:
+       partition_filter: str = None
        mode: str = "include"
 
    # After module loading, GlobalPipelineConfig has:
-   # - well_filter_config: WellFilterConfig = WellFilterConfig()
-   # And LazyWellFilterConfig is auto-created
+   # - partition_filter_config: PartitionFilterConfig = PartitionFilterConfig()
+   # And LazyPartitionFilterConfig is auto-created
 
 **Injection process:**
 
 1. Decorated classes are registered for injection
 2. At module load completion, ``_inject_all_pending_fields()`` is called
-3. Field name is snake_case of class name (``WellFilterConfig`` → ``well_filter_config``)
-4. Lazy version is created (``LazyWellFilterConfig``)
+3. Field name is snake_case of class name (``PartitionFilterConfig`` → ``partition_filter_config``)
+4. Lazy version is created (``LazyPartitionFilterConfig``)
 5. Both the field and lazy class are added to the global config
 
 **Benefits:**
@@ -384,9 +384,9 @@ Sets all inherited fields from parent classes to ``None`` by default:
 .. code-block:: python
 
    @dataclass
-   class StepWellFilterConfig:
+   class StepPartitionFilterConfig:
        persistent: bool = True
-       well_filter: str = None
+       partition_filter: str = None
 
    @dataclass
    class StreamingDefaults:
@@ -395,10 +395,10 @@ Sets all inherited fields from parent classes to ``None`` by default:
 
    @global_pipeline_config(inherit_as_none=True)  # Default
    @dataclass
-   class StreamingConfig(StepWellFilterConfig, StreamingDefaults):
+   class StreamingConfig(StepPartitionFilterConfig, StreamingDefaults):
        """Uses multiple inheritance.
 
-       All inherited fields (persistent, well_filter, host, port)
+       All inherited fields (persistent, partition_filter, host, port)
        are automatically set to None for proper lazy resolution.
        """
        stream_type: str = "napari"

{objectstate-2.0.0 → objectstate-2.1.1}/docs/examples/dual_axis.rst

@@ -197,9 +197,9 @@ The ``inherit_as_none`` parameter enables proper dual-axis inheritance when usin
 
    # Base class with some fields
    @dataclass
-   class StepWellFilterConfig:
+   class StepPartitionFilterConfig:
        persistent: bool = True
-       well_filter: str = None
+       partition_filter: str = None
        timeout: int = 30
 
    # Another base class with different fields
@@ -212,11 +212,11 @@ The ``inherit_as_none`` parameter enables proper dual-axis inheritance when usin
    # Use inherit_as_none for multiple inheritance
    @global_pipeline_config(inherit_as_none=True)  # Default behavior
    @dataclass
-   class StreamingConfig(StepWellFilterConfig, StreamingDefaults):
+   class StreamingConfig(StepPartitionFilterConfig, StreamingDefaults):
        """Config using multiple inheritance.
 
        With inherit_as_none=True, all inherited fields
-       (persistent, well_filter, timeout, host, port, transport_mode)
+       (persistent, partition_filter, timeout, host, port, transport_mode)
        are automatically set to None for proper lazy resolution.
        """
        stream_type: str = "napari"
@@ -227,7 +227,7 @@ The ``inherit_as_none`` parameter enables proper dual-axis inheritance when usin
    print(f"stream_type: {config.stream_type}")        # "napari" (explicit)
    print(f"buffer_size: {config.buffer_size}")        # 1024 (explicit)
    print(f"persistent: {config.persistent}")          # None (inherited, set to None)
-   print(f"well_filter: {config.well_filter}")        # None (was already None)
+   print(f"partition_filter: {config.partition_filter}")        # None (was already None)
    print(f"timeout: {config.timeout}")                # None (inherited, set to None)
    print(f"host: {config.host}")                      # None (inherited, set to None)
    print(f"port: {config.port}")                      # None (inherited, set to None)
@@ -242,9 +242,9 @@ This enables polymorphic access to inherited fields without type-specific attrib
    from objectstate import config_context
 
    # Create a base config with values
-   base_config = StepWellFilterConfig(
+   base_config = StepPartitionFilterConfig(
        persistent=False,
-       well_filter="A01",
+       partition_filter="A01",
        timeout=60
    )
 
@@ -261,7 +261,7 @@ This enables polymorphic access to inherited fields without type-specific attrib
            # - stream_type from streaming_config ("custom")
            # - buffer_size from streaming_config (2048)
            # - persistent from base_config (False)
-           # - well_filter from base_config ("A01")
+           # - partition_filter from base_config ("A01")
            # - timeout from base_config (60)
            # - host, port, transport_mode from StreamingDefaults
            pass
@@ -275,7 +275,7 @@ You can disable this behavior if you want inherited fields to keep their default
 
    @global_pipeline_config(inherit_as_none=False)
    @dataclass
-   class ConcreteStreamingConfig(StepWellFilterConfig, StreamingDefaults):
+   class ConcreteStreamingConfig(StepPartitionFilterConfig, StreamingDefaults):
        """Config with concrete inherited defaults.
 
        Inherited fields keep their default values from parent classes.
@@ -283,8 +283,8 @@ You can disable this behavior if you want inherited fields to keep their default
        stream_type: str = "napari"
 
    config = ConcreteStreamingConfig()
-   print(f"persistent: {config.persistent}")          # True (from StepWellFilterConfig)
-   print(f"timeout: {config.timeout}")                # 30 (from StepWellFilterConfig)
+   print(f"persistent: {config.persistent}")          # True (from StepPartitionFilterConfig)
+   print(f"timeout: {config.timeout}")                # 30 (from StepPartitionFilterConfig)
    print(f"host: {config.host}")                      # "localhost" (from StreamingDefaults)
    print(f"port: {config.port}")                      # 5000 (from StreamingDefaults)
 

{objectstate-2.0.0 → objectstate-2.1.1}/docs/provenance.rst

@@ -69,13 +69,13 @@ Get the source scope_id and type for an inherited field value:
     state = ObjectStateRegistry.get_by_scope("plate_123::step_0")
 
     # Get provenance for a field
-    provenance = state.get_provenance("well_filter")
+    provenance = state.get_provenance("partition_filter")
     if provenance:
         source_scope, source_type = provenance
-        print(f"well_filter comes from scope: {source_scope}")
-        print(f"well_filter comes from type: {source_type.__name__}")
+        print(f"partition_filter comes from scope: {source_scope}")
+        print(f"partition_filter comes from type: {source_type.__name__}")
     else:
-        print("well_filter is explicitly set on this object")
+        print("partition_filter is explicitly set on this object")
 
 **Returns:**
 * ``Tuple[str, type]`` if the value is inherited
@@ -95,7 +95,7 @@ Resolve a field value AND find its provenance source in ONE walk:
     # Resolve value and get provenance simultaneously
     value, source_scope, source_type = resolve_with_provenance(
         container_type=PathPlanningConfig,
-        field_name="well_filter"
+        field_name="partition_filter"
     )
 
     print(f"Value: {value}")
@@ -105,7 +105,7 @@ Resolve a field value AND find its provenance source in ONE walk:
 **Parameters:**
 
 * ``container_type``: The type containing the field (e.g., ``LazyPathPlanningConfig``)
-* ``field_name``: Name of the field to find provenance for (e.g., ``"well_filter"``)
+* ``field_name``: Name of the field to find provenance for (e.g., ``"partition_filter"``)
 
 **Returns:**
 
@@ -126,7 +126,7 @@ Convenience wrapper that returns only the scope and type (not the value):
 
     source_scope, source_type = get_field_provenance(
         container_type=PathPlanningConfig,
-        field_name="well_filter"
+        field_name="partition_filter"
     )
 
     print(f"Field comes from: {source_scope} ({source_type.__name__})")
@@ -165,7 +165,7 @@ Use provenance to understand where a value comes from:
     state = ObjectStateRegistry.get_by_scope("plate_123::step_0")
 
     # Check where various fields come from
-    for field_name in ["well_filter", "output_dir", "num_workers"]:
+    for field_name in ["partition_filter", "output_dir", "num_workers"]:
         provenance = state.get_provenance(field_name)
         if provenance:
             source_scope, source_type = provenance
@@ -177,7 +177,7 @@ Example output:
 
 .. code-block:: text
 
-    well_filter: inherited from  (GlobalPipelineConfig)
+    partition_filter: inherited from  (GlobalPipelineConfig)
     output_dir: inherited from plate_123 (PlateConfig)
     num_workers: explicitly set on this object
 
@@ -209,7 +209,7 @@ Trace the full inheritance chain for a field:
             print("  → Value is a class default (no override)")
 
     # Use it
-    trace_field_origin(PathPlanningConfig, "well_filter")
+    trace_field_origin(PathPlanningConfig, "partition_filter")
     trace_field_origin(PathPlanningConfig, "output_dir_suffix")
 
 UI Integration
@@ -242,8 +242,8 @@ Provenance information can be displayed in UI elements to help users understand
         }
 
     # Display in UI
-    info = get_field_display_info("well_filter")
-    print(f"well_filter: {info['value']} [{info['origin']}]")
+    info = get_field_display_info("partition_filter")
+    print(f"partition_filter: {info['value']} [{info['origin']}]")
 
 Provenance in Snapshots
 -------------------------

{objectstate-2.0.0 → objectstate-2.1.1}/pyproject.toml

@@ -25,6 +25,7 @@ keywords = ["configuration", "dataclass", "lazy", "inheritance", "contextvars",
 
 dependencies = [
     "dill>=0.4.0",
+    "pycodify>=0.2.0,<0.3",
     "python-introspect>=0.2.0,<0.3",
 ]
 

{objectstate-2.0.0 → objectstate-2.1.1}/src/objectstate/__init__.py

@@ -212,7 +212,7 @@ __all__ = [
     'ObjectStateEditSession',
 ]
 
-__version__ = "2.0.0"
+__version__ = "2.1.1"
 __author__ = 'OpenHCS Team'
 __description__ = 'Generic configuration framework for lazy dataclass resolution'
 

objectstate-2.1.1/src/objectstate/codegen.py

@@ -0,0 +1,137 @@
+"""Python source for lazily resolved dataclasses, through pycodify.
+
+Importing this module registers two formatters. Both write raw field values,
+never resolved ones: a ``None`` field inherits from context and stays ``None``
+in the source.
+
+- :class:`LazyResolutionFormatter` (any :class:`LazyResolutionDataclass`):
+  clean mode writes the fields whose raw value differs from the field default.
+- :class:`LazyDataclassFormatter` (factory-made :class:`LazyDataclass`): clean
+  mode writes a field when it was passed to the constructor or holds a concrete
+  value; an inherited ``None`` is omitted, and so is a nested lazy dataclass
+  that carries nothing.
+
+Full mode writes every field.
+"""
+
+from __future__ import annotations
+
+from dataclasses import MISSING, Field, fields, is_dataclass
+
+from pycodify import (
+    FormatContext,
+    SourceFormatter,
+    SourceFragment,
+    imported_name,
+    to_source,
+)
+
+from objectstate.field_access import DataclassFieldAccess
+from objectstate.lazy_factory import LazyDataclass, LazyResolutionDataclass
+
+
+def _set_field_names(value: LazyDataclass) -> frozenset[str]:
+    return frozenset(object.__getattribute__(value, "_explicitly_set_fields"))
+
+
+def lazy_dataclass_carries_values(value: LazyDataclass) -> bool:
+    """Whether a lazy dataclass has a constructor-set field or a concrete value."""
+
+    return bool(_set_field_names(value)) or any(
+        DataclassFieldAccess.raw_value(value, field.name) is not None
+        for field in fields(value)
+    )
+
+
+def _is_instance_of_dataclass(value: object) -> bool:
+    return is_dataclass(value) and not isinstance(value, type)
+
+
+def raw_values_equal(left: object, right: object) -> bool:
+    """Whether two values are equal, comparing dataclasses by raw field values."""
+
+    if _is_instance_of_dataclass(left) and _is_instance_of_dataclass(right):
+        if type(left) is not type(right):
+            return False
+        return all(
+            raw_values_equal(
+                DataclassFieldAccess.raw_value(left, field.name),
+                DataclassFieldAccess.raw_value(right, field.name),
+            )
+            for field in fields(left)
+            if field.init
+        )
+    return left == right
+
+
+def field_needs_source(current: object, default: object, context: FormatContext) -> bool:
+    """Whether an owner's field holding ``current`` must be written.
+
+    For owners (such as a step) that format their own constructor fields and
+    hold lazy dataclasses among them. Full mode writes every field; clean mode
+    writes a lazy dataclass that carries values different from the default,
+    and any other value that differs from the default.
+    """
+
+    if not context.clean_mode:
+        return True
+    if isinstance(current, LazyDataclass):
+        if not lazy_dataclass_carries_values(current):
+            return False
+        return not raw_values_equal(current, default)
+    return current != default
+
+
+def _field_default(field: Field) -> object:
+    if field.default is not MISSING:
+        return field.default
+    if field.default_factory is not MISSING:
+        return field.default_factory()
+    return MISSING
+
+
+class LazyResolutionFormatter(SourceFormatter):
+    priority = 36
+    formats: type = LazyResolutionDataclass
+
+    def can_format(self, value: object) -> bool:
+        return isinstance(value, self.formats)
+
+    def clean_field_needs_source(self, value: object, field: Field, current: object) -> bool:
+        return not raw_values_equal(current, _field_default(field))
+
+    def format(self, value: object, context: FormatContext) -> SourceFragment:
+        lazy_type = type(value)
+        class_ref = imported_name(lazy_type.__module__, lazy_type.__qualname__, context)
+        imports = set(class_ref.imports)
+        field_ctx = context.indented()
+        lines = []
+        for field in fields(value):
+            if not field.init:
+                continue
+            current = DataclassFieldAccess.raw_value(value, field.name)
+            if context.clean_mode and not self.clean_field_needs_source(value, field, current):
+                continue
+            fragment = to_source(current, field_ctx)
+            imports |= fragment.imports
+            lines.append(f"{field.name}={fragment.code}")
+
+        if not lines:
+            return SourceFragment(f"{class_ref.code}()", frozenset(imports))
+        inner = f",\n{field_ctx.indent_str}".join(lines)
+        code = f"{class_ref.code}(\n{field_ctx.indent_str}{inner}\n{context.indent_str})"
+        return SourceFragment(code, frozenset(imports))
+
+
+class LazyDataclassFormatter(LazyResolutionFormatter):
+    priority = 37
+    formats = LazyDataclass
+
+    def clean_field_needs_source(self, value: object, field: Field, current: object) -> bool:
+        if current is None:
+            return False
+        if field.name in _set_field_names(value):
+            return True
+        if isinstance(current, LazyDataclass):
+            return lazy_dataclass_carries_values(current)
+        return True

{objectstate-2.0.0 → objectstate-2.1.1}/src/objectstate/context_manager.py

@@ -187,8 +187,9 @@ def config_context(obj, mask_with_none: bool = False, use_live_global: bool = Tr
                                 # to_base_config() passes None values to base class constructor,
                                 # but frozen dataclasses with non-Optional defaults substitute the
                                 # default value for None. This breaks cross-hierarchy inheritance.
-                                # Example: LazyWellFilterConfig(well_filter_mode=None) becomes
-                                # WellFilterConfig(well_filter_mode=INCLUDE) instead of keeping None.
+                                # Example: LazyPartitionFilterConfig(partition_filter_mode=None)
+                                # becomes PartitionFilterConfig(partition_filter_mode=INCLUDE)
+                                # instead of keeping None.
                                 #
                                 # Instead, pass lazy dataclass directly to _merge_nested_dataclass,
                                 # which uses object.__getattribute__ to get raw values and correctly
@@ -730,12 +731,12 @@ def _find_live_values_for_type(target_type: type, live_context: dict) -> dict |
     Find live values for a target type in live_context.
 
     Handles type normalization (lazy vs base types) AND inheritance.
-    For sibling inheritance, a StepWellFilterConfig's values should be
-    usable when resolving WellFilterConfig's placeholders.
+    For sibling inheritance, a StepPartitionFilterConfig's values should be
+    usable when resolving PartitionFilterConfig's placeholders.
 
     IMPORTANT: Prefers subclass matches over exact matches.
-    This ensures StepWellFilterConfig values (with concrete value) are used
-    for WellFilterConfig resolution, not WellFilterConfig values (with None).
+    This ensures StepPartitionFilterConfig values (with concrete value) are used
+    for PartitionFilterConfig resolution, not PartitionFilterConfig values (with None).
 
     Args:
         target_type: The type to find values for
@@ -755,7 +756,7 @@ def _find_live_values_for_type(target_type: type, live_context: dict) -> dict |
             return config_values
 
     # First pass: look for subclass match (more specific wins) after normalization
-    # e.g., StepWellFilterConfig values for WellFilterConfig resolution
+    # e.g., StepPartitionFilterConfig values for PartitionFilterConfig resolution
     for config_type, config_values in live_context.items():
         config_base = _normalize_type(config_type)
         try:
@@ -899,12 +900,6 @@ def get_base_global_config(use_live: bool = True):
         # Get the appropriate global config (live or saved)
         current_global = get_current_global_config(base_config_type, use_live=use_live)
         if current_global is not None:
-            # DEBUG: Log well_filter value
-            try:
-                wf_value = object.__getattribute__(current_global.well_filter_config, 'well_filter')
-                logger.debug(f"🔍 get_base_global_config: use_live={use_live}, well_filter={wf_value}")
-            except:
-                pass
             return current_global
 
         # Fallback to default if none was set

{objectstate-2.0.0 → objectstate-2.1.1}/src/objectstate/docs/configuration_framework.rst

@@ -63,7 +63,7 @@ Nested configurations use the ``@global_config`` decorator to inject fields into
 
    @global_config
    @dataclass(frozen=True)
-   class PathPlanningConfig(WellFilterConfig):
+   class PathPlanningConfig(PartitionFilterConfig):
        output_dir_suffix: str = ""
        sub_dir: str = ""