CompilerOptions is not auto-discovered

[JannisNe]

The new unit discovery works only for units inheriting from AmpelABC:

Ampel-core/ampel/config/builder/DistConfigBuilder.py

Line 186 in 0bc97bb

required_parents: Sequence[str] = ['AmpelABC'],

Should auxiliary units that only inherit from AmpelBaseModel not be discoverable as well? For example, I have a unit inheriting from CompilerOptions which is an AuxAlisableModel: https://github.com/JannisNe/timewise/blob/main/ampel/timewise/ingest/TiCompilerOptions.py

[vbrinnel]

Hi,

yes, the setting required_parents = ['AmpelABC'] is intentional. The idea is that aux units must adhere to a contract; otherwise, you lose the ability to config‑swap them, and they no longer qualify as units in Ampel framework terminology.

In this case, we are talking about a pure container: a validated model without abstract methods, essentially a safe dataclass. Such classes do not perform any actions and therefore are not (no longer) considered units.

The question now is how to properly handle CompilerOptions, ZiCompilerOptions (Zi stands for ZTF‑Ipac by the way), and TiCompilerOptions.

My impression is that it would make sense to define these as config aliases and update any code that relies on them accordingly.

If we anticipate needing more advanced logic in the future (such as dynamic configuration or reusable superclass functionality), we can redefine CompilerOptions as shown below, and the related units will be auto‑discovered:

class CompilerOptions(AmpelABC, AuxAliasableModel):
    """
    Options will be merged with those provided by IngestionHandlers, which take precedence.
    These options, for example, setting default tags for specific documents or defining a
    custom `AbsIdMapper` subclass for the stock compiler.
    """

    t0: dict[str, Any] | None = None
    t1: dict[str, Any] | None = None
    state_t2: dict[str, Any] | None = None
    point_t2: dict[str, Any] | None = None
    stock_t2: dict[str, Any] | None = None
    stock: dict[str, Any] | None = None

    @abstractmethod
    def t0_options(self) -> dict[str, Any]:
        return self.t0 or {}

    @abstractmethod
    def t1_options(self) -> dict[str, Any]:
        return self.t1 or {}

    @abstractmethod
    def state_t2_options(self) -> dict[str, Any]:
        return self.state_t2 or {}

    @abstractmethod
    def point_t2_options(self) -> dict[str, Any]:
        return self.point_t2 or {}

    @abstractmethod
    def stock_t2_options(self) -> dict[str, Any]:
        return self.stock_t2 or {}

    @abstractmethod
    def stock_options(self) -> dict[str, Any]:
        return self.stock or {}

[JannisNe]

Thanks! My solution for now is to just also inherit from AmpelABC in the aux units.

[vbrinnel]

Reopening, as the fix doesn’t fully address the underlying issue and further tracking is desired