immplement Element behaviour and some tests

pyproject.toml

@@ -35,8 +35,8 @@ classifiers = [
 dependencies = [
     'importlib-metadata; python_version<"3.9"',
     'packaging',
-    'pydantic',
-    'runtype'
+    'frozendict',
+    'typeguard'
 ]
 dynamic = ["version"]
 

src/dabmodel/LAMFields/Constraint.py

@@ -0,0 +1,17 @@
+from typing import Generic, TypeVar
+
+T_Field = TypeVar("T_Field")
+
+
+class Constraint(Generic[T_Field]):
+    """Constraint class
+    Base class for Field's constraints
+    """
+
+    _bound_type: type
+
+    def __init__(self): ...
+
+    def check(self, value: T_Field) -> bool:
+        """Check if a Constraint is completed"""
+        return True

src/dabmodel/LAMFields/FrozenLAMField.py

@@ -0,0 +1,41 @@
+from typing import Generic, TypeVar, Any
+
+from .LAMField import LAMField
+from .Constraint import Constraint
+from ..tools import LAMdeepfreeze
+
+T_Field = TypeVar("T_Field")
+
+
+class FrozenLAMField(Generic[T_Field]):
+    """FrozenLAMField class
+    a read-only proxy of a Field
+    """
+
+    def __init__(self, inner_field: LAMField[T_Field]):
+        self._inner_field = inner_field
+
+    @property
+    def doc(self) -> str:
+        """Returns Field's documentation (frozen)"""
+        return LAMdeepfreeze(self._inner_field.doc)
+
+    @property
+    def constraints(self) -> tuple[Constraint]:
+        """Returns Field's constraint (frozen)"""
+        return LAMdeepfreeze(self._inner_field.constraints)
+
+    @property
+    def default_value(self) -> Any:
+        """Returns Field's default value (frozen)"""
+        return self._inner_field.default_value
+
+    @property
+    def value(self) -> Any:
+        """Returns Field's value (frosen)"""
+        return self._inner_field.value
+
+    @property
+    def annotations(self) -> Any:
+        """Returns Field's annotation (frozen)"""
+        return LAMdeepfreeze(self._inner_field.annotations)

src/dabmodel/LAMFields/LAMCompatible.py

@@ -0,0 +1,38 @@
+from typing import Generic, TypeVar, Self, Hashable, Any
+from abc import ABC, abstractmethod
+from ..tools import JSONType
+
+TV_LAMCompatbile = TypeVar("TV_LABCompatbile", bound="LABCompatible")
+
+
+class LAMCompatible(Generic[TV_LAMCompatbile], ABC):
+    """Any type that can safely live inside a LABField."""
+
+    @classmethod
+    def lam_validate_annotation(cls, annotation: Any) -> None:
+        """
+        Validate the type annotation (e.g., SpecialList[int]).
+        Raise if it's not compatible.
+        """
+        return  # default: do nothing (simple types don’t need it)
+
+    @abstractmethod
+    def lam_validate(self) -> None:
+        """Raise if the value is invalid for this type."""
+        ...
+
+    @abstractmethod
+    def lam_freeze(self) -> Hashable:
+        """Return an immutable/hashable representation of this value."""
+        ...
+
+    @abstractmethod
+    def lam_to_plain(self) -> JSONType:
+        """Return a plain serializable form (str, dict, etc.)."""
+        ...
+
+    @classmethod
+    @abstractmethod
+    def lam_from_plain(cls, plain: JSONType) -> Self:
+        """Return an Object from a plain serializable form (str, dict, etc.)."""
+        ...

src/dabmodel/LAMFields/LAMField.py

@@ -0,0 +1,62 @@
+from typing import Generic, TypeVar, Optional, Any
+
+from .LAMFieldInfo import LAMFieldInfo
+from .Constraint import Constraint
+from ..tools import LAMdeepfreeze
+
+TV_LABField = TypeVar("TV_LABField")
+
+
+class LAMField(Generic[TV_LABField]):
+    """This class describe a Field in Schema"""
+
+    def __init__(self, name: str, v: Optional[TV_LABField], a: Any, i: LAMFieldInfo):
+        self._name: str = name
+        self._source: Optional[type] = None
+        self._default_value: Optional[TV_LABField] = v
+        self._value: Optional[TV_LABField] = v
+        self._annotations: Any = a
+        self._info: LAMFieldInfo = i
+        self._constraints: list[Constraint[Any]] = i.constraints
+
+    def add_source(self, s: type) -> None:
+        """Adds source Appliance to the Field"""
+        self._source = s
+
+    @property
+    def doc(self) -> str:
+        """Returns Field's documentation"""
+        return self._info.doc
+
+    def add_constraint(self, c: Constraint) -> None:
+        """Adds constraint to the Field"""
+        self._constraints.append(c)
+
+    @property
+    def constraints(self) -> list[Constraint]:
+        """Returns Field's constraint"""
+        return self._info.constraints
+
+    @property
+    def default_value(self) -> Any:
+        """Returns Field's default value (frozen)"""
+        return LAMdeepfreeze(self._default_value)
+
+    def update_value(self, v: Optional[TV_LABField] = None) -> None:
+        """Updates Field's value"""
+        self._value = v
+
+    @property
+    def value(self) -> Any:
+        """Returns Field's value (frozen)"""
+        return LAMdeepfreeze(self._value)
+
+    @property
+    def raw_value(self) -> Optional[TV_LABField]:
+        """Returns Field's value"""
+        return self._value
+
+    @property
+    def annotations(self) -> Any:
+        """Returns Field's annotation"""
+        return self._annotations

src/dabmodel/LAMFields/LAMFieldInfo.py

@@ -0,0 +1,26 @@
+from typing import Optional, Any
+from .Constraint import Constraint
+
+
+class LAMFieldInfo:
+    """This Class allows to describe a Field in Appliance class"""
+
+    def __init__(
+        self, *, doc: str = "", constraints: Optional[list[Constraint]] = None
+    ):
+        self._doc: str = doc
+        self._constraints: list[Constraint]
+        if constraints is None:
+            self._constraints = []
+        else:
+            self._constraints = constraints
+
+    @property
+    def doc(self) -> str:
+        """Returns Field's documentation"""
+        return self._doc
+
+    @property
+    def constraints(self) -> list[Constraint[Any]]:
+        """Returns Field's constraints"""
+        return self._constraints

src/dabmodel/__init__.py

@@ -11,10 +11,18 @@ Main module __init__ file.
 """
 
 from .__metadata__ import __version__, __Summuary__, __Name__
-from .model import (
-    DABFieldInfo,
-    BaseAppliance,
-    BaseFeature,
+
+
+from .LAMFields.LAMField import LAMField
+from .LAMFields.LAMFieldInfo import LAMFieldInfo
+from .LAMFields.FrozenLAMField import FrozenLAMField
+from .LAMFields.LAMCompatible import LAMCompatible
+from .appliance import Appliance
+from .feature import Feature
+from .element import Element
+
+
+from .exception import (
     DABModelException,
     MultipleInheritanceForbidden,
     BrokenInheritance,
@@ -25,4 +33,11 @@ from .model import (
     InvalidFieldValue,
     InvalidFieldAnnotation,
     IncompletelyAnnotatedField,
+    ImportForbidden,
+    FunctionForbidden,
+    InvalidFeatureInheritance,
+    FeatureNotBound,
+    UnsupportedFieldType,
 )
+
+__all__ = [name for name in globals() if not name.startswith("_")]

src/dabmodel/__metadata__.py

@@ -15,20 +15,26 @@ import warnings
 
 try:  # pragma: no cover
     __version__ = version("dabmodel")
-except PackageNotFoundError: # pragma: no cover
-    warnings.warn("can not read __version__, assuming local test context, setting it to ?.?.?")
+except PackageNotFoundError:  # pragma: no cover
+    warnings.warn(
+        "can not read __version__, assuming local test context, setting it to ?.?.?"
+    )
     __version__ = "?.?.?"
 
 try:  # pragma: no cover
     dist = distribution("dabmodel")
     __Summuary__ = dist.metadata["Summary"]
 except PackageNotFoundError:  # pragma: no cover
-    warnings.warn('can not read dist.metadata["Summary"], assuming local test context, setting it to <dabmodel description>')
+    warnings.warn(
+        'can not read dist.metadata["Summary"], assuming local test context, setting it to <dabmodel description>'
+    )
     __Summuary__ = "dabmodel description"
 
 try:  # pragma: no cover
     dist = distribution("dabmodel")
     __Name__ = dist.metadata["Name"]
 except PackageNotFoundError:  # pragma: no cover
-    warnings.warn('can not read dist.metadata["Name"], assuming local test context, setting it to <dabmodel>')
+    warnings.warn(
+        'can not read dist.metadata["Name"], assuming local test context, setting it to <dabmodel>'
+    )
     __Name__ = "dabmodel"

src/dabmodel/appliance.py

@@ -0,0 +1,9 @@
+from .element import Element
+from .meta.appliance import _MetaAppliance
+
+
+class Appliance(metaclass=_MetaAppliance):
+    """BaseFeature class
+    Base class for Appliance.
+    An appliance is a server configuration / image that is built using appliance's code and Fields.
+    """

src/dabmodel/element.py

@@ -0,0 +1,7 @@
+from .meta.element import _MetaElement, IElement
+
+
+class Element(IElement, metaclass=_MetaElement):
+    """Element class
+    Base class to apply metaclass and set common Fields.
+    """

src/dabmodel/exception.py

@@ -0,0 +1,109 @@
+class DABModelException(Exception):
+    """DABModelException Exception class
+    Base Exception for DABModelException class
+    """
+
+
+class FunctionForbidden(DABModelException): ...
+
+
+class ExternalCodeForbidden(FunctionForbidden): ...
+
+
+class ClosureForbidden(FunctionForbidden): ...
+
+
+class ReservedFieldName(Exception):
+    """DABModelException Exception class
+    Base Exception for DABModelException class
+    """
+
+
+class MultipleInheritanceForbidden(DABModelException):
+    """MultipleInheritanceForbidden Exception class
+    Multiple inheritance is forbidden when using dabmodel
+    """
+
+
+class BrokenInheritance(DABModelException):
+    """BrokenInheritance Exception class
+    inheritance chain is broken
+    """
+
+
+class ReadOnlyField(DABModelException):
+    """ReadOnlyField Exception class
+    The used Field is ReadOnly
+    """
+
+
+class NewFieldForbidden(DABModelException):
+    """NewFieldForbidden Exception class
+    Field creation is forbidden
+    """
+
+
+class InvalidFieldAnnotation(DABModelException):
+    """InvalidFieldAnnotation Exception class
+    The field annotation is invalid
+    """
+
+
+class InvalidInitializerType(DABModelException):
+    """InvalidInitializerType Exception class
+    The initializer is not a valid type
+    """
+
+
+class NotAnnotatedField(InvalidFieldAnnotation):
+    """NotAnnotatedField Exception class
+    The Field is not Annotated
+    """
+
+
+class IncompletelyAnnotatedField(InvalidFieldAnnotation):
+    """IncompletelyAnnotatedField Exception class
+    The field annotation is incomplete
+    """
+
+
+class UnsupportedFieldType(InvalidFieldAnnotation):
+    """UnsupportedFieldType Exception class
+    The field type is unsupported
+    """
+
+
+class ReadOnlyFieldAnnotation(DABModelException):
+    """ReadOnlyFieldAnnotation Exception class
+    Field annotation connot be modified
+    """
+
+
+class InvalidFieldValue(DABModelException):
+    """InvalidFieldValue Exception class
+    The Field value is invalid
+    """
+
+
+class NonExistingField(DABModelException):
+    """NonExistingField Exception class
+    The given Field is non existing
+    """
+
+
+class ImportForbidden(DABModelException):
+    """ImportForbidden Exception class
+    Imports are forbidden
+    """
+
+
+class InvalidFeatureInheritance(DABModelException):
+    """InvalidFeatureInheritance Exception class
+    Features of same name in child appliance need to be from same type
+    """
+
+
+class FeatureNotBound(DABModelException):
+    """FeatureNotBound Exception class
+    a Feature must be bound to the appliance (or parent)
+    """

src/dabmodel/feature.py

@@ -0,0 +1,12 @@
+from .element import Element
+from .meta.feature import _MetaFeature
+
+
+class Feature(metaclass=_MetaFeature):
+    """Feature class
+    Base class for Appliance's Features.
+    Features are optional traits of an appliance.
+    """
+
+    _BoundAppliance: "Optional[Type[BaseAppliance]]" = None
+    Enabled: bool = False

src/dabmodel/meta/appliance.py

@@ -0,0 +1,213 @@
+from typing import Any, Type
+from copy import copy
+
+from typeguard import check_type, CollectionCheckStrategy, TypeCheckError
+
+from ..tools import LAMdeepfreeze
+from ..LAMFields.LAMField import LAMField
+from ..LAMFields.FrozenLAMField import FrozenLAMField
+from .element import _MetaElement
+from ..feature import Feature
+from ..exception import (
+    InvalidFieldValue,
+    InvalidFeatureInheritance,
+    FeatureNotBound,
+)
+
+
+class _MetaAppliance(_MetaElement):
+    """_MetaAppliance class
+    Appliance specific metaclass code
+    """
+
+    @classmethod
+    def check_class(
+        mcs: type["meta"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],  # pylint: disable=unused-argument
+        extensions: dict[str, Any],
+    ) -> None:
+        """
+        Appliance-specific pre-check: ensure the `features` slot exists in schema.
+
+        Copies the parent's `features` mapping when inheriting to keep it per-class.
+        """
+        super().check_class(name, bases, namespace, extensions)  # type: ignore[misc]
+        if "features" not in namespace["__LAMSchema__"]:
+            namespace["__LAMSchema__"]["features"] = {}
+        else:
+            namespace["__LAMSchema__"]["features"] = copy(
+                namespace["__LAMSchema__"]["features"]
+            )
+
+    @classmethod
+    def process_class_fields(
+        mcs: type["meta"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        extensions: dict[str, Any],
+    ):
+        """
+        Like meta.process_class_fields but also stages Feature declarations.
+
+        Initializes:
+          extensions["new_features"], extensions["modified_features"]
+        then defers to the base scanner for regular fields.
+        """
+        extensions["new_features"] = {}
+        extensions["modified_features"] = {}
+        super().process_class_fields(name, bases, namespace, extensions)  # type: ignore[misc]
+
+    @classmethod
+    def process_new_field(
+        mcs: type["meta"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        _fname: str,
+        _fvalue: Any,
+        extensions: dict[str, Any],
+    ):  # pylint: disable=unused-argument
+        """
+        Intercept Feature declarations.
+
+        - If `_fname` already exists in parent's `features`, enforce same type;
+          stage into `modified_features`.
+        - Else, if `_fvalue` is a Feature *class*, stage into `new_features`.
+        - Otherwise, it is a regular field: delegate to meta.process_new_field.
+        """
+        if _fname in namespace["__LAMSchema__"]["features"].keys():
+            if not issubclass(_fvalue, namespace["__LAMSchema__"]["features"][_fname]):
+                raise InvalidFeatureInheritance(
+                    f"Feature {_fname} is not an instance of {bases[0]}.{_fname}"
+                )
+            extensions["modified_features"][_fname] = _fvalue
+        elif isinstance(_fvalue, type) and issubclass(_fvalue, Feature):
+            extensions["new_features"][_fname] = _fvalue
+        else:
+            super().process_new_field(name, bases, namespace, _fname, _fvalue, extensions)  # type: ignore[misc]
+
+    @classmethod
+    def commit_fields(
+        mcs: type["meta"],
+        cls,
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],  # pylint: disable=unused-argument
+        extensions: dict[str, Any],
+    ):
+        """
+        Commit regular fields (via meta) and then bind staged Feature classes.
+
+        For each new/modified feature:
+          - bind it to `cls` (sets the feature's `_BoundAppliance`),
+          - register it under `cls.__LAMSchema__["features"]`.
+        """
+        super().commit_fields(cls, name, bases, namespace, extensions)  # type: ignore[misc]
+
+        for _ftname, _ftvalue in extensions["modified_features"].items():
+            _ftvalue._BoundAppliance = cls  # pylint: disable=protected-access
+            cls.__LAMSchema__["features"][_ftname] = _ftvalue
+        for _ftname, _ftvalue in extensions["new_features"].items():
+            _ftvalue._BoundAppliance = cls  # pylint: disable=protected-access
+            cls.__LAMSchema__["features"][_ftname] = _ftvalue
+
+    def finalize_instance(cls: Type, obj, extensions: dict[str, Any]):
+        """
+        Instantiate and attach all features declared (or overridden) in the instance schema.
+        Handles:
+          - Declared features (plain class)
+          - Subclass replacements
+          - Dict overrides (class + patch dict)
+        """
+        for fname, fdef in obj.__LAMSchema__.get("features", {}).items():
+            # Case 1: plain class or subclass
+            if isinstance(fdef, type) and issubclass(fdef, Feature):
+                inst = fdef()
+                object.__setattr__(obj, fname, inst)
+
+            # Case 2: (class, dict) → dict overrides
+            elif isinstance(fdef, tuple) and len(fdef) == 2:
+                feat_cls, overrides = fdef
+                inst = feat_cls()
+                for field_name, new_val in overrides.items():
+                    if field_name not in feat_cls.__LAMSchema__:
+                        raise InvalidFieldValue(
+                            f"Feature '{fname}' has no field '{field_name}'"
+                        )
+                    field = feat_cls.__LAMSchema__[field_name]
+                    try:
+                        check_type(
+                            new_val,
+                            field.annotations,
+                            collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+                        )
+                    except TypeCheckError as exp:
+                        raise InvalidFieldValue(
+                            f"Invalid value for {fname}.{field_name}: "
+                            f"expected {field.annotations}, got {new_val!r}"
+                        ) from exp
+                    object.__setattr__(inst, field_name, LAMdeepfreeze(new_val))
+                    inst.__LAMSchema__[field_name] = FrozenLAMField(
+                        LAMField(field_name, new_val, field.annotations, field._info)
+                    )
+                object.__setattr__(obj, fname, inst)
+
+            else:
+                raise InvalidFieldValue(
+                    f"Invalid feature definition stored for '{fname}': {fdef!r}"
+                )
+
+    def apply_overrides(cls, obj, extensions, *args, **kwargs):
+        """
+        Support for runtime field and feature overrides.
+
+        Fields:
+          MyApp(name="foo")
+
+        Features:
+          MyApp(F1=MyF1)                # inheritance / replacement
+          MyApp(F1={"val": 42, ...})    # dict override of existing feature
+        """
+
+        # --- feature overrides ---
+        for k, v in list(kwargs.items()):
+            if k in cls.__LAMSchema__.get("features", {}):
+                base_feat_cls = cls.__LAMSchema__["features"][k]
+
+                # Case 1: subclass replacement (inheritance)
+                if isinstance(v, type) and issubclass(v, base_feat_cls):
+                    bound = getattr(v, "_BoundAppliance", None)
+                    if bound is None or not issubclass(cls, bound):
+                        raise FeatureNotBound(
+                            f"Feature {v.__name__} is not bound to {cls.__name__}"
+                        )
+                    # record subclass into instance schema
+                    obj.__LAMSchema__["features"][k] = v
+                    kwargs.pop(k)
+
+                # Case 2: dict override
+                elif isinstance(v, dict):
+                    # store (class, override_dict) for finalize_instance
+                    obj.__LAMSchema__["features"][k] = (base_feat_cls, v)
+                    kwargs.pop(k)
+
+                else:
+                    raise InvalidFieldValue(
+                        f"Feature override for '{k}' must be a Feature subclass or dict, got {type(v)}"
+                    )
+
+        # --- new features not declared at class level ---
+        for k, v in list(kwargs.items()):
+            if isinstance(v, type) and issubclass(v, Feature):
+                bound = getattr(v, "_BoundAppliance", None)
+                if bound is None or not issubclass(cls, bound):
+                    raise FeatureNotBound(
+                        f"Feature {v.__name__} is not bound to {cls.__name__}"
+                    )
+                obj.__LAMSchema__["features"][k] = v
+                kwargs.pop(k)
+
+        super().apply_overrides(obj, extensions, *args, **kwargs)

src/dabmodel/meta/element.py

@@ -0,0 +1,797 @@
+from typing import (
+    Optional,
+    TypeVar,
+    Union,
+    get_origin,
+    get_args,
+    List,
+    Dict,
+    Any,
+    Tuple,
+    Set,
+    Annotated,
+    FrozenSet,
+    Callable,
+    Type,
+)
+
+from types import UnionType, FunctionType, SimpleNamespace
+from copy import deepcopy, copy
+
+import math
+import inspect, ast, textwrap
+
+from typeguard import check_type, TypeCheckError, CollectionCheckStrategy
+
+from ..tools import LAMdeepfreeze
+from ..LAMFields.LAMField import LAMField
+from ..LAMFields.LAMFieldInfo import LAMFieldInfo
+from ..LAMFields.FrozenLAMField import FrozenLAMField
+
+
+from ..exception import (
+    MultipleInheritanceForbidden,
+    BrokenInheritance,
+    ReadOnlyField,
+    NewFieldForbidden,
+    NotAnnotatedField,
+    ReadOnlyFieldAnnotation,
+    InvalidFieldValue,
+    InvalidFieldAnnotation,
+    IncompletelyAnnotatedField,
+    ImportForbidden,
+    FunctionForbidden,
+    NonExistingField,
+    InvalidInitializerType,
+    UnsupportedFieldType,
+)
+
+ALLOWED_ANNOTATIONS: dict[str, Any] = {
+    "Union": Union,
+    "Optional": Optional,
+    "List": List,
+    "Dict": Dict,
+    "Tuple": Tuple,
+    "Set": Set,
+    "FrozenSet": FrozenSet,
+    "Annotated": Annotated,
+    # builtins:
+    "int": int,
+    "str": str,
+    "float": float,
+    "bool": bool,
+    "complex": complex,
+    "bytes": bytes,
+    "None": type(None),
+    "list": list,
+    "dict": dict,
+    "set": set,
+    "frozenset": frozenset,
+    "tuple": tuple,
+}
+ALLOWED_MODEL_FIELDS_TYPES: tuple[type[Any], ...] = (
+    str,
+    int,
+    float,
+    complex,
+    bool,
+    bytes,
+)
+
+
+ALLOWED_HELPERS_MATH = SimpleNamespace(
+    sqrt=math.sqrt,
+    floor=math.floor,
+    ceil=math.ceil,
+    trunc=math.trunc,
+    fabs=math.fabs,
+    copysign=math.copysign,
+    hypot=math.hypot,
+    exp=math.exp,
+    log=math.log,
+    log10=math.log10,
+    sin=math.sin,
+    cos=math.cos,
+    tan=math.tan,
+    atan2=math.atan2,
+    radians=math.radians,
+    degrees=math.degrees,
+)
+
+ALLOWED_HELPERS_DEFAULT: dict[str, object] = {
+    "math": ALLOWED_HELPERS_MATH,
+    "print": print,
+    # Numbers & reducers (pure, deterministic)
+    "abs": abs,
+    "round": round,
+    "min": min,
+    "max": max,
+    "sum": sum,
+    # Introspection-free basics
+    "len": len,
+    "sorted": sorted,
+    # Basic constructors (for copy-on-write patterns)
+    "tuple": tuple,
+    "list": list,
+    "dict": dict,
+    "set": set,
+    # Simple casts if they need to normalize types
+    "int": int,
+    "float": float,
+    "str": str,
+    "bool": bool,
+    "bytes": bytes,
+    "complex": complex,
+    # Easy iteration helpers (optional but handy)
+    "range": range,
+}
+
+
+class IElement:
+    pass
+
+
+def _check_initializer_safety(func) -> None:
+    """
+    Preliminary structural check for __initializer__.
+
+    Policy (minimal):
+      - Forbid 'import' / 'from ... import ...' inside the initializer body.
+      - Forbid nested function definitions (closures/helpers) in the body.
+      - Allow lambdas.
+      - No restrictions on calls here (keep it simple).
+      - Optionally forbid closures (free vars) for determinism.
+    """
+    try:
+        src = inspect.getsource(func)
+    except OSError as exc:
+        # If source isn't available (rare), fail closed (or skip if you prefer)
+        raise FunctionForbidden("Cannot inspect __initializer__ source") from exc
+
+    src = textwrap.dedent(src)
+    mod = ast.parse(src)
+
+    # Find the FunctionDef node that corresponds to this initializer
+    init_node = next(
+        (
+            n
+            for n in mod.body
+            if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and n.name == func.__name__
+        ),
+        None,
+    )
+    if init_node is None:
+        # Fallback: if not found, analyze nothing further to avoid false positives
+        return
+
+    for node in ast.walk(ast.Module(body=init_node.body, type_ignores=[])):
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            raise ImportForbidden("imports disabled in __initializer")
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            raise FunctionForbidden("Nested defs are forbidden in __initializer")
+        # if isinstance(node, ast.Lambda):
+        #    raise FunctionForbidden("Lambdas are forbidden in __initializer")
+
+    # Optional: forbid closures (keeps determinism; allows lambdas that don't capture)
+    if func.__code__.co_freevars:
+        # Inspect captured free vars
+        closure_vars = inspect.getclosurevars(func)
+        captured = {**closure_vars.globals, **closure_vars.nonlocals}
+        for name, val in captured.items():
+            if isinstance(val, type) and issubclass(val, IElement):
+                continue
+            if isinstance(val, (int, str, float, bool, type(None))):
+                continue
+            raise FunctionForbidden(
+                f"Closures are forbidden in __initializer__ (captured: {name}={val!r})"
+            )
+
+
+def _blocked_import(*args, **kwargs):
+    raise ImportForbidden("imports disabled in __initializer")
+
+
+def _resolve_annotation(ann):
+    if isinstance(ann, str):
+        # Safe eval against a **whitelist** only
+        return eval(  # pylint: disable=eval-used
+            ann, {"__builtins__": {}}, ALLOWED_ANNOTATIONS
+        )
+    return ann
+
+
+def _peel_annotated(t: Any) -> Any:
+    # If you ever allow Annotated[T, ...], peel to T
+    while True:
+        origin = get_origin(t)
+        if origin is None:
+            return t
+        name = (
+            getattr(origin, "__name__", "")
+            or getattr(origin, "__qualname__", "")
+            or str(origin)
+        )
+        if "Annotated" in name:
+            args = get_args(t)
+            t = args[0] if args else t
+        else:
+            return t
+
+
+def _check_annotation_definition(  # pylint: disable=too-complex,too-many-return-statements
+    _type,
+):
+
+    print(f"_type={_type}")
+    _type = _peel_annotated(_type)
+    _origin = get_origin(_type) or _type
+    _args = get_args(_type)
+
+    # handle Optional[] and Union[None,...]
+    if (_origin is Union or _origin is UnionType) and type(None) in _args:
+        return all(
+            _check_annotation_definition(_)
+            for _ in get_args(_type)
+            if _ is not type(None)
+        )
+
+    # handle other Union[...]
+    if _origin is Union or _origin is UnionType:
+        return all(_check_annotation_definition(_) for _ in _args)
+
+    # handle Dict[...]
+    if _origin is dict:
+        print("a")
+        if len(_args) != 2:
+            raise IncompletelyAnnotatedField(
+                f"Dict Annotation requires 2 inner definitions: {_type}"
+            )
+        if not _peel_annotated(_args[0]) in ALLOWED_MODEL_FIELDS_TYPES:
+            raise IncompletelyAnnotatedField(
+                f"Dict Key must be simple builtin: {_type}"
+            )
+        return _check_annotation_definition(_args[1])
+
+    # handle Tuple[]
+    if _origin is tuple:
+        if len(_args) == 0:
+            raise IncompletelyAnnotatedField(
+                f"Annotation requires inner definition: {_type}"
+            )
+        if len(_args) == 2 and _args[1] is Ellipsis:
+            return _check_annotation_definition(_args[0])
+        return all(_check_annotation_definition(_) for _ in _args)
+
+    # handle Set[],Tuple[],FrozenSet[],List[]
+    if _origin in [set, frozenset, tuple, list]:
+        if len(_args) == 0:
+            raise IncompletelyAnnotatedField(
+                f"Annotation requires inner definition: {_type}"
+            )
+        return all(_check_annotation_definition(_) for _ in _args)
+
+    if isinstance(_origin, type) and issubclass(_origin, IElement):
+        return
+
+    if _type in ALLOWED_MODEL_FIELDS_TYPES:
+        return
+    raise UnsupportedFieldType(_type)
+
+
+class ModelSpecView:
+    """ModelSpecView class
+    A class that will act as fake BaseElement proxy to allow setting values"""
+
+    __slots__ = ("_vals", "_types", "_touched", "_name", "_module")
+
+    def __init__(
+        self, values: dict[str, Any], types_map: dict[str, type], name: str, module: str
+    ):
+        self._name: str
+        self._vals: dict[str, Any]
+        self._types: dict[str, type]
+        self._touched: set
+        self._module: str
+        object.__setattr__(self, "_vals", dict(values))
+        object.__setattr__(self, "_types", types_map)
+        object.__setattr__(self, "_name", name)
+        object.__setattr__(self, "_module", module)
+
+    @property
+    def __name__(self) -> str:
+        """returns proxified class' name"""
+        return self._name
+
+    @property
+    def __module__(self) -> str:
+        """returns proxified module's name"""
+        return self._module
+
+    @__module__.setter
+    def __module__(self, value: str):
+        pass
+
+    def __getattr__(self, name: str) -> Any:
+        """internal proxy getattr"""
+        if name not in self._types:
+            raise AttributeError(f"Unknown field {name}")
+        return self._vals[name]
+
+    def __setattr__(self, name: str, value: Any):
+        """internal proxy setattr"""
+        if name not in self._types:
+            raise NonExistingField(f"Cannot set unknown field {name}")
+        T = self._types[name]
+
+        try:
+            check_type(
+                value,
+                T,
+                collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+            )
+        except TypeCheckError as exp:
+            raise InvalidFieldValue(
+                f"Field <{name}> value is not of expected type {T}."
+            ) from exp
+
+        self._vals[name] = value
+
+    def export(self) -> dict:
+        """exports all proxified values"""
+        return dict(self._vals)
+
+
+T_Meta = TypeVar("T_Meta", bound="_MetaElement")
+T_BE = TypeVar("T_BE", bound="BaseElement")
+
+
+class _MetaElement(type):
+    """metaclass to use to build BaseElement"""
+
+    modified_fields: Dict[str, Any] = {}
+    new_fields: Dict[str, LAMField[Any]] = {}
+    initializer: Optional[Callable[..., Any]] = None
+    __LAMSchema__: dict[str, Any] = {}
+
+    @classmethod
+    def check_class(
+        mcs: type["_MetaElement"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],  # pylint: disable=unused-argument
+        extensions: dict[str, Any],
+    ) -> None:
+        """
+        Early class-build hook.
+
+        Validates the inheritance shape, initializes an empty schema for root classes,
+        copies the parent schema for subclasses, and ensures all annotated fields
+        have a default (inserting `None` when missing).
+
+        This runs before the class object is created.
+        """
+        # print("__NEW__ Defining:", name, "with keys:", list(namespace))
+
+        if len(bases) > 1:
+            raise MultipleInheritanceForbidden(
+                "Multiple inheritance is not supported by dabmodel"
+            )
+        if len(bases) == 0:  # base class (Appliance,Feature)
+            namespace["__LAMSchema__"] = {}
+        elif (
+            len(bases) == 1 and bases[0] is IElement
+        ):  # special case for Element (hidden layer IElement)
+            namespace["__LAMSchema__"] = {}
+        else:  # standard inheritance
+            # check class tree origin
+            if "__LAMSchema__" not in dir(bases[0]):
+                raise BrokenInheritance(
+                    "__LAMSchema__ not found in base class, broken inheritance chain."
+                )
+            # copy inherited schema
+            namespace["__LAMSchema__"] = copy(bases[0].__LAMSchema__)
+
+        # force field without default value to be instantiated (with None)
+        if "__annotations__" in namespace:
+            for _funknown in [
+                _ for _ in namespace["__annotations__"] if _ not in namespace.keys()
+            ]:
+                namespace[_funknown] = None
+
+    @classmethod
+    def process_class_fields(  # pylint: disable=too-complex,too-many-branches
+        mcs: type["_MetaElement"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        extensions: dict[str, Any],
+    ):
+        """
+        Scan the class namespace and partition fields.
+
+        Detects:
+          - modified fields (shadowing parent values),
+          - new fields (present in annotations),
+          - the optional `__initializer` classmethod (in mangled or unmangled form).
+
+        Validates annotations and types and removes processed items from `namespace`
+        so they won't become normal attributes. Results are staged into:
+          mcs.new_fields, mcs.modified_fields, mcs.initializer
+        to be committed later.
+        """
+        # iterating new and modified fields
+        mcs.modified_fields = {}
+        mcs.new_fields = {}
+        mcs.initializer = None
+        initializer_name: Optional[str] = None
+        for _fname, _fvalue in namespace.items():
+            if _fname == f"_{name}__initializer" or (
+                name.startswith("_") and _fname == "__initializer"
+            ):
+                if not isinstance(_fvalue, classmethod):
+                    raise InvalidInitializerType(
+                        "__initializer should be a classmethod"
+                    )
+                mcs.initializer = _fvalue.__func__
+                if name.startswith("_"):
+                    initializer_name = "__initializer"
+                else:
+                    initializer_name = f"_{name}__initializer"
+            elif _fname.startswith("_"):
+                pass
+            elif isinstance(_fvalue, classmethod):
+                pass
+            else:
+                print(f"Parsing Field: {_fname} / {_fvalue}")
+                if (
+                    len(bases) == 1 and _fname in namespace["__LAMSchema__"].keys()
+                ):  # Modified fields
+                    mcs.process_modified_field(
+                        name, bases, namespace, _fname, _fvalue, extensions
+                    )
+                else:  # New fieds
+                    mcs.process_new_field(
+                        name, bases, namespace, _fname, _fvalue, extensions
+                    )
+        # removing modified fields from class (will add them back later)
+        for _fname in mcs.new_fields:
+            del namespace[_fname]
+        for _fname in mcs.modified_fields:
+            del namespace[_fname]
+        if mcs.initializer is not None and initializer_name is not None:
+            del namespace[initializer_name]
+
+    @classmethod
+    def process_modified_field(
+        mcs: type["_MetaElement"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        _fname: str,
+        _fvalue: Any,
+        extensions: dict[str, Any],
+    ):  # pylint: disable=unused-argument
+        """
+        Handle a *modified* field declared by a subclass.
+
+        Forbids annotation changes, validates the new default value against
+        the inherited annotation, and stages the new default into `mcs.modified_fields`.
+        """
+        if "__annotations__" in namespace and _fname in namespace["__annotations__"]:
+            raise ReadOnlyFieldAnnotation(
+                f"annotations cannot be modified on derived classes {_fname}"
+            )
+        try:
+            check_type(
+                _fvalue,
+                namespace["__LAMSchema__"][_fname].annotations,
+                collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+            )
+        except TypeCheckError as exp:
+            raise InvalidFieldValue(
+                f"Field <{_fname}> New Field value is not of expected type {bases[0].__annotations__[_fname]}."
+            ) from exp
+        mcs.modified_fields[_fname] = _fvalue
+
+    @classmethod
+    def process_new_field(
+        mcs: type["_MetaElement"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        _fname: str,
+        _fvalue: Any,
+        extensions: dict[str, Any],
+    ):  # pylint: disable=unused-argument
+        """
+        Handle a *new* field declared on the class.
+
+        Resolves string annotations against a whitelist, validates `Annotated[...]`
+        payloads (allowing only LAMFieldInfo), checks the default value type,
+        and stages the field as a `LAMField` in `mcs.new_fields`.
+        """
+        print(f"New field: {_fname}")
+
+        # check if field is annotated
+        if (
+            "__annotations__" not in namespace
+            or _fname not in namespace["__annotations__"]
+        ):
+            raise NotAnnotatedField(
+                f"Every dabmodel Fields must be annotated ({_fname})"
+            )
+
+        # check if annotation is allowed
+        if isinstance(namespace["__annotations__"][_fname], str):
+            namespace["__annotations__"][_fname] = _resolve_annotation(
+                namespace["__annotations__"][_fname]
+            )
+
+        try:
+            _check_annotation_definition(namespace["__annotations__"][_fname])
+        except InvalidFieldAnnotation:
+            raise
+        except Exception as ex:
+            raise InvalidFieldAnnotation(
+                f"Field <{_fname}> has not an allowed or valid annotation.", ex
+            )
+
+        _finfo: LAMFieldInfo = LAMFieldInfo()
+        origin = get_origin(namespace["__annotations__"][_fname])
+        tname = (
+            getattr(origin, "__name__", "")
+            or getattr(origin, "__qualname__", "")
+            or str(origin)
+        )
+        if "Annotated" in tname:
+            args = get_args(namespace["__annotations__"][_fname])
+            if args:
+                if len(args) > 2:
+                    raise InvalidFieldAnnotation(
+                        f"Field <{_fname}> had invalid Annotated value."
+                    )
+                if len(args) == 2 and not isinstance(args[1], LAMFieldInfo):
+                    raise InvalidFieldAnnotation(
+                        "Only LAMFieldInfo object is allowed as Annotated data."
+                    )
+
+                _finfo = args[1]
+
+        # check if value is valid
+        try:
+            check_type(
+                _fvalue,
+                namespace["__annotations__"][_fname],
+                collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+            )
+        except TypeCheckError as exp:
+            raise InvalidFieldValue(
+                f"Value of Field <{_fname}> is not of expected type {namespace['__annotations__'][_fname]}."
+            ) from exp
+        print(f"!!VAL: {_fvalue}")
+        mcs.new_fields[_fname] = LAMField(
+            _fname, _fvalue, namespace["__annotations__"][_fname], _finfo
+        )
+
+    @classmethod
+    def apply_initializer(
+        mcs: type["_MetaElement"],
+        cls,
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],  # pylint: disable=unused-argument
+        extensions: dict[str, Any],
+    ):
+        """
+        Apply the optional `__initializer` classmethod to compute derived defaults.
+
+        The initializer runs in a restricted, import-blocked environment using a
+        `ModelSpecView` proxy that enforces type checking on assignments.
+        On success, the computed values are validated and written back into the
+        class schema's DABFields.
+        """
+        if mcs.initializer is not None:
+            _check_initializer_safety(mcs.initializer)
+            init_fieldvalues = {}
+            init_fieldtypes = {}
+            for _fname, _fvalue in cls.__LAMSchema__.items():
+                if isinstance(_fvalue, LAMField):
+                    init_fieldvalues[_fname] = deepcopy(_fvalue.raw_value)
+                    init_fieldtypes[_fname] = _fvalue.annotations
+            fakecls = ModelSpecView(
+                init_fieldvalues, init_fieldtypes, cls.__name__, cls.__module__
+            )
+            safe_globals = {
+                "__builtins__": {"__import__": _blocked_import},
+                **ALLOWED_HELPERS_DEFAULT,
+            }
+            # if mcs.initializer.__code__.co_freevars:
+            #    raise FunctionForbidden("__initializer must not use closures")
+            safe_initializer = FunctionType(
+                mcs.initializer.__code__,
+                safe_globals,
+                name=mcs.initializer.__name__,
+                argdefs=mcs.initializer.__defaults__,
+                closure=mcs.initializer.__closure__,
+            )
+            safe_initializer(fakecls)  # pylint: disable=not-callable
+            for _fname, _fvalue in fakecls.export().items():
+                try:
+                    check_type(
+                        _fvalue,
+                        cls.__LAMSchema__[_fname].annotations,
+                        collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+                    )
+                except TypeCheckError as exp:
+                    raise InvalidFieldValue(
+                        f"Value of Field <{_fname}> is not of expected type {namespace['__annotations__'][_fname]}."
+                    ) from exp
+                cls.__LAMSchema__[_fname] = deepcopy(cls.__LAMSchema__[_fname])
+                cls.__LAMSchema__[_fname].update_value(_fvalue)
+
+    def __new__(
+        mcs: type["_MetaElement"],
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+    ) -> Type:
+        """BaseElement new class"""
+        extensions: dict[str, Any] = {}
+        mcs.check_class(name, bases, namespace, extensions)
+        mcs.process_class_fields(name, bases, namespace, extensions)
+
+        _cls = super().__new__(mcs, name, bases, namespace)
+
+        mcs.commit_fields(_cls, name, bases, namespace, extensions)
+        mcs.apply_initializer(_cls, name, bases, namespace, extensions)
+        _cls.install_instance_guard(extensions)
+
+        return _cls
+
+    @classmethod
+    def commit_fields(
+        mcs: type["_MetaElement"],
+        cls,
+        name: str,
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],  # pylint: disable=unused-argument
+        extensions: dict[str, Any],
+    ):
+        """
+        Commit staged fields into the class schema (`__LAMSchema__`).
+
+        - For modified fields: copy the parent's LAMField, update its value.
+        - For new fields: set the freshly built LAMField and record its source.
+        """
+        for _fname, _fvalue in mcs.modified_fields.items():
+            cls.__LAMSchema__[_fname] = deepcopy(bases[0].__LAMSchema__[_fname])
+            cls.__LAMSchema__[_fname].update_value(_fvalue)
+
+        for _fname, _fvalue in mcs.new_fields.items():
+            _fvalue.add_source(cls)
+            cls.__LAMSchema__[_fname] = _fvalue
+
+    def __call__(cls: Type, *args: Any, **kw: Any):  # intentionally untyped
+        """BaseElement new instance"""
+        obj = super().__call__(*args)
+
+        extensions: dict[str, Any] = {}
+
+        cls.populate_instance(  # pylint: disable=no-value-for-parameter
+            obj, extensions, *args, **kw
+        )
+        cls.freeze_instance_schema(  # pylint: disable=no-value-for-parameter
+            obj, extensions, *args, **kw
+        )
+        cls.apply_overrides(  # pylint: disable=no-value-for-parameter
+            obj, extensions, *args, **kw
+        )
+        cls.finalize_instance(obj, extensions)  # pylint: disable=no-value-for-parameter
+
+        return obj
+
+    def populate_instance(
+        cls: Type, obj: Any, extensions: dict[str, Any], *args: Any, **kw: Any
+    ):
+        """
+        Populate the new instance with field values from the class schema.
+
+        Copies each LAMField.value to an instance attribute (deep-frozen view).
+        """
+        for _fname, _fvalue in cls.__LAMSchema__.items():
+            if isinstance(_fvalue, LAMField):
+                object.__setattr__(obj, _fname, _fvalue.value)
+
+    def freeze_instance_schema(
+        cls: Type, obj: Any, extensions: dict[str, Any], *args: Any, **kw: Any
+    ):
+        """
+        Freeze the instance's schema by wrapping DABFields into FrozenLAMField.
+
+        Creates a per-instance `__LAMSchema__` dict where each field is read-only.
+        """
+        inst_schema = copy(obj.__LAMSchema__)
+        for _fname, _fvalue in cls.__LAMSchema__.items():
+            if isinstance(_fvalue, LAMField):
+                inst_schema[_fname] = FrozenLAMField(_fvalue)
+
+        if "features" in inst_schema:
+            inst_schema["features"] = dict(inst_schema["features"])
+
+        object.__setattr__(obj, "__LAMSchema__", inst_schema)
+
+    def apply_overrides(cls, obj, extensions, *args, **kwargs):
+        """
+        Hook for runtime overrides at instance creation.
+
+        Invoked after the schema has been frozen but before finalize_instance.
+        Subclasses of _MetaElement can override this to support things like:
+
+          - Field overrides: MyApp(field=value)
+        """
+
+        # --- field overrides (unchanged) ---
+        for k, v in list(kwargs.items()):
+            if k in cls.__LAMSchema__:  # regular field
+                field = cls.__LAMSchema__[k]
+                try:
+                    check_type(
+                        v,
+                        field.annotations,
+                        collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
+                    )
+                except TypeCheckError as exp:
+                    raise InvalidFieldValue(
+                        f"Invalid value for field '{k}': expected {field.annotations}, got {v!r}"
+                    ) from exp
+
+                object.__setattr__(obj, k, LAMdeepfreeze(v))
+                obj.__LAMSchema__[k] = FrozenLAMField(
+                    LAMField(k, v, field.annotations, field._info)
+                )
+                kwargs.pop(k)
+
+        if kwargs:
+            unknown = ", ".join(sorted(kwargs.keys()))
+            raise InvalidFieldValue(f"Unknown parameters: {unknown}")
+
+    def finalize_instance(cls: Type, obj: Any, extensions: dict[str, Any]):
+        """
+        Finalization hook invoked at the end of instance construction.
+
+        Subclasses of the metaclass override this to attach runtime components
+        to the instance. (Example: BaseMetaAppliance instantiates bound Features
+        and sets them as attributes on the appliance instance.)
+        """
+
+    def install_instance_guard(cls: Type, extensions: dict[str, Any]):
+        """
+        Install the runtime `__setattr__` guard on the class.
+
+        After instances are constructed, prevents:
+          - creating new public fields,
+          - reassigning existing fields post-initialization.
+
+        Private/dunder attributes are exempt to allow internal bookkeeping.
+        """
+        orig_setattr = getattr(cls, "__setattr__")
+
+        # cls.orig_setattr = orig_setattr
+
+        def guarded_setattr(_self, key: str, value: Any):
+            if key.startswith("_"):  # allow private and dunder attrs
+                return orig_setattr(_self, key, value)
+            # block writes after init if key is readonly
+            if key in _self.__LAMSchema__.keys():
+                if key in _self.__dict__:
+                    raise ReadOnlyField(f"{key} is read-only")
+            # elif key in _self.__LAMSchema__["features"].keys():
+            #    if key in _self.__dict__:
+            #        raise ReadOnlyField(f"{key} is read-only")
+            else:
+                raise NewFieldForbidden("creating new fields is not allowed")
+
+            return orig_setattr(_self, key, value)
+
+        setattr(cls, "__setattr__", guarded_setattr)

src/dabmodel/meta/feature.py

@@ -0,0 +1,19 @@
+from typing import Type, Any
+from .element import _MetaElement
+from ..exception import FeatureNotBound
+
+
+class _MetaFeature(_MetaElement):
+    """_MetaFeature class
+    Feature specific metaclass code
+    """
+
+    def __call__(cls: Type, *args: Any, **kw: Any):  # intentionally untyped
+        """BaseFeature new instance"""
+
+        if cls._BoundAppliance is None:
+            raise FeatureNotBound()
+
+        obj = super().__call__(*args, **kw)
+
+        return obj

src/dabmodel/model.py

@@ -1,374 +0,0 @@
-from typing import Optional, TypeVar, Generic, Union, get_origin, get_args, List, Dict, Any, Tuple, Set, Annotated, FrozenSet
-from types import UnionType
-from frozendict import deepfreeze
-from copy import deepcopy, copy
-from pprint import pprint
-
-from typeguard import check_type, TypeCheckError, CollectionCheckStrategy
-
-ALLOWED_ANNOTATIONS = {
-    "Union": Union,
-    "Optional": Optional,
-    "List": List,
-    "Dict": Dict,
-    "Tuple": Tuple,
-    "Set": Set,
-    "FrozenSet": FrozenSet,
-    "Annotated": Annotated,
-    # builtins:
-    "int": int,
-    "str": str,
-    "float": float,
-    "bool": bool,
-    "complex": complex,
-    "bytes": bytes,
-    "None": type(None),
-    "list": list,
-    "dict": dict,
-    "set": set,
-    "frozenset": frozenset,
-    "tuple": tuple,
-}
-
-ALLOWED_MODEL_FIELDS_TYPES = (str, int, float, complex, bool, bytes)
-ALLOWED_MODEL_FIELDS_CONTAINERS = (dict, list, set, frozenset, tuple)
-
-
-TV_ALLOWED_MODEL_FIELDS_TYPES = TypeVar("TV_ALLOWED_MODEL_FIELDS_TYPES", *ALLOWED_MODEL_FIELDS_TYPES, *ALLOWED_MODEL_FIELDS_CONTAINERS)
-
-
-class DABModelException(Exception): ...
-
-
-class MultipleInheritanceForbidden(DABModelException): ...
-
-
-class BrokenInheritance(DABModelException): ...
-
-
-class ReadOnlyField(DABModelException): ...
-
-
-class NewFieldForbidden(DABModelException): ...
-
-
-class InvalidFieldAnnotation(DABModelException): ...
-
-
-class NotAnnotatedField(InvalidFieldAnnotation): ...
-
-
-class IncompletelyAnnotatedField(InvalidFieldAnnotation): ...
-
-
-class ReadOnlyFieldAnnotation(DABModelException): ...
-
-
-class InvalidFieldValue(DABModelException): ...
-
-
-def _resolve_annotation(ann):
-    if isinstance(ann, str):
-        # Safe eval against a **whitelist** only
-        return eval(ann, {"__builtins__": {}}, ALLOWED_ANNOTATIONS)
-    return ann
-
-
-def _peel_annotated(t: Any) -> Any:
-    # If you ever allow Annotated[T, ...], peel to T
-    while True:
-        origin = get_origin(t)
-        if origin is None:
-            return t
-        name = getattr(origin, "__name__", "") or getattr(origin, "__qualname__", "") or str(origin)
-        if "Annotated" in name:
-            args = get_args(t)
-            t = args[0] if args else t
-        else:
-            return t
-
-
-def _check_annotation_definition(_type) -> bool:
-    _type = _peel_annotated(_type)
-    # handle Optional[] and Union[None,...]
-    if (get_origin(_type) is Union or get_origin(_type) is UnionType) and type(None) in get_args(_type):
-        return all([_check_annotation_definition(_) for _ in get_args(_type) if _ is not type(None)])
-
-    # handle other Union[...]
-    if get_origin(_type) is Union or get_origin(_type) is UnionType:
-        return all([_check_annotation_definition(_) for _ in get_args(_type)])
-
-    # handle Dict[...]
-    if get_origin(_type) is dict:
-        inner = get_args(_type)
-        if len(inner) != 2:
-            raise IncompletelyAnnotatedField(f"Dict Annotation requires 2 inner definitions: {_type}")
-        return _peel_annotated(inner[0]) in ALLOWED_MODEL_FIELDS_TYPES and _check_annotation_definition(inner[1])
-
-    # handle Tuple[]
-    if get_origin(_type) in [tuple]:
-        inner_types = get_args(_type)
-        if len(inner_types) == 0:
-            raise IncompletelyAnnotatedField(f"Annotation requires inner definition: {_type}")
-        if len(inner_types) == 2 and inner_types[1] is Ellipsis:
-            return _check_annotation_definition(inner_types[0])
-        return all([_check_annotation_definition(_) for _ in inner_types])
-
-    # handle Set[],Tuple[],FrozenSet[],List[]
-    if get_origin(_type) in [set, frozenset, tuple, list]:
-        inner_types = get_args(_type)
-        if len(inner_types) == 0:
-            raise IncompletelyAnnotatedField(f"Annotation requires inner definition: {_type}")
-        return all([_check_annotation_definition(_) for _ in inner_types])
-
-    if _type in ALLOWED_MODEL_FIELDS_TYPES:
-        return True
-    return False
-
-
-class BaseConstraint(Generic[TV_ALLOWED_MODEL_FIELDS_TYPES]):
-    _bound_type: type
-
-    def __init__(self): ...
-
-    def check(self, value: TV_ALLOWED_MODEL_FIELDS_TYPES) -> bool: ...
-
-
-def _deepfreeze(value):
-    if isinstance(value, dict):
-        return deepfreeze(value)
-    elif isinstance(value, set):
-        return frozenset(_deepfreeze(v) for v in value)
-    elif isinstance(value, list):
-        return tuple(_deepfreeze(v) for v in value)
-    elif isinstance(value, tuple):
-        return tuple(_deepfreeze(v) for v in value)
-    return value
-
-
-class DABFieldInfo:
-    def __init__(self, *, doc: str = "", constraints: list[BaseConstraint] = []):
-        self._doc: str = doc
-        self._constraints: list[BaseConstraint] = constraints
-
-    @property
-    def doc(self):
-        return self._doc
-
-    @property
-    def constraints(self):
-        return self._constraints
-
-
-class DABField(Generic[TV_ALLOWED_MODEL_FIELDS_TYPES]):
-    def __init__(self, name: str, v: Optional[TV_ALLOWED_MODEL_FIELDS_TYPES], a: Any, i: str):
-        self._name: str = name
-        self._source: Optional[type] = None
-        self._default_value: Optional[TV_ALLOWED_MODEL_FIELDS_TYPES] = v
-        self._value: Optional[TV_ALLOWED_MODEL_FIELDS_TYPES] = v
-        self._annotations: Any = a
-        self._info: DABFieldInfo = i
-        self._constraints: List[BaseConstraint] = i.constraints
-
-    def add_source(self, s: type) -> None:
-        self._source = s
-
-    @property
-    def doc(self):
-        return self._info.doc
-
-    def add_constraint(self, c: BaseConstraint) -> None:
-        self._constraints.append(c)
-
-    @property
-    def constraints(self) -> list[BaseConstraint]:
-        return self._info.constraints
-
-    @property
-    def default_value(self):
-        return _deepfreeze(self._default_value)
-
-    def update_value(self, v: Optional[TV_ALLOWED_MODEL_FIELDS_TYPES] = None) -> None:
-        self._value = v
-
-    @property
-    def value(self):
-        return _deepfreeze(self._value)
-
-    @property
-    def annotations(self) -> Any:
-        return self._annotations
-
-
-class FrozenDABField(Generic[TV_ALLOWED_MODEL_FIELDS_TYPES]):
-    def __init__(self, inner_field: DABField):
-        self._inner_field = inner_field
-
-    @property
-    def doc(self):
-        return self._inner_field.doc
-
-    @property
-    def constraints(self):
-        return _deepfreeze(self._inner_field.constraints)
-
-    @property
-    def default_value(self):
-        return self._inner_field.default_value
-
-    @property
-    def value(self):
-        return self._inner_field.value
-
-    @property
-    def annotations(self) -> Any:
-        return _deepfreeze(self._inner_field.annotations)
-
-
-class BaseMeta(type):
-    def __new__(mcls, name, bases, namespace):
-        # print("__NEW__ Defining:", name, "with keys:", list(namespace))
-
-        if len(bases) > 1:
-            raise MultipleInheritanceForbidden("Multiple inheritance is not supported by dabmodel")
-        elif len(bases) == 0:  # base class (BaseElement)
-            namespace["__DABSchema__"] = dict()
-        else:  # standard inheritance
-            # check class tree origin
-            if "__DABSchema__" not in dir(bases[0]):
-                raise BrokenInheritance("__DABSchema__ not found in base class, broken inheritance chain.")
-            # copy inherited schema
-            namespace["__DABSchema__"] = copy(bases[0].__DABSchema__)
-
-        # force field without default value to be instantiated (with None)
-        if "__annotations__" in namespace:
-            for _funknown in [_ for _ in namespace["__annotations__"] if _ not in namespace.keys()]:
-                namespace[_funknown] = None
-
-        # iterating new and modified fields
-        modified_field: Dict[str, Any] = {}
-        new_fields: Dict[str, DABField] = {}
-        for _fname, _fvalue in namespace.items():
-            if _fname.startswith("__"):
-                pass
-            elif _fname == "Constraints" and type(_fvalue) is type:
-                ...
-                # print("FOUND Constraints")
-            else:
-                # print(f"Parsing Field: {_fname} / {_fvalue}")
-                # Modified fields
-                if len(bases) == 1 and _fname in namespace["__DABSchema__"].keys():
-                    # print(f"Modified field: {_fname}")
-                    if "__annotations__" in namespace and _fname in namespace["__annotations__"]:
-                        raise ReadOnlyFieldAnnotation("annotations cannot be modified on derived classes")
-                    try:
-                        check_type(
-                            _fvalue,
-                            namespace["__DABSchema__"][_fname].annotations,
-                            collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS,
-                        )
-                    except TypeCheckError as exp:
-                        raise InvalidFieldValue(
-                            f"Field <{_fname}> New Field value is not of expected type {bases[0].__annotations__[_fname]}."
-                        ) from exp
-                    modified_field[_fname] = _fvalue
-                # New fieds
-                else:
-                    # print(f"New field: {_fname}")
-                    # print(f"type is: {type(_fvalue)}")
-                    # print(f"value is: {_fvalue}")
-
-                    # check if field is annotated
-                    if "__annotations__" not in namespace or _fname not in namespace["__annotations__"]:
-                        raise NotAnnotatedField(f"Every dabmodel Fields must be annotated ({_fname})")
-
-                    # check if annotation is allowed
-                    if isinstance(namespace["__annotations__"][_fname], str):
-                        namespace["__annotations__"][_fname] = _resolve_annotation(namespace["__annotations__"][_fname])
-
-                    if not _check_annotation_definition(namespace["__annotations__"][_fname]):
-                        raise InvalidFieldAnnotation(f"Field <{_fname}> has not an allowed or valid annotation.")
-
-                    _finfo: Optional[DABFieldInfo] = DABFieldInfo()
-                    origin = get_origin(namespace["__annotations__"][_fname])
-                    name = getattr(origin, "__name__", "") or getattr(origin, "__qualname__", "") or str(origin)
-                    if "Annotated" in name:
-                        args = get_args(namespace["__annotations__"][_fname])
-                        if args:
-                            if len(args) > 2:
-                                raise InvalidFieldAnnotation(f"Field <{_fname}> had invalid Annotated value.")
-                            if len(args) == 2 and not isinstance(args[1], DABFieldInfo):
-                                raise InvalidFieldAnnotation(f"Only DABFieldInfo object is allowed as Annotated data.")
-
-                            _finfo = args[1]
-
-                    # print(f"annotation is: {namespace['__annotations__'][_fname]}")
-                    # check if value is valid
-                    try:
-                        check_type(
-                            _fvalue, namespace["__annotations__"][_fname], collection_check_strategy=CollectionCheckStrategy.ALL_ITEMS
-                        )
-                    except TypeCheckError as exp:
-                        raise InvalidFieldValue(
-                            f"Value of Field <{_fname}> is not of expected type {namespace['__annotations__'][_fname]}."
-                        ) from exp
-                    new_fields[_fname] = DABField(_fname, _fvalue, namespace["__annotations__"][_fname], _finfo)
-
-        # removing modified fields from class (will add them back later)
-        for _fname in new_fields.keys():
-            del namespace[_fname]
-        for _fname in modified_field.keys():
-            del namespace[_fname]
-
-        orig_setattr = namespace.get("__setattr__", object.__setattr__)
-
-        def guarded_setattr(self, key, value):
-            if key.startswith("_"):  # allow private and dunder attrs
-                return orig_setattr(self, key, value)
-            # block writes after init if key is readonly
-            if key in self.__DABSchema__.keys():
-                if hasattr(self, key):
-                    raise ReadOnlyField(f"{key} is read-only")
-            else:
-                raise NewFieldForbidden(f"creating new fields is not allowed")
-
-            return orig_setattr(self, key, value)
-
-        namespace["__setattr__"] = guarded_setattr
-
-        cls = super().__new__(mcls, name, bases, namespace)
-
-        for _fname, _fvalue in modified_field.items():
-            cls.__DABSchema__[_fname] = deepcopy(bases[0].__DABSchema__[_fname])
-            cls.__DABSchema__[_fname].update_value(_fvalue)
-
-        for _fname, _fvalue in new_fields.items():
-            _fvalue.add_source(cls)
-            cls.__DABSchema__[_fname] = _fvalue
-
-        return cls
-
-    def __call__(cls, *args, **kw):
-        obj = super().__call__(*args, **kw)
-
-        for _fname in cls.__DABSchema__.keys():
-            setattr(obj, _fname, cls.__DABSchema__[_fname].value)
-        # obj.__DABSchema__ = deepfreeze(obj.__DABSchema__)
-        # setattr(obj, "__DABSchema__", deepfreeze(obj.__DABSchema__))
-        inst_schema = dict()
-        for _fname, _fvalue in cls.__DABSchema__.items():
-            inst_schema[_fname] = FrozenDABField(_fvalue)
-        setattr(obj, "__DABSchema__", inst_schema)
-        return obj
-
-
-class BaseElement(metaclass=BaseMeta):
-    pass
-
-
-class BaseFeature(BaseElement):
-    pass
-
-
-class BaseAppliance(BaseElement):
-    pass

src/dabmodel/tools.py

@@ -1,13 +1,36 @@
+"""library's internal tools"""
+
+from typing import Union, List, Any, Dict
 from uuid import UUID
 from datetime import datetime
 import json
 
+from frozendict import deepfreeze
 
-class DABJSONEncoder(json.JSONEncoder):
-    def default(self, obj):
-        if isinstance(obj, UUID):
-            # if the obj is uuid, we simply return the value of uuid
-            return obj.hex
-        elif isinstance(obj, datetime):
-            return str(obj)
-        return json.JSONEncoder.default(self, obj)
+JSONPrimitive = Union[str, int, float, bool, None]
+JSONType = Union[JSONPrimitive, List[Any], Dict[str, Any]]  # recursive in practice
+
+
+class LAMJSONEncoder(json.JSONEncoder):
+    """allows to JSON encode non supported data type"""
+
+    def default(self, o):
+        if isinstance(o, UUID):
+            # if the o is uuid, we simply return the value of uuid
+            return o.hex
+        if isinstance(o, datetime):
+            return str(o)
+        return json.JSONEncoder.default(self, o)
+
+
+def LAMdeepfreeze(value):
+    """recursive freeze helper function"""
+    if isinstance(value, dict):
+        return deepfreeze(value)
+    if isinstance(value, set):
+        return frozenset(LAMdeepfreeze(v) for v in value)
+    if isinstance(value, list):
+        return tuple(LAMdeepfreeze(v) for v in value)
+    if isinstance(value, tuple):
+        return tuple(LAMdeepfreeze(v) for v in value)
+    return value

test/test_element.py

@@ -0,0 +1,293 @@
+# dabmodel (c) by chacha
+#
+# dabmodel  is licensed under a
+# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
+#
+# You should have received a copy of the license along with this
+# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
+
+import unittest
+
+import sys
+import subprocess
+from os import chdir, environ
+from pathlib import Path
+
+print(__name__)
+print(__package__)
+
+from src import dabmodel as dm
+
+testdir_path = Path(__file__).parent.resolve()
+chdir(testdir_path.parent.resolve())
+
+
+class ElementTest(unittest.TestCase):
+    def setUp(self):
+        print("\n->", unittest.TestCase.id(self))
+
+    def test_element_simple(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class A(dm.Appliance):
+            elem: E = E(ivalue=45, strvalue="coucou", ar_int=[5, 7])
+
+        a = A()
+
+        self.assertIsInstance(a.elem, E)
+        self.assertIsInstance(a.elem.ivalue, int)
+        self.assertEqual(a.elem.ivalue, 45)
+        self.assertIsInstance(a.elem.strvalue, str)
+        self.assertEqual(a.elem.strvalue, "coucou")
+        self.assertIsInstance(a.elem.fvalue, float)
+        self.assertEqual(a.elem.fvalue, 1.4322)
+        self.assertIsInstance(a.elem.ar_int, tuple)
+        self.assertEqual(a.elem.ar_int, (5, 7))
+        self.assertIsInstance(a.elem.ar_int2, tuple)
+        self.assertEqual(a.elem.ar_int2, (1, 54, 65))
+
+    def test_element_in_container(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class A(dm.Appliance):
+            elems: list[E] = [
+                E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
+                E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]),
+            ]
+
+        a = A()
+
+        self.assertIsInstance(a.elems, tuple)
+        self.assertEqual(len(a.elems), 2)
+
+        self.assertIsInstance(a.elems[0], E)
+        self.assertIsInstance(a.elems[0].ivalue, int)
+        self.assertEqual(a.elems[0].ivalue, 45)
+        self.assertIsInstance(a.elems[0].strvalue, str)
+        self.assertEqual(a.elems[0].strvalue, "coucou")
+        self.assertIsInstance(a.elems[0].fvalue, float)
+        self.assertEqual(a.elems[0].fvalue, 1.4322)
+        self.assertIsInstance(a.elems[0].ar_int, tuple)
+        self.assertEqual(a.elems[0].ar_int, (5, 7))
+        self.assertIsInstance(a.elems[0].ar_int2, tuple)
+        self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(a.elems[1], E)
+        self.assertIsInstance(a.elems[1].ivalue, int)
+        self.assertEqual(a.elems[1].ivalue, 46)
+        self.assertIsInstance(a.elems[1].strvalue, str)
+        self.assertEqual(a.elems[1].strvalue, "coucou2")
+        self.assertIsInstance(a.elems[1].fvalue, float)
+        self.assertEqual(a.elems[1].fvalue, 1.4322)
+        self.assertIsInstance(a.elems[1].ar_int, tuple)
+        self.assertEqual(a.elems[1].ar_int, (50, 7))
+        self.assertIsInstance(a.elems[1].ar_int2, tuple)
+        self.assertEqual(a.elems[1].ar_int2, (1, 54, 65))
+
+    def test_element_frozen(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class A(dm.Appliance):
+            elems: list[E] = [
+                E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
+                E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]),
+            ]
+            elem: E = E()
+
+        a = A()
+
+        with self.assertRaises(AttributeError):
+            a.elems.add(E())
+
+        with self.assertRaises(dm.ReadOnlyField):
+            a.elem.ivalue = 1
+
+        with self.assertRaises(dm.ReadOnlyField):
+            a.elems[0].ivalue = 1
+
+    def test_element_inheritance(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class E2(E):
+            ivalue2: int = 43
+
+        class A(dm.Appliance):
+            elems: list[E] = [
+                E(ivalue=45, strvalue="coucou", ar_int=[5, 7]),
+                E2(ivalue=46, strvalue="coucou2", ar_int=[50, 7], ivalue2=32),
+            ]
+            elem: E = E()
+            elem2: E2 = E2(ivalue=7, ivalue2=33)
+
+        a = A()
+
+        self.assertIsInstance(a.elems, tuple)
+        self.assertEqual(len(a.elems), 2)
+
+        self.assertIsInstance(a.elems[0], E)
+        self.assertIsInstance(a.elems[0].ivalue, int)
+        self.assertEqual(a.elems[0].ivalue, 45)
+        self.assertIsInstance(a.elems[0].strvalue, str)
+        self.assertEqual(a.elems[0].strvalue, "coucou")
+        self.assertIsInstance(a.elems[0].fvalue, float)
+        self.assertEqual(a.elems[0].fvalue, 1.4322)
+        self.assertIsInstance(a.elems[0].ar_int, tuple)
+        self.assertEqual(a.elems[0].ar_int, (5, 7))
+        self.assertIsInstance(a.elems[0].ar_int2, tuple)
+        self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(a.elems[1], E2)
+        self.assertIsInstance(a.elems[1].ivalue, int)
+        self.assertEqual(a.elems[1].ivalue, 46)
+        self.assertIsInstance(a.elems[1].ivalue2, int)
+        self.assertEqual(a.elems[1].ivalue2, 32)
+        self.assertIsInstance(a.elems[1].strvalue, str)
+        self.assertEqual(a.elems[1].strvalue, "coucou2")
+        self.assertIsInstance(a.elems[1].fvalue, float)
+        self.assertEqual(a.elems[1].fvalue, 1.4322)
+        self.assertIsInstance(a.elems[1].ar_int, tuple)
+        self.assertEqual(a.elems[1].ar_int, (50, 7))
+        self.assertIsInstance(a.elems[1].ar_int2, tuple)
+        self.assertEqual(a.elems[1].ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(a.elem, E)
+        self.assertIsInstance(a.elem.ivalue, int)
+        self.assertEqual(a.elem.ivalue, 43)
+        self.assertIsInstance(a.elem.strvalue, str)
+        self.assertEqual(a.elem.strvalue, "test")
+        self.assertIsInstance(a.elem.fvalue, float)
+        self.assertEqual(a.elem.fvalue, 1.4322)
+        self.assertIsInstance(a.elem.ar_int, tuple)
+        self.assertEqual(a.elem.ar_int, (1, 54, 65))
+        self.assertIsInstance(a.elem.ar_int2, tuple)
+        self.assertEqual(a.elem.ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(a.elem2, E2)
+        self.assertIsInstance(a.elem2.ivalue, int)
+        self.assertEqual(a.elem2.ivalue, 7)
+        self.assertIsInstance(a.elem2.ivalue2, int)
+        self.assertEqual(a.elem2.ivalue2, 33)
+        self.assertIsInstance(a.elem2.strvalue, str)
+        self.assertEqual(a.elem2.strvalue, "test")
+        self.assertIsInstance(a.elem2.fvalue, float)
+        self.assertEqual(a.elem2.fvalue, 1.4322)
+        self.assertIsInstance(a.elem2.ar_int, tuple)
+        self.assertEqual(a.elem2.ar_int, (1, 54, 65))
+        self.assertIsInstance(a.elem2.ar_int2, tuple)
+        self.assertEqual(a.elem2.ar_int2, (1, 54, 65))
+
+    def test_element_initializer(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class A(dm.Appliance):
+            elem: E = E(ivalue=45, strvalue="coucou", ar_int=[5, 7])
+
+            @classmethod
+            def __initializer(self):
+                self.elem = E(ivalue=12, strvalue="coucou", ar_int=[5, 7])
+
+        a = A()
+
+        self.assertIsInstance(a.elem, E)
+        self.assertIsInstance(a.elem.ivalue, int)
+        self.assertEqual(a.elem.ivalue, 12)
+        self.assertIsInstance(a.elem.strvalue, str)
+        self.assertEqual(a.elem.strvalue, "coucou")
+        self.assertIsInstance(a.elem.fvalue, float)
+        self.assertEqual(a.elem.fvalue, 1.4322)
+        self.assertIsInstance(a.elem.ar_int, tuple)
+        self.assertEqual(a.elem.ar_int, (5, 7))
+        self.assertIsInstance(a.elem.ar_int2, tuple)
+        self.assertEqual(a.elem.ar_int2, (1, 54, 65))
+
+    def test_element_in_container_initializer(self):
+        class E(dm.Element):
+            ivalue: int = 43
+            strvalue: str = "test"
+            fvalue: float = 1.4322
+            ar_int: list[int] = [1, 54, 65]
+            ar_int2: list[int] = [1, 54, 65]
+
+        class A(dm.Appliance):
+            elems: list[E] = [E(ivalue=45, strvalue="coucou", ar_int=[5, 7])]
+
+        class B(A):
+            @classmethod
+            def __initializer(cls):
+                cls.elems.append(E(ivalue=46, strvalue="coucou2", ar_int=[50, 7]))
+
+        a = A()
+        b = B()
+
+        self.assertIsInstance(a.elems, tuple)
+        self.assertEqual(len(a.elems), 1)
+
+        self.assertIsInstance(a.elems[0], E)
+        self.assertIsInstance(a.elems[0].ivalue, int)
+        self.assertEqual(a.elems[0].ivalue, 45)
+        self.assertIsInstance(a.elems[0].strvalue, str)
+        self.assertEqual(a.elems[0].strvalue, "coucou")
+        self.assertIsInstance(a.elems[0].fvalue, float)
+        self.assertEqual(a.elems[0].fvalue, 1.4322)
+        self.assertIsInstance(a.elems[0].ar_int, tuple)
+        self.assertEqual(a.elems[0].ar_int, (5, 7))
+        self.assertIsInstance(a.elems[0].ar_int2, tuple)
+        self.assertEqual(a.elems[0].ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(b.elems, tuple)
+        self.assertEqual(len(b.elems), 2)
+
+        self.assertIsInstance(b.elems[0], E)
+        self.assertIsInstance(b.elems[0].ivalue, int)
+        self.assertEqual(b.elems[0].ivalue, 45)
+        self.assertIsInstance(b.elems[0].strvalue, str)
+        self.assertEqual(b.elems[0].strvalue, "coucou")
+        self.assertIsInstance(b.elems[0].fvalue, float)
+        self.assertEqual(b.elems[0].fvalue, 1.4322)
+        self.assertIsInstance(b.elems[0].ar_int, tuple)
+        self.assertEqual(b.elems[0].ar_int, (5, 7))
+        self.assertIsInstance(b.elems[0].ar_int2, tuple)
+        self.assertEqual(b.elems[0].ar_int2, (1, 54, 65))
+
+        self.assertIsInstance(b.elems[1], E)
+        self.assertIsInstance(b.elems[1].ivalue, int)
+        self.assertEqual(b.elems[1].ivalue, 46)
+        self.assertIsInstance(b.elems[1].strvalue, str)
+        self.assertEqual(b.elems[1].strvalue, "coucou2")
+        self.assertIsInstance(b.elems[1].fvalue, float)
+        self.assertEqual(b.elems[1].fvalue, 1.4322)
+        self.assertIsInstance(b.elems[1].ar_int, tuple)
+        self.assertEqual(b.elems[1].ar_int, (50, 7))
+        self.assertIsInstance(b.elems[1].ar_int2, tuple)
+        self.assertEqual(b.elems[1].ar_int2, (1, 54, 65))
+
+
+# ---------- main ----------
+
+if __name__ == "__main__":
+    unittest.main()

test/test_feature.py

@@ -0,0 +1,730 @@
+# dabmodel (c) by chacha
+#
+# dabmodel  is licensed under a
+# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
+#
+# You should have received a copy of the license along with this
+# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
+
+import unittest
+
+from os import chdir
+from pathlib import Path
+
+from typing import (
+    Any,
+    Annotated,
+)
+
+
+print(__name__)
+print(__package__)
+
+from src import dabmodel as dm
+
+
+testdir_path = Path(__file__).parent.resolve()
+chdir(testdir_path.parent.resolve())
+
+
+def test_initializer_safe_testfc():
+    eval("print('hi')")
+
+
+class FeatureTest(unittest.TestCase):
+    def setUp(self):
+        print("\n->", unittest.TestCase.id(self))
+
+    def immutable_vars__test_field(
+        self, obj: Any, name: str, default_value: Any, test_value: Any
+    ):
+        # field is not in the class
+        self.assertNotIn(name, dir(obj.__class__))
+        # field is in the object
+        self.assertIn(name, dir(obj))
+        # field is in the schema
+        self.assertIn(name, obj.__LAMSchema__.keys())
+        # field is readable
+        self.assertEqual(getattr(obj, name), default_value)
+        # field is read only
+        with self.assertRaises(dm.ReadOnlyField):
+            setattr(obj, name, test_value)
+
+    def test_simple(self):
+        """Testing first appliance feature, and Field types (simple)"""
+
+        # class can be created
+        class Appliance1(dm.Appliance):
+            VarStrOuter: str = "testvalue APPLIANCE"
+
+            class Feature1(dm.Feature):
+                VarStrInner: str = "testvalue FEATURE"
+
+        app1 = Appliance1()
+
+        self.assertIsInstance(Appliance1.__LAMSchema__["VarStrOuter"], dm.LAMField)
+        self.assertIsInstance(app1.__LAMSchema__["VarStrOuter"], dm.FrozenLAMField)
+        self.assertIn("Feature1", app1.__LAMSchema__["features"])
+        self.assertIn(
+            "VarStrInner", app1.__LAMSchema__["features"]["Feature1"].__LAMSchema__
+        )
+        self.assertIsInstance(
+            app1.__LAMSchema__["features"]["Feature1"].__LAMSchema__["VarStrInner"],
+            dm.LAMField,
+        )
+        self.assertTrue(hasattr(app1, "Feature1"))
+        self.assertIsInstance(
+            app1.Feature1.__LAMSchema__["VarStrInner"], dm.FrozenLAMField
+        )
+        self.assertTrue(hasattr(app1.Feature1, "VarStrInner"))
+
+    def test_inheritance(self):
+        """Testing first appliance feature, and Field types (simple)"""
+
+        # class can be created
+        class Appliance1(dm.Appliance):
+            VarStrOuter: str = "testvalue APPLIANCE1"
+
+            class Feature1(dm.Feature):
+                VarStrInner: str = "testvalue FEATURE1"
+                VarInt: int = 42
+
+        print(dir(Appliance1))
+
+        class Appliance2(Appliance1):
+            VarStrOuter = "testvalue APPLIANCE2"
+
+            class Feature2(dm.Feature):
+                VarStrInner: str = "testvalue FEATURE2"
+
+        print(dir(Appliance2))
+
+        class Appliance3(Appliance2):
+            VarStrOuter = "testvalue APPLIANCE3"
+
+            class Feature1(Appliance1.Feature1):
+                VarStrInner = "testvalue FEATURE1 modded"
+
+            class Feature3(dm.Feature):
+                VarStrInner: str = "testvalue FEATURE3"
+
+        print(dir(Appliance3))
+
+        app1 = Appliance1()
+        app2 = Appliance2()
+        app3 = Appliance3()
+
+        self.assertIsInstance(Appliance1.__LAMSchema__["VarStrOuter"], dm.LAMField)
+        self.assertIsInstance(app1.__LAMSchema__["VarStrOuter"], dm.FrozenLAMField)
+        self.assertIn("Feature1", app1.__LAMSchema__["features"])
+        self.assertIn(
+            "VarStrInner", app1.__LAMSchema__["features"]["Feature1"].__LAMSchema__
+        )
+        self.assertIsInstance(
+            app1.__LAMSchema__["features"]["Feature1"].__LAMSchema__["VarStrInner"],
+            dm.LAMField,
+        )
+        self.assertTrue(hasattr(app1, "Feature1"))
+        self.assertIsInstance(
+            app1.Feature1.__LAMSchema__["VarStrInner"], dm.FrozenLAMField
+        )
+        self.assertTrue(hasattr(app1.Feature1, "VarStrInner"))
+        self.assertEqual(app1.VarStrOuter, "testvalue APPLIANCE1")
+        self.assertEqual(app1.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app1.Feature1.VarInt, 42)
+        self.assertEqual(app2.VarStrOuter, "testvalue APPLIANCE2")
+        self.assertEqual(app2.Feature2.VarStrInner, "testvalue FEATURE2")
+        self.assertEqual(app3.VarStrOuter, "testvalue APPLIANCE3")
+        self.assertEqual(app3.Feature1.VarStrInner, "testvalue FEATURE1 modded")
+        self.assertEqual(app3.Feature1.VarInt, 42)
+        self.assertEqual(app3.Feature3.VarStrInner, "testvalue FEATURE3")
+
+    def test_inheritance2(self):
+        """Testing first appliance feature, and Field types (simple)"""
+
+        # class can be created
+        class Appliance1(dm.Appliance):
+            class Feature1(dm.Feature):
+                VarStrInner: str = "testvalue FEATURE1"
+
+        # check cannot REdefine a feature from Feature
+        with self.assertRaises(dm.InvalidFeatureInheritance):
+
+            class Appliance2(Appliance1):
+                class Feature1(dm.Feature): ...
+
+        class Appliance2b(Appliance1):
+            class Feature1(Appliance1.Feature1): ...
+
+        # check only REdefine a feature from highest parent
+        with self.assertRaises(dm.InvalidFeatureInheritance):
+
+            class Appliance3(Appliance2b):
+                class Feature1(Appliance1.Feature1): ...
+
+        class Appliance3b(Appliance2b):
+            class Feature1(Appliance2b.Feature1): ...
+
+        app1 = Appliance1()
+        app2 = Appliance2b()
+        app3 = Appliance3b()
+
+        self.assertEqual(app1.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app2.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app3.Feature1.VarStrInner, "testvalue FEATURE1")
+
+        class Appliance4(Appliance3b):
+            class Feature1(Appliance3b.Feature1):
+                VarStrInner = "testvalue FEATURE4"
+
+        self.assertEqual(app1.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app2.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app3.Feature1.VarStrInner, "testvalue FEATURE1")
+
+        app4 = Appliance4()
+
+        self.assertEqual(app1.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app2.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app3.Feature1.VarStrInner, "testvalue FEATURE1")
+        self.assertEqual(app4.Feature1.VarStrInner, "testvalue FEATURE4")
+
+    def test_register(self):
+        """Testing first appliance feature, and Field types (simple)"""
+
+        # class can be created
+        class Appliance1(dm.Appliance):
+            pass
+
+        class Feature1(dm.Feature):
+            _BoundAppliance = Appliance1
+            VarStrInner: str = "testvalue FEATURE1"
+
+        app = Appliance1(feat1=Feature1)
+        self.assertEqual(app.feat1.VarStrInner, "testvalue FEATURE1")
+
+        # check it does not leak accross instances
+
+        app = Appliance1(feat2=Feature1)
+        self.assertEqual(app.feat2.VarStrInner, "testvalue FEATURE1")
+
+        with self.assertRaises(AttributeError):
+            app.feat1
+
+    def test_register_notbound(self):
+        """Testing first appliance feature, and Field types (simple)"""
+
+        # class can be created
+        class Appliance1(dm.Appliance):
+            pass
+
+        class Feature1(dm.Feature):
+            VarStrInner: str = "testvalue FEATURE1"
+
+        with self.assertRaises(dm.FeatureNotBound):
+            Appliance1(feat1=Feature1)
+
+    def test_register_defect(self):
+
+        class Feature1(dm.Feature):
+            pass
+
+        with self.assertRaises(dm.FeatureNotBound):
+            Feature1()
+
+    def test_new_field_forbidden(self):
+        class App(dm.Appliance):
+            x: int = 1
+
+        app = App()
+        with self.assertRaises(dm.NewFieldForbidden):
+            app.y = 2
+
+    def test_inherit_declared(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        class MyF1(App.F1):
+            val = 2
+            val2: str = "toto"
+
+        app = App(F1=MyF1)
+        self.assertIsInstance(app.F1, MyF1)
+        self.assertEqual(app.F1.val, 2)
+        self.assertEqual(app.F1.val2, "toto")
+
+    def test_override_declared(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+                val2: str = "toto"
+
+        app = App(F1={"val": 42, "val2": "tata"})
+        self.assertEqual(app.F1.val, 42)
+        self.assertEqual(app.F1.val2, "tata")
+
+    def test_dict_override_type_error(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        # wrong type for val → must raise InvalidFieldValue
+        with self.assertRaises(dm.InvalidFieldValue):
+            App(F1={"val": "not-an-int"})
+
+    def test_dict_override_nonexisting_field(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        # field does not exist → must raise
+        with self.assertRaises(dm.InvalidFieldValue):
+            App(F1={"doesnotexist": 123})
+
+    def test_inheritance_with_extra_fields(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        class MyF1(App.F1):
+            val = 2
+            extra: str = "hello"
+
+        app = App(F1=MyF1)
+        self.assertEqual(app.F1.val, 2)
+        self.assertEqual(app.F1.extra, "hello")
+
+    def test_not_bound_runtime_attach_fails(self):
+        class App(dm.Appliance):
+            pass
+
+        class UnboundFeature(dm.Feature):
+            x: int = 1
+
+        # attaching an unbound feature should raise
+        with self.assertRaises(dm.FeatureNotBound):
+            App(Unbound=UnboundFeature)
+
+    def test_override_does_not_leak_between_instances(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        app1 = App(F1={"val": 99})
+        app2 = App()
+        self.assertEqual(app1.F1.val, 99)
+        self.assertEqual(app2.F1.val, 1)
+
+    def test_deepfreeze_nested_mixed_tuple_list(self):
+        class App(dm.Appliance):
+            data: tuple[list[int], tuple[int, list[int]]] = ([1, 2], (3, [4, 5]))
+
+        app = App()
+
+        # Top-level: must be tuple
+        self.assertIsInstance(app.data, tuple)
+
+        # First element of tuple: should have been frozen to tuple, not list
+        self.assertIsInstance(app.data[0], tuple)
+
+        # Nested second element: itself a tuple
+        self.assertIsInstance(app.data[1], tuple)
+
+        # Deepest element: inner list should also be frozen to tuple
+        self.assertIsInstance(app.data[1][1], tuple)
+
+        # Check immutability
+        with self.assertRaises(TypeError):
+            app.data[0] += (99,)  # tuples are immutable
+
+        with self.assertRaises(TypeError):
+            app.data[1][1] += (42,)  # inner tuple also immutable
+
+    def test_inacurate_type(self):
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance1(dm.Appliance):
+                SomeVar: list = []
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance2(dm.Appliance):
+                SomeVar: list[Any] = []
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance3(dm.Appliance):
+                SomeVar: list[object] = []
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance4(dm.Appliance):
+                SomeVar: dict = {}
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance5(dm.Appliance):
+                SomeVar: dict[str, Any] = {}
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance6(dm.Appliance):
+                SomeVar: dict[Any, Any] = {}
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance7(dm.Appliance):
+                SomeVar: dict[Any, str] = {}
+
+        with self.assertRaises(dm.InvalidFieldAnnotation):
+
+            class Appliance8(dm.Appliance):
+                SomeVar: dict[str, object] = {}
+
+    def test_runtime_attach_bound_success(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        class Extra(App.F1):  # stays bound to App
+            val = 7
+
+        app = App(Extra=Extra)
+        self.assertTrue(hasattr(app, "Extra"))
+        self.assertIsInstance(app.Extra, Extra)
+        self.assertEqual(app.Extra.val, 7)
+
+    def test_cant_override_inherited_annotation(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                val: int = 1
+
+        with self.assertRaises(dm.ReadOnlyFieldAnnotation):
+
+            class Extra(App.F1):
+                val: str = "test"
+
+    def test_fields_are_frozen_after_override(self):
+        class App(dm.Appliance):
+            class F(dm.Feature):
+                nums: list[int] = [1, 2]
+                tag: str = "x"
+
+        # dict override
+        app1 = App(F={"nums": [9], "tag": "y"})
+        self.assertEqual(app1.F.nums, (9,))
+        self.assertEqual(app1.F.tag, "y")
+        with self.assertRaises(AttributeError):
+            app1.F.nums.append(3)  # tuple
+
+        # subclass override
+        class F2(App.F):
+            nums = [4, 5]
+
+        app2 = App(F=F2)
+        self.assertEqual(app2.F.nums, (4, 5))
+        with self.assertRaises(dm.ReadOnlyField):
+            app2.F.nums += (6,)  # still immutable
+
+    def test_dict_partial_override_keeps_other_defaults(self):
+        class App(dm.Appliance):
+            class F(dm.Feature):
+                a: int = 1
+                b: str = "k"
+
+        app = App(F={"b": "z"})
+        self.assertEqual(app.F.a, 1)  # default remains
+        self.assertEqual(app.F.b, "z")  # overridden
+
+    def test_override_linear_chain(self):
+        # Base appliance defines Feat1
+        class A(dm.Appliance):
+            class Feat1(dm.Feature):
+                x: int = 1
+
+        # ✅ Appliance B overrides Feat1 by subclassing A.Feat1
+        class B(A):
+            class Feat1(A.Feat1):
+                y: int = 2
+
+        self.assertTrue(issubclass(B.Feat1, A.Feat1))
+
+        # ✅ Appliance C overrides Feat1 again by subclassing B.Feat1 (not A.Feat1)
+        class C(B):
+            class Feat1(B.Feat1):
+                z: int = 3
+
+        self.assertTrue(issubclass(C.Feat1, B.Feat1))
+        self.assertTrue(issubclass(C.Feat1, A.Feat1))
+
+        # ❌ Bad: D tries to override with a *fresh* Feature, not subclass of B.Feat1
+        with self.assertRaises(dm.InvalidFeatureInheritance):
+
+            class D(B):
+                class Feat1(dm.Feature):
+                    fail: str = "oops"
+
+        # ❌ Bad: E tries to override with ancestor (A.Feat1) instead of B.Feat1
+        with self.assertRaises(dm.InvalidFeatureInheritance):
+
+            class E(B):
+                class Feat1(A.Feat1):
+                    fail: str = "oops"
+
+        # ✅ New feature name in child is always fine
+        class F(B):
+            class Feat2(dm.Feature):
+                other: str = "ok"
+
+        self.assertTrue(hasattr(F, "Feat2"))
+
+    def test_override_chain_runtime_replacement(self):
+        # Build a linear chain: A -> B -> C for feature 'Feat1'
+        class A(dm.Appliance):
+            class Feat1(dm.Feature):
+                x: int = 1
+
+        class B(A):
+            class Feat1(A.Feat1):
+                y: int = 2
+
+        class C(B):
+            class Feat1(B.Feat1):
+                z: int = 3
+
+        # ✅ OK: at instantiation of C, replacing Feat1 with a subclass of the LATEST (C.Feat1)
+        class CFeat1Plus(C.Feat1):
+            w: int = 4
+
+        c_ok = C(Feat1=CFeat1Plus)
+        self.assertIsInstance(c_ok.Feat1, CFeat1Plus)
+        self.assertEqual(
+            (c_ok.Feat1.x, c_ok.Feat1.y, c_ok.Feat1.z, c_ok.Feat1.w), (1, 2, 3, 4)
+        )
+
+        # ❌ Not OK: replacing with a subclass of the ancestor (A.Feat1) — must target latest (C.Feat1)
+        class AFeat1Alt(A.Feat1):
+            pass
+
+        with self.assertRaises(dm.InvalidFieldValue):
+            C(Feat1=AFeat1Alt)
+
+        # ❌ Not OK: replacing with a subclass of the mid ancestor (B.Feat1) — still must target latest (C.Feat1)
+        class BFeat1Alt(B.Feat1):
+            pass
+
+        with self.assertRaises(dm.InvalidFieldValue):
+            C(Feat1=BFeat1Alt)
+
+    def test_inheritance_tree_and_no_leakage(self):
+        class A(dm.Appliance):
+            class F1(dm.Feature):
+                a: int = 1
+
+            class F2(dm.Feature):
+                b: int = 2
+
+        # ✅ Child inherits both features automatically
+        class B(A):
+            c: str = "extra"
+
+        b1 = B()
+        self.assertIsInstance(b1.F1, A.F1)
+        self.assertIsInstance(b1.F2, A.F2)
+        self.assertEqual((b1.F1.a, b1.F2.b, b1.c), (1, 2, "extra"))
+
+        # ✅ Override only F2, F1 should still come from A
+        class C(B):
+            class F2(B.F2):
+                bb: int = 22
+
+        c1 = C()
+        self.assertIsInstance(c1.F1, A.F1)  # unchanged
+        self.assertIsInstance(c1.F2, C.F2)  # overridden
+        self.assertEqual((c1.F1.a, c1.F2.b, c1.F2.bb), (1, 2, 22))
+
+        # ✅ No leakage: instances of B are not affected by C's override
+        b2 = B()
+        self.assertIsInstance(b2.F2, A.F2)
+        self.assertFalse(hasattr(b2.F2, "bb"))
+
+        # ✅ Adding a new feature in D is independent of previous appliances
+        class D(C):
+            class F3(dm.Feature):
+                d: int = 3
+
+        d1 = D()
+        self.assertIsInstance(d1.F1, A.F1)
+        self.assertIsInstance(d1.F2, C.F2)
+        self.assertIsInstance(d1.F3, D.F3)
+
+        # ✅ No leakage: instances of A and B should not see F3
+        a1 = A()
+        self.assertFalse(hasattr(a1, "F3"))
+        b3 = B()
+        self.assertFalse(hasattr(b3, "F3"))
+
+    def test_appliance_inheritance_tree_isolation(self):
+        class A(dm.Appliance):
+            class F1(dm.Feature):
+                a: int = 1
+
+        # Branch 1 overrides F1
+        class B(A):
+            class F1(A.F1):
+                b: int = 2
+
+        # Branch 2 also overrides F1 differently
+        class C(A):
+            class F1(A.F1):
+                c: int = 3
+
+        # ✅ Instances of B use B.F1
+        b = B()
+        self.assertIsInstance(b.F1, B.F1)
+        self.assertEqual((b.F1.a, b.F1.b), (1, 2))
+        self.assertFalse(hasattr(b.F1, "c"))
+
+        # ✅ Instances of C use C.F1
+        c = C()
+        self.assertIsInstance(c.F1, C.F1)
+        self.assertEqual((c.F1.a, c.F1.c), (1, 3))
+        self.assertFalse(hasattr(c.F1, "b"))
+
+        # ✅ Base appliance A still uses its original feature
+        a = A()
+        self.assertIsInstance(a.F1, A.F1)
+        self.assertEqual(a.F1.a, 1)
+        self.assertFalse(hasattr(a.F1, "b"))
+        self.assertFalse(hasattr(a.F1, "c"))
+
+        # ✅ No leakage: B's override doesn't affect C and vice versa
+        b2 = B()
+        c2 = C()
+        self.assertTrue(hasattr(b2.F1, "b"))
+        self.assertFalse(hasattr(b2.F1, "c"))
+        self.assertTrue(hasattr(c2.F1, "c"))
+        self.assertFalse(hasattr(c2.F1, "b"))
+
+    def test_appliance_inheritance_tree_runtime_attach_isolation(self):
+        class A(dm.Appliance):
+            class F1(dm.Feature):
+                a: int = 1
+
+        class B(A):
+            class F1(A.F1):
+                b: int = 2
+
+        class C(A):
+            class F1(A.F1):
+                c: int = 3
+
+        # Define new runtime-attachable features
+        class FextraB(B.F1):
+            xb: int = 99
+
+        class FextraC(C.F1):
+            xc: int = -99
+
+        # ✅ Attach to B at instantiation
+        b = B(F1=FextraB)
+        self.assertIsInstance(b.F1, FextraB)
+        self.assertEqual((b.F1.a, b.F1.b, b.F1.xb), (1, 2, 99))
+        self.assertFalse(hasattr(b.F1, "c"))
+        self.assertFalse(hasattr(b.F1, "xc"))
+
+        # ✅ Attach to C at instantiation
+        c = C(F1=FextraC)
+        self.assertIsInstance(c.F1, FextraC)
+        self.assertEqual((c.F1.a, c.F1.c, c.F1.xc), (1, 3, -99))
+        self.assertFalse(hasattr(c.F1, "b"))
+        self.assertFalse(hasattr(c.F1, "xb"))
+
+        # ✅ Base appliance still untouched
+        a = A()
+        self.assertIsInstance(a.F1, A.F1)
+        self.assertEqual(a.F1.a, 1)
+        self.assertFalse(hasattr(a.F1, "b"))
+        self.assertFalse(hasattr(a.F1, "c"))
+        self.assertFalse(hasattr(a.F1, "xb"))
+        self.assertFalse(hasattr(a.F1, "xc"))
+
+        # ✅ Repeated instantiations stay isolated
+        b2 = B()
+        c2 = C()
+        self.assertIsInstance(b2.F1, B.F1)
+        self.assertIsInstance(c2.F1, C.F1)
+        self.assertFalse(hasattr(b2.F1, "xb"))
+        self.assertFalse(hasattr(c2.F1, "xc"))
+
+    def test_feature_dict_override_with_nested_containers(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                values: list[int] = [1, 2]
+
+        app = App(F1={"values": [5, 6]})
+        self.assertEqual(app.F1.values, (5, 6))  # deepfreeze → tuple
+
+        # Invalid type in list should fail
+        with self.assertRaises(dm.InvalidFieldValue):
+            App(F1={"values": [1, "oops"]})
+
+    def test_dict_override_with_unknown_key(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                a: int = 1
+
+        # Dict override with unknown field 'zzz'
+        with self.assertRaises(dm.InvalidFieldValue):
+            App(F1={"zzz": 42})
+
+    def test_schema_isolation_across_multiple_overrides(self):
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                a: int = 1
+
+        class F1a(App.F1):
+            a = 10
+
+        class F1b(App.F1):
+            a = 20
+
+        app1 = App(F1=F1a)
+        self.assertIsInstance(app1.F1, F1a)
+        self.assertEqual(app1.F1.a, 10)
+
+        app2 = App(F1=F1b)
+        self.assertIsInstance(app2.F1, F1b)
+        self.assertEqual(app2.F1.a, 20)
+
+        # Original appliance schema must not be polluted
+        app3 = App()
+        self.assertIsInstance(app3.F1, App.F1)
+        self.assertEqual(app3.F1.a, 1)
+
+    def test_inheritance_with_annotated_fields(self):
+
+        class App(dm.Appliance):
+            class F1(dm.Feature):
+                a: Annotated[int, dm.LAMFieldInfo(doc="field a")] = 1
+
+        # ✅ Subclass override must inherit from parent F1
+        class F1Ex(App.F1):
+            b: str = "ok"
+
+        app = App(F1=F1Ex)
+        self.assertIsInstance(app.F1, F1Ex)
+        self.assertEqual((app.F1.a, app.F1.b), (1, "ok"))
+
+        # ❌ Wrong: fresh Feature under same name
+        with self.assertRaises(dm.InvalidFeatureInheritance):
+
+            class Bad(App):
+                class F1(dm.Feature):
+                    fail: str = "oops"
+
+
+# ---------- main ----------
+
+if __name__ == "__main__":
+    unittest.main()

test/test_model.py

@@ -1,903 +0,0 @@
-# dabmodel (c) by chacha
-#
-# dabmodel  is licensed under a
-# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
-#
-# You should have received a copy of the license along with this
-# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
-
-import unittest
-
-import sys
-import subprocess
-from os import chdir, environ
-from pathlib import Path
-import textwrap
-from typing import List, Optional, Dict, Union, Tuple, Set, FrozenSet, TypeVar, Generic, Any, Annotated
-from pprint import pprint
-
-print(__name__)
-print(__package__)
-
-from src import dabmodel as dm
-
-
-testdir_path = Path(__file__).parent.resolve()
-chdir(testdir_path.parent.resolve())
-
-
-class TestConfigWithoutEnabledFlag(unittest.TestCase):
-    def setUp(self):
-        print("\n->", unittest.TestCase.id(self))
-
-    def immutable_vars__test_field(self, obj: Any, name: str, default_value: Any, test_value: Any):
-        # field is not in the class
-        self.assertNotIn(name, dir(obj.__class__))
-        # field is in the object
-        self.assertIn(name, dir(obj))
-        # field is in the schema
-        self.assertIn(name, obj.__DABSchema__.keys())
-        # field is readable
-        self.assertEqual(getattr(obj, name), default_value)
-        # field is read only
-        with self.assertRaises(dm.ReadOnlyField):
-            setattr(obj, name, test_value)
-
-    def test_immutable_fields(self):
-        """Testing first appliance level, and Field types (simple)"""
-
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            StrVar: str = "default value"
-            StrVar2: str = "default value2"
-            VarInt: int = 12
-            VarInt2: int = 21
-            VarFloat: float = 12.1
-            VarFloat2: float = 21.2
-            VarComplex: complex = complex(3, 5)
-            VarComplex2: complex = complex(8, 6)
-            VarBool: bool = True
-            VarBool2: bool = False
-            VarBytes: bytes = bytes.fromhex("2Ef0 F1f2  ")
-            VarBytes2: bytes = bytes.fromhex("2ff0 F7f2  ")
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "test")
-        self.immutable_vars__test_field(app1, "StrVar2", "default value2", "test2")
-        self.immutable_vars__test_field(app1, "VarInt", 12, 13)
-        self.immutable_vars__test_field(app1, "VarInt2", 21, 22)
-        self.immutable_vars__test_field(app1, "VarFloat", 12.1, 32)
-        self.immutable_vars__test_field(app1, "VarFloat2", 21.2, 42)
-        self.immutable_vars__test_field(app1, "VarComplex", complex(3, 5), complex(1, 2))
-        self.immutable_vars__test_field(app1, "VarComplex2", complex(8, 6), complex(3, 2))
-        self.immutable_vars__test_field(app1, "VarBool", True, False)
-        self.immutable_vars__test_field(app1, "VarBool2", False, True)
-        self.immutable_vars__test_field(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("11f0 F1e2  "))
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: str = 12
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: int = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: float = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: complex = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: bool = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: bytes = "value"
-
-    def test_annotation(self):
-        """Testing first appliance level, and Field types (simple annotations)"""
-
-        # class can be created if annotation is a string
-        class Appliance1(dm.BaseAppliance):
-            StrVar: "str" = "default value"
-            StrVar2: "str" = "default value2"
-            VarInt: "int" = 12
-            VarInt2: "int" = 21
-            VarFloat: "float" = 12.1
-            VarFloat2: "float" = 21.2
-            VarComplex: "complex" = complex(3, 5)
-            VarComplex2: "complex" = complex(8, 6)
-            VarBool: "bool" = True
-            VarBool2: "bool" = False
-            VarBytes: "bytes" = bytes.fromhex("2Ef0 F1f2  ")
-            VarBytes2: "bytes" = bytes.fromhex("2ff0 F7f2  ")
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "test")
-        self.immutable_vars__test_field(app1, "StrVar2", "default value2", "test2")
-        self.immutable_vars__test_field(app1, "VarInt", 12, 13)
-        self.immutable_vars__test_field(app1, "VarInt2", 21, 22)
-        self.immutable_vars__test_field(app1, "VarFloat", 12.1, 32)
-        self.immutable_vars__test_field(app1, "VarFloat2", 21.2, 42)
-        self.immutable_vars__test_field(app1, "VarComplex", complex(3, 5), complex(1, 2))
-        self.immutable_vars__test_field(app1, "VarComplex2", complex(8, 6), complex(3, 2))
-        self.immutable_vars__test_field(app1, "VarBool", True, False)
-        self.immutable_vars__test_field(app1, "VarBool2", False, True)
-        self.immutable_vars__test_field(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("11f0 F1e2  "))
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "str" = 12
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "int" = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "float" = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "complex" = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "bool" = "value"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "bytes" = "value"
-
-        # class cannot be created if not annotated field
-        with self.assertRaises(dm.NotAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _ = "default value"
-
-    def test_optionnal(self):
-        """Testing first appliance level, and Field types (Optionnal annotations)"""
-
-        # class can be created with Optionnal (and variant)
-        class Appliance1(dm.BaseAppliance):
-            StrVar: Optional[str] = "default value"
-            StrVar2: Optional[str]
-            StrVar3: Union[None | str] = "default value"
-            StrVar4: Union[None | str]
-            StrVar5: None | str = "default value"
-            StrVar6: None | str
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "123")
-        self.immutable_vars__test_field(app1, "StrVar2", None, "123")
-        self.immutable_vars__test_field(app1, "StrVar3", "default value", "123")
-        self.immutable_vars__test_field(app1, "StrVar4", None, "123")
-        self.immutable_vars__test_field(app1, "StrVar5", "default value", "123")
-        self.immutable_vars__test_field(app1, "StrVar6", None, "123")
-
-        # class can be created with Optionnal (and variant), as string annotation
-        class Appliance2(dm.BaseAppliance):
-            StrVar: "Optional[str]" = "default value"
-            StrVar2: "Optional[str]"
-            StrVar3: "Union[None | str]" = "default value"
-            StrVar4: "Union[None | str]"
-            StrVar5: "None | str" = "default value"
-            StrVar6: "None | str"
-
-        app2 = Appliance2()
-
-        self.immutable_vars__test_field(app2, "StrVar", "default value", "123")
-        self.immutable_vars__test_field(app2, "StrVar2", None, "123")
-        self.immutable_vars__test_field(app2, "StrVar3", "default value", "123")
-        self.immutable_vars__test_field(app2, "StrVar4", None, "123")
-        self.immutable_vars__test_field(app2, "StrVar5", "default value", "123")
-        self.immutable_vars__test_field(app2, "StrVar6", None, "123")
-
-    @unittest.skip
-    def test_containers__set(self):
-        """Testing first appliance level, and Field types (Set)"""
-
-        # class can be created with set
-        class Appliance1(dm.BaseAppliance):
-            testVar: Set[int] = {1, 2}
-            testVar2: Set[str] = {"a", "b"}
-            testVar3: Set[float] = {0.5, 0.456, 12}
-            testVar4: "Set[str]" = {"a", "c"}
-            testVar5: set[str] = {"a", "b"}
-            testVar6: "set[str]" = {"a", "b"}
-            testVar7: set[int | str] = {1, 2, "abcd", "efg"}
-
-        app1 = Appliance1()
-        self.immutable_vars__test_field(app1, "testVar", {1, 2}, {1, 5})
-        self.assertEqual(app1.testVar, {2, 1})
-        self.immutable_vars__test_field(app1, "testVar2", {"a", "b"}, {"h", "c"})
-        self.assertEqual(app1.testVar2, {"b", "a"})
-        self.immutable_vars__test_field(app1, "testVar3", {0.5, 0.456, 12}, {0.9, 0.4156, 11})
-        self.assertEqual(app1.testVar3, {0.456, 0.5, 12})
-        self.immutable_vars__test_field(app1, "testVar4", {"a", "c"}, {"h", "e"})
-        self.immutable_vars__test_field(app1, "testVar5", {"a", "b"}, {"h", "c"})
-        self.immutable_vars__test_field(app1, "testVar6", {"a", "b"}, {"h", "c"})
-        self.immutable_vars__test_field(app1, "testVar7", {1, 2, "abcd", "efg"}, {"h", "c"})
-
-        # must work
-        sorted(app1.testVar)
-
-        with self.assertRaises(AttributeError):
-            app1.testVar.add(3)
-
-        with self.assertRaises(AttributeError):
-            app1.testVar4.add("coucou")
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: Set[int] = {"a"}
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "Set[int]" = {"a"}
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: Set = {1, 2}
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: "Set" = {1, 2}
-
-        # Hacky part !
-        # set() are randomly ordered, and typeguard can be configured to only check 1st element of containers.
-        # we need to make sure it is properly configured, so we are expecting it to detect wrong type at any element
-        # this is why we need to run the code multiple time with a new interpreter that will use a different random seed
-        code = textwrap.dedent(
-            r"""
-        from src import dabmodel as dm
-        from typing import Set
-        try:
-            class Yours(dm.BaseAppliance):
-                My1: Set[int] = {99, 1, 3, "a", 5,6}
-        except dm.InvalidFieldValue as ex:
-            raise SystemExit(2)
-        raise SystemExit(0)
-        
-            """
-        )
-
-        for i in range(15):
-            env = environ.copy()
-            env["PYTHONHASHSEED"] = str(i)
-            res = subprocess.run([sys.executable, "-c", code], env=env)
-            self.assertEqual(res.returncode, 2)
-
-    @unittest.skip
-    def test_containers__frozenset(self):
-        """Testing first appliance level, and Field types (FrozenSet)"""
-
-        # class can be created with set
-        class Appliance1(dm.BaseAppliance):
-            testVar: frozenset[int] = frozenset({1, 2})
-            testVar2: frozenset[str] = frozenset({"a", "b"})
-            testVar3: frozenset[float] = frozenset({0.5, 0.456, 12})
-            testVar4: "frozenset[str]" = frozenset({"a", "c"})
-            testVar5: FrozenSet[int] = frozenset({1, 2})
-            testVar6: "FrozenSet[int]" = frozenset({1, 2})
-            testVar7: FrozenSet[int | str] = frozenset({1, 2, "abcd", "efg"})
-
-        app1 = Appliance1()
-        self.immutable_vars__test_field(app1, "testVar", {1, 2}, {1, 5})
-        self.assertEqual(app1.testVar, {2, 1})
-        self.immutable_vars__test_field(app1, "testVar2", {"a", "b"}, {"h", "c"})
-        self.assertEqual(app1.testVar2, {"b", "a"})
-        self.immutable_vars__test_field(app1, "testVar3", {0.5, 0.456, 12}, {0.9, 0.4156, 11})
-        self.assertEqual(app1.testVar3, {0.456, 0.5, 12})
-        self.immutable_vars__test_field(app1, "testVar4", {"a", "c"}, {"h", "e"})
-        self.immutable_vars__test_field(app1, "testVar5", {1, 2}, {1, 5})
-        self.immutable_vars__test_field(app1, "testVar6", {1, 2}, {1, 5})
-        self.immutable_vars__test_field(app1, "testVar7", {1, 2, "abcd", "efg"}, {1, 5})
-
-        # must work
-        sorted(app1.testVar)
-
-        with self.assertRaises(AttributeError):
-            app1.testVar.add(3)
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: FrozenSet[int] = {"a"}
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "FrozenSet[int]" = {"a"}
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: FrozenSet = {1, 2}
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: "FrozenSet" = {1, 2}
-
-        # Hacky part !
-        # set() are randomly ordered, and typeguard can be configured to only check 1st element of containers.
-        # we need to make sure it is properly configured, so we are expecting it to detect wrong type at any element
-        # this is why we need to run the code multiple time with a new interpreter that will use a different random seed
-        code = textwrap.dedent(
-            r"""
-        from src import dabmodel as dm
-        from typing import FrozenSet
-        try:
-            class Yours(dm.BaseAppliance):
-                My1: FrozenSet[int] = frozenset({99, 1, 3, "a", 5,6})
-        except dm.InvalidFieldValue as ex:
-            raise SystemExit(2)
-        raise SystemExit(0)
-        
-            """
-        )
-
-        for i in range(15):
-            env = environ.copy()
-            env["PYTHONHASHSEED"] = str(i)
-            res = subprocess.run([sys.executable, "-c", code], env=env)
-            self.assertEqual(res.returncode, 2)
-
-    def test_containers__list(self):
-        """Testing first appliance level, and Field types (List)"""
-
-        # class can be created with list
-        class Appliance1(dm.BaseAppliance):
-            testVar: List[int] = [1, 2]
-            testVar2: List[str] = ["a", "b"]
-            testVar3: List[float] = [0.5, 0.456, 12]
-            testVar4: "List[str]" = ["a", "c"]
-            testVar5: list[str] = ["a", "b"]
-            testVar6: "list[str]" = ["a", "b"]
-            testVar7: List[Union[int, str]] = [1, 2, 3, "one", "two", "three"]
-
-        app1 = Appliance1()
-        # Note: lists are converted to tuples
-        self.immutable_vars__test_field(app1, "testVar", (1, 2), [1, 5])
-        self.immutable_vars__test_field(app1, "testVar2", ("a", "b"), ["h", "c"])
-        self.immutable_vars__test_field(app1, "testVar3", (0.5, 0.456, 12), [0.9, 0.4156, 11])
-        self.immutable_vars__test_field(app1, "testVar4", ("a", "c"), ["h", "e"])
-        self.immutable_vars__test_field(app1, "testVar5", ("a", "b"), ["h", "c"])
-        self.immutable_vars__test_field(app1, "testVar6", ("a", "b"), ["h", "c"])
-        self.immutable_vars__test_field(app1, "testVar7", (1, 2, 3, "one", "two", "three"), ["h", "c"])
-
-        # must work
-        sorted(app1.testVar)
-
-        with self.assertRaises(AttributeError):
-            app1.testVar.append(3)
-
-        with self.assertRaises(AttributeError):
-            app1.testVar.pop()
-
-        with self.assertRaises(AttributeError):
-            app1.testVar.sort()
-
-        with self.assertRaises(AttributeError):
-            app1.testVar4.append("coucou")
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: List[int] = ["a"]
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "List[int]" = ["a"]
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: List = [1, 2]
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: "List" = [1, 2]
-
-    def test_containers__dict(self):
-        """Testing first appliance level, and Field types (Dict)"""
-
-        # class can be created with dict
-        class Appliance1(dm.BaseAppliance):
-            testVar: Dict[int, str] = {1: "a", 2: "b"}
-            testVar2: "Dict[int, str]" = {1: "c", 99: "d"}
-
-        app1 = Appliance1()
-        self.immutable_vars__test_field(app1, "testVar", {1: "a", 2: "b"}, {1: "", 99: "i"})
-        self.immutable_vars__test_field(app1, "testVar2", {1: "c", 99: "d"}, {10: "", 50: "i"})
-
-        # TODO: wrap exception type
-        with self.assertRaises(TypeError):
-            app1.testVar[58] = "aaa"
-
-        # TODO: wrap exception type
-        with self.assertRaises(TypeError):
-            app1.testVar[1] = "ggg"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: Dict[int, str] = {1: 64, 2: "b"}
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "Dict[int, str]" = {1: 64, 2: "b"}
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: Dict = {1: 64, 2: "b"}
-
-        # annotation is parsed before the library can do anything, so the exception can only be TypeError
-        with self.assertRaises(TypeError):
-
-            class _(dm.BaseAppliance):
-                _: Dict[int] = {1: 64, 2: "b"}
-
-        # annotation is parsed before the library can do anything, so the exception can only be TypeError
-        with self.assertRaises(TypeError):
-
-            class _(dm.BaseAppliance):
-                _: "Dict[int]" = {1: 64, 2: "b"}
-
-    def test_containers__tuple(self):
-        """Testing first appliance level, and Field types (Tuple)"""
-
-        # class can be created with list
-        class Appliance1(dm.BaseAppliance):
-            testVar: Tuple[int, ...] = (1, 2)
-            testVar2: Tuple[str, ...] = ("a", "b")
-            testVar3: Tuple[float, ...] = (0.5, 0.456, 12)
-            testVar4: "Tuple[str,...]" = ("a", "c")
-            testVar5: tuple[str, ...] = ("a", "b")
-            testVar6: "tuple[str,...]" = ("a", "b")
-            testVar7: Tuple[int, str] = (1, "b")
-            # testVar7: Tuple[Union[int, str]] = (1, 2, 3, "one", "two", "three")
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "testVar", (1, 2), (1, 5))
-        self.immutable_vars__test_field(app1, "testVar2", ("a", "b"), ("h", "c"))
-        self.immutable_vars__test_field(app1, "testVar3", (0.5, 0.456, 12), (0.9, 0.4156, 11))
-        self.immutable_vars__test_field(app1, "testVar4", ("a", "c"), ("h", "e"))
-        self.immutable_vars__test_field(app1, "testVar5", ("a", "b"), ("h", "c"))
-        self.immutable_vars__test_field(app1, "testVar6", ("a", "b"), ("h", "c"))
-        self.immutable_vars__test_field(app1, "testVar7", (1, "b"), (7, "h"))
-
-        # must work
-        sorted(app1.testVar)
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: Tuple[int] = "a"
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "Tuple[int]" = "a"
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: Tuple = (1, 2)
-
-        with self.assertRaises(dm.IncompletelyAnnotatedField):
-
-            class _(dm.BaseAppliance):
-                _: "Tuple" = (1, 2)
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "Tuple[int,...]" = (1, "a")
-
-        with self.assertRaises(dm.InvalidFieldValue):
-
-            class _(dm.BaseAppliance):
-                _: "tuple[int,...]" = (1, "a")
-
-    def check_immutable_fields_schema(
-        self, appliance: dm.BaseAppliance, field_name: str, expected_value: str, expected_default_value: str, expected_type: type
-    ):
-        self.assertIn(field_name, appliance.__DABSchema__)
-        self.assertIn("doc", dir(appliance.__DABSchema__[field_name]))
-        self.assertEqual(appliance.__DABSchema__[field_name].doc, "")
-        self.assertIn("annotations", dir(appliance.__DABSchema__[field_name]))
-        self.assertEqual(appliance.__DABSchema__[field_name].annotations, expected_type)
-        self.assertIn("value", dir(appliance.__DABSchema__[field_name]))
-        self.assertEqual(appliance.__DABSchema__[field_name].value, expected_value)
-        self.assertIn("default_value", dir(appliance.__DABSchema__[field_name]))
-        self.assertEqual(appliance.__DABSchema__[field_name].default_value, expected_default_value)
-        self.assertIn("constraints", dir(appliance.__DABSchema__[field_name]))
-        self.assertEqual(appliance.__DABSchema__[field_name].constraints, ())
-
-    def test_immutable_fields_schema(self):
-        """Testing first appliance level, and Field types (annotated)"""
-
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            StrVar: "str" = "default value"
-            StrVar2: "str" = "default value2"
-            VarInt: "int" = 12
-            VarInt2: "int" = 21
-            VarFloat: "float" = 12.1
-            VarFloat2: "float" = 21.2
-            VarComplex: "complex" = complex(3, 5)
-            VarComplex2: "complex" = complex(8, 6)
-            VarBool: "bool" = True
-            VarBool2: "bool" = False
-            VarBytes: "bytes" = bytes.fromhex("2Ef0 F1f2  ")
-            VarBytes2: "bytes" = bytes.fromhex("2ff0 F7f2  ")
-
-        app1 = Appliance1()
-
-        self.assertIn("__DABSchema__", dir(app1))
-        self.assertIn("__DABSchema__", app1.__dict__)
-
-        self.check_immutable_fields_schema(app1, "StrVar", "default value", "default value", str)
-        self.check_immutable_fields_schema(app1, "StrVar2", "default value2", "default value2", str)
-        self.check_immutable_fields_schema(app1, "VarInt", 12, 12, int)
-        self.check_immutable_fields_schema(app1, "VarInt2", 21, 21, int)
-        self.check_immutable_fields_schema(app1, "VarFloat", 12.1, 12.1, float)
-        self.check_immutable_fields_schema(app1, "VarFloat2", 21.2, 21.2, float)
-        self.check_immutable_fields_schema(app1, "VarComplex", complex(3, 5), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app1, "VarComplex2", complex(8, 6), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app1, "VarBool", True, True, bool)
-        self.check_immutable_fields_schema(app1, "VarBool2", False, False, bool)
-        self.check_immutable_fields_schema(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-
-    def test_container_field_schema(self):
-        """Testing first appliance level, and Field types (annotated)"""
-
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            ListStr: list[str] = ["val1", "val2"]
-            ListStr2: "list[str]" = ["val3", "val4"]
-            Dict1: dict[int, float] = {1: 1.1, 4: 7.6, 91: 23.6}
-            Dict2: "dict[str, str]" = {"1": "1.1", "4": "7.6", "91": "23.6"}
-            Tuple1: "tuple[str,...]" = ("a", "c")
-            Tuple2: tuple[str, ...] = ("a", "b")
-            FrozenSet1: frozenset[int] = frozenset({1, 2})
-            FrozenSet2: "frozenset[int]" = frozenset({1, 2})
-            Set1: set[int] = set({1, 2})
-            Set2: "set[int]" = set({1, 2})
-
-        app1 = Appliance1()
-
-        self.assertIn("__DABSchema__", dir(app1))
-        self.assertIn("__DABSchema__", app1.__dict__)
-
-        self.check_immutable_fields_schema(app1, "ListStr", ("val1", "val2"), ("val1", "val2"), list[str])
-        self.check_immutable_fields_schema(app1, "ListStr2", ("val3", "val4"), ("val3", "val4"), list[str])
-        self.check_immutable_fields_schema(app1, "Dict1", {1: 1.1, 4: 7.6, 91: 23.6}, {1: 1.1, 4: 7.6, 91: 23.6}, dict[int, float])
-        self.check_immutable_fields_schema(
-            app1, "Dict2", {"1": "1.1", "4": "7.6", "91": "23.6"}, {"1": "1.1", "4": "7.6", "91": "23.6"}, dict[str, str]
-        )
-        self.check_immutable_fields_schema(app1, "Tuple1", ("a", "c"), ("a", "c"), tuple[str, ...])
-        self.check_immutable_fields_schema(app1, "Tuple2", ("a", "b"), ("a", "b"), tuple[str, ...])
-        self.check_immutable_fields_schema(app1, "FrozenSet1", frozenset({1, 2}), frozenset({1, 2}), frozenset[int])
-        self.check_immutable_fields_schema(app1, "FrozenSet2", frozenset({1, 2}), frozenset({1, 2}), frozenset[int])
-        self.check_immutable_fields_schema(app1, "Set1", frozenset({1, 2}), frozenset({1, 2}), set[int])
-        self.check_immutable_fields_schema(app1, "Set2", frozenset({1, 2}), frozenset({1, 2}), set[int])
-
-        # same test with Typing types (list -> List ...)
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            ListStr: List[str] = ["val1", "val2"]
-            ListStr2: "List[str]" = ["val3", "val4"]
-            Dict1: Dict[int, float] = {1: 1.1, 4: 7.6, 91: 23.6}
-            Dict2: "Dict[str, str]" = {"1": "1.1", "4": "7.6", "91": "23.6"}
-            Tuple1: "Tuple[str,...]" = ("a", "c")
-            Tuple2: Tuple[str, ...] = ("a", "b")
-            FrozenSet1: FrozenSet[int] = frozenset({1, 2})
-            FrozenSet2: "FrozenSet[int]" = frozenset({1, 2})
-            Set1: Set[int] = set({1, 2})
-            Set2: "Set[int]" = set({1, 2})
-
-        app1 = Appliance1()
-
-        self.assertIn("__DABSchema__", dir(app1))
-        self.assertIn("__DABSchema__", app1.__dict__)
-
-        self.check_immutable_fields_schema(app1, "ListStr", ("val1", "val2"), ("val1", "val2"), List[str])
-        self.check_immutable_fields_schema(app1, "ListStr2", ("val3", "val4"), ("val3", "val4"), List[str])
-        self.check_immutable_fields_schema(app1, "Dict1", {1: 1.1, 4: 7.6, 91: 23.6}, {1: 1.1, 4: 7.6, 91: 23.6}, Dict[int, float])
-        self.check_immutable_fields_schema(
-            app1, "Dict2", {"1": "1.1", "4": "7.6", "91": "23.6"}, {"1": "1.1", "4": "7.6", "91": "23.6"}, Dict[str, str]
-        )
-        self.check_immutable_fields_schema(app1, "Tuple1", ("a", "c"), ("a", "c"), Tuple[str, ...])
-        self.check_immutable_fields_schema(app1, "Tuple2", ("a", "b"), ("a", "b"), Tuple[str, ...])
-        self.check_immutable_fields_schema(app1, "FrozenSet1", frozenset({1, 2}), frozenset({1, 2}), FrozenSet[int])
-        self.check_immutable_fields_schema(app1, "FrozenSet2", frozenset({1, 2}), frozenset({1, 2}), FrozenSet[int])
-        self.check_immutable_fields_schema(app1, "Set1", frozenset({1, 2}), frozenset({1, 2}), Set[int])
-        self.check_immutable_fields_schema(app1, "Set2", frozenset({1, 2}), frozenset({1, 2}), Set[int])
-
-    def test_immutable_fields_annotated(self):
-        """Testing first appliance level, and Field types (annotated)"""
-
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            StrVar: Annotated[str, dm.DABFieldInfo(doc="foo1")] = "default value"
-            StrVar2: Annotated[str, dm.DABFieldInfo(doc="foo2")] = "default value2"
-            VarInt: Annotated[int, dm.DABFieldInfo(doc="foo3")] = 12
-            VarInt2: Annotated[int, dm.DABFieldInfo(doc="foo4")] = 21
-            VarFloat: Annotated[float, dm.DABFieldInfo(doc="foo5")] = 12.1
-            VarFloat2: Annotated[float, dm.DABFieldInfo(doc="foo6")] = 21.2
-            VarComplex: Annotated[complex, dm.DABFieldInfo(doc="foo7")] = complex(3, 5)
-            VarComplex2: Annotated[complex, dm.DABFieldInfo(doc="foo8")] = complex(8, 6)
-            VarBool: Annotated[bool, dm.DABFieldInfo(doc="foo9")] = True
-            VarBool2: Annotated[bool, dm.DABFieldInfo(doc="foo10")] = False
-            VarBytes: Annotated[bytes, dm.DABFieldInfo(doc="foo11")] = bytes.fromhex("2Ef0 F1f2  ")
-            VarBytes2: Annotated[bytes, dm.DABFieldInfo(doc="foo12")] = bytes.fromhex("2ff0 F7f2  ")
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "test")
-        self.assertEqual(app1.__DABSchema__["StrVar"].doc, "foo1")
-        self.immutable_vars__test_field(app1, "StrVar2", "default value2", "test2")
-        self.assertEqual(app1.__DABSchema__["StrVar2"].doc, "foo2")
-        self.immutable_vars__test_field(app1, "VarInt", 12, 13)
-        self.assertEqual(app1.__DABSchema__["VarInt"].doc, "foo3")
-        self.immutable_vars__test_field(app1, "VarInt2", 21, 22)
-        self.assertEqual(app1.__DABSchema__["VarInt2"].doc, "foo4")
-        self.immutable_vars__test_field(app1, "VarFloat", 12.1, 32)
-        self.assertEqual(app1.__DABSchema__["VarFloat"].doc, "foo5")
-        self.immutable_vars__test_field(app1, "VarFloat2", 21.2, 42)
-        self.assertEqual(app1.__DABSchema__["VarFloat2"].doc, "foo6")
-        self.immutable_vars__test_field(app1, "VarComplex", complex(3, 5), complex(1, 2))
-        self.assertEqual(app1.__DABSchema__["VarComplex"].doc, "foo7")
-        self.immutable_vars__test_field(app1, "VarComplex2", complex(8, 6), complex(3, 2))
-        self.assertEqual(app1.__DABSchema__["VarComplex2"].doc, "foo8")
-        self.immutable_vars__test_field(app1, "VarBool", True, False)
-        self.assertEqual(app1.__DABSchema__["VarBool"].doc, "foo9")
-        self.immutable_vars__test_field(app1, "VarBool2", False, True)
-        self.assertEqual(app1.__DABSchema__["VarBool2"].doc, "foo10")
-        self.immutable_vars__test_field(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.assertEqual(app1.__DABSchema__["VarBytes"].doc, "foo11")
-        self.immutable_vars__test_field(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("11f0 F1e2  "))
-        self.assertEqual(app1.__DABSchema__["VarBytes2"].doc, "foo12")
-
-        with self.assertRaises(dm.InvalidFieldAnnotation):
-
-            class _(dm.BaseAppliance):
-                _: Annotated[str, "foo2"] = "default value2"
-
-        # annotation is parsed before the library can do anything, so the exception can only be TypeError
-        with self.assertRaises(TypeError):
-
-            class _(dm.BaseAppliance):
-                _: Annotated[str] = "default value2"
-
-    def test_immutable_fields_inheritance(self):
-        """Testing first appliance level, and Field types (simple)"""
-
-        # class can be created
-        class Appliance1(dm.BaseAppliance):
-            StrVar: str = "default value"
-            StrVar2: str = "default value2"
-            VarInt: int = 12
-            VarInt2: int = 21
-            VarFloat: float = 12.1
-            VarFloat2: float = 21.2
-            VarComplex: complex = complex(3, 5)
-            VarComplex2: complex = complex(8, 6)
-            VarBool: bool = True
-            VarBool2: bool = False
-            VarBytes: bytes = bytes.fromhex("2Ef0 F1f2  ")
-            VarBytes2: bytes = bytes.fromhex("2ff0 F7f2  ")
-
-        class Appliance2(Appliance1):
-            StrVar = "moded value"
-            StrVar2 = "moded value2"
-            VarInt = 54
-            VarInt2 = 23
-            VarFloat = 2.6
-            VarFloat2 = 1.5
-            VarComplex = complex(7, 1)
-            VarComplex2 = complex(3, 0)
-            VarBool = False
-            VarBool2 = True
-            VarBytes = bytes.fromhex("21f0 e1f2  ")
-            VarBytes2 = bytes.fromhex("2df0 F672  ")
-
-        app1 = Appliance1()
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "test")
-        self.immutable_vars__test_field(app1, "StrVar2", "default value2", "test2")
-        self.immutable_vars__test_field(app1, "VarInt", 12, 13)
-        self.immutable_vars__test_field(app1, "VarInt2", 21, 22)
-        self.immutable_vars__test_field(app1, "VarFloat", 12.1, 32)
-        self.immutable_vars__test_field(app1, "VarFloat2", 21.2, 42)
-        self.immutable_vars__test_field(app1, "VarComplex", complex(3, 5), complex(1, 2))
-        self.immutable_vars__test_field(app1, "VarComplex2", complex(8, 6), complex(3, 2))
-        self.immutable_vars__test_field(app1, "VarBool", True, False)
-        self.immutable_vars__test_field(app1, "VarBool2", False, True)
-        self.immutable_vars__test_field(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("11f0 F1e2  "))
-
-        self.check_immutable_fields_schema(app1, "StrVar", "default value", "default value", str)
-        self.check_immutable_fields_schema(app1, "StrVar2", "default value2", "default value2", str)
-        self.check_immutable_fields_schema(app1, "VarInt", 12, 12, int)
-        self.check_immutable_fields_schema(app1, "VarInt2", 21, 21, int)
-        self.check_immutable_fields_schema(app1, "VarFloat", 12.1, 12.1, float)
-        self.check_immutable_fields_schema(app1, "VarFloat2", 21.2, 21.2, float)
-        self.check_immutable_fields_schema(app1, "VarComplex", complex(3, 5), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app1, "VarComplex2", complex(8, 6), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app1, "VarBool", True, True, bool)
-        self.check_immutable_fields_schema(app1, "VarBool2", False, False, bool)
-        self.check_immutable_fields_schema(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-
-        app2 = Appliance2()
-
-        self.immutable_vars__test_field(app2, "StrVar", "moded value", "test")
-        self.immutable_vars__test_field(app2, "StrVar2", "moded value2", "test2")
-        self.immutable_vars__test_field(app2, "VarInt", 54, 13)
-        self.immutable_vars__test_field(app2, "VarInt2", 23, 22)
-        self.immutable_vars__test_field(app2, "VarFloat", 2.6, 32)
-        self.immutable_vars__test_field(app2, "VarFloat2", 1.5, 42)
-        self.immutable_vars__test_field(app2, "VarComplex", complex(7, 1), complex(1, 2))
-        self.immutable_vars__test_field(app2, "VarComplex2", complex(3, 0), complex(3, 2))
-        self.immutable_vars__test_field(app2, "VarBool", False, False)
-        self.immutable_vars__test_field(app2, "VarBool2", True, True)
-        self.immutable_vars__test_field(app2, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app2, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("11f0 F1e2  "))
-
-        self.check_immutable_fields_schema(app2, "StrVar", "moded value", "default value", str)
-        self.check_immutable_fields_schema(app2, "StrVar2", "moded value2", "default value2", str)
-        self.check_immutable_fields_schema(app2, "VarInt", 54, 12, int)
-        self.check_immutable_fields_schema(app2, "VarInt2", 23, 21, int)
-        self.check_immutable_fields_schema(app2, "VarFloat", 2.6, 12.1, float)
-        self.check_immutable_fields_schema(app2, "VarFloat2", 1.5, 21.2, float)
-        self.check_immutable_fields_schema(app2, "VarComplex", complex(7, 1), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app2, "VarComplex2", complex(3, 0), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app2, "VarBool", False, True, bool)
-        self.check_immutable_fields_schema(app2, "VarBool2", True, False, bool)
-        self.check_immutable_fields_schema(app2, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app2, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-
-        class Appliance3(Appliance2):
-            NewValue: str = "newval"
-
-        self.assertNotIn("NewValue", Appliance2.__DABSchema__)
-        self.assertNotIn("NewValue", app2.__DABSchema__)
-        self.assertNotIn("NewValue", Appliance1.__DABSchema__)
-        self.assertNotIn("NewValue", app1.__DABSchema__)
-
-        app3 = Appliance3()
-        self.immutable_vars__test_field(app3, "StrVar", "moded value", "test")
-        self.immutable_vars__test_field(app3, "StrVar2", "moded value2", "test2")
-        self.immutable_vars__test_field(app3, "VarInt", 54, 13)
-        self.immutable_vars__test_field(app3, "VarInt2", 23, 22)
-        self.immutable_vars__test_field(app3, "VarFloat", 2.6, 32)
-        self.immutable_vars__test_field(app3, "VarFloat2", 1.5, 42)
-        self.immutable_vars__test_field(app3, "VarComplex", complex(7, 1), complex(1, 2))
-        self.immutable_vars__test_field(app3, "VarComplex2", complex(3, 0), complex(3, 2))
-        self.immutable_vars__test_field(app3, "VarBool", False, False)
-        self.immutable_vars__test_field(app3, "VarBool2", True, True)
-        self.immutable_vars__test_field(app3, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app3, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("11f0 F1e2  "))
-        self.immutable_vars__test_field(app3, "NewValue", "newval", "test")
-
-        self.check_immutable_fields_schema(app3, "StrVar", "moded value", "default value", str)
-        self.check_immutable_fields_schema(app3, "StrVar2", "moded value2", "default value2", str)
-        self.check_immutable_fields_schema(app3, "VarInt", 54, 12, int)
-        self.check_immutable_fields_schema(app3, "VarInt2", 23, 21, int)
-        self.check_immutable_fields_schema(app3, "VarFloat", 2.6, 12.1, float)
-        self.check_immutable_fields_schema(app3, "VarFloat2", 1.5, 21.2, float)
-        self.check_immutable_fields_schema(app3, "VarComplex", complex(7, 1), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app3, "VarComplex2", complex(3, 0), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app3, "VarBool", False, True, bool)
-        self.check_immutable_fields_schema(app3, "VarBool2", True, False, bool)
-        self.check_immutable_fields_schema(app3, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app3, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-        self.check_immutable_fields_schema(app3, "NewValue", "newval", "newval", str)
-
-        self.immutable_vars__test_field(app1, "StrVar", "default value", "test")
-        self.immutable_vars__test_field(app1, "StrVar2", "default value2", "test2")
-        self.immutable_vars__test_field(app1, "VarInt", 12, 13)
-        self.immutable_vars__test_field(app1, "VarInt2", 21, 22)
-        self.immutable_vars__test_field(app1, "VarFloat", 12.1, 32)
-        self.immutable_vars__test_field(app1, "VarFloat2", 21.2, 42)
-        self.immutable_vars__test_field(app1, "VarComplex", complex(3, 5), complex(1, 2))
-        self.immutable_vars__test_field(app1, "VarComplex2", complex(8, 6), complex(3, 2))
-        self.immutable_vars__test_field(app1, "VarBool", True, False)
-        self.immutable_vars__test_field(app1, "VarBool2", False, True)
-        self.immutable_vars__test_field(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("11f0 F1e2  "))
-
-        self.check_immutable_fields_schema(app1, "StrVar", "default value", "default value", str)
-        self.check_immutable_fields_schema(app1, "StrVar2", "default value2", "default value2", str)
-        self.check_immutable_fields_schema(app1, "VarInt", 12, 12, int)
-        self.check_immutable_fields_schema(app1, "VarInt2", 21, 21, int)
-        self.check_immutable_fields_schema(app1, "VarFloat", 12.1, 12.1, float)
-        self.check_immutable_fields_schema(app1, "VarFloat2", 21.2, 21.2, float)
-        self.check_immutable_fields_schema(app1, "VarComplex", complex(3, 5), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app1, "VarComplex2", complex(8, 6), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app1, "VarBool", True, True, bool)
-        self.check_immutable_fields_schema(app1, "VarBool2", False, False, bool)
-        self.check_immutable_fields_schema(app1, "VarBytes", bytes.fromhex("2Ef0 F1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app1, "VarBytes2", bytes.fromhex("2ff0 F7f2  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-
-        self.immutable_vars__test_field(app2, "StrVar", "moded value", "test")
-        self.immutable_vars__test_field(app2, "StrVar2", "moded value2", "test2")
-        self.immutable_vars__test_field(app2, "VarInt", 54, 13)
-        self.immutable_vars__test_field(app2, "VarInt2", 23, 22)
-        self.immutable_vars__test_field(app2, "VarFloat", 2.6, 32)
-        self.immutable_vars__test_field(app2, "VarFloat2", 1.5, 42)
-        self.immutable_vars__test_field(app2, "VarComplex", complex(7, 1), complex(1, 2))
-        self.immutable_vars__test_field(app2, "VarComplex2", complex(3, 0), complex(3, 2))
-        self.immutable_vars__test_field(app2, "VarBool", False, False)
-        self.immutable_vars__test_field(app2, "VarBool2", True, True)
-        self.immutable_vars__test_field(app2, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("11f0 F1f2  "))
-        self.immutable_vars__test_field(app2, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("11f0 F1e2  "))
-
-        self.check_immutable_fields_schema(app2, "StrVar", "moded value", "default value", str)
-        self.check_immutable_fields_schema(app2, "StrVar2", "moded value2", "default value2", str)
-        self.check_immutable_fields_schema(app2, "VarInt", 54, 12, int)
-        self.check_immutable_fields_schema(app2, "VarInt2", 23, 21, int)
-        self.check_immutable_fields_schema(app2, "VarFloat", 2.6, 12.1, float)
-        self.check_immutable_fields_schema(app2, "VarFloat2", 1.5, 21.2, float)
-        self.check_immutable_fields_schema(app2, "VarComplex", complex(7, 1), complex(3, 5), complex)
-        self.check_immutable_fields_schema(app2, "VarComplex2", complex(3, 0), complex(8, 6), complex)
-        self.check_immutable_fields_schema(app2, "VarBool", False, True, bool)
-        self.check_immutable_fields_schema(app2, "VarBool2", True, False, bool)
-        self.check_immutable_fields_schema(app2, "VarBytes", bytes.fromhex("21f0 e1f2  "), bytes.fromhex("2Ef0 F1f2  "), bytes)
-        self.check_immutable_fields_schema(app2, "VarBytes2", bytes.fromhex("2df0 F672  "), bytes.fromhex("2ff0 F7f2  "), bytes)
-
-        with self.assertRaises(dm.ReadOnlyFieldAnnotation):
-
-            class _(Appliance1):
-                StrVar: int = 12
-
-        with self.assertRaises(dm.ReadOnlyFieldAnnotation):
-
-            class _(Appliance3):
-                NewValue: int = 12
-
-        with self.assertRaises(dm.ReadOnlyFieldAnnotation):
-
-            class _(Appliance3):
-                StrVar: int = 12
-
-
-# ---------- main ----------
-
-if __name__ == "__main__":
-    unittest.main()