sdata 1.5.0__py3-none-any.whl

sdata/sclass/lazy_namespace.py

@@ -0,0 +1,155 @@
+# lazy_namespace.py
+from __future__ import annotations
+from dataclasses import dataclass
+from importlib import import_module
+from threading import RLock
+from types import ModuleType
+from typing import Any, Dict, Mapping, Tuple
+import sys
+
+Spec = str  # z.B. "sdata.suuid:SUUID" oder "pkg.mod:Outer.Inner"
+
+def _split_spec(spec: Spec) -> Tuple[str, str]:
+    """Zerlegt 'package.module:QualName' in (module, qualname)."""
+    if ":" not in spec:
+        raise ValueError(f"Ungültige Spec (':' fehlt): {spec!r}")
+    mod, qual = spec.split(":", 1)
+    if not mod or not qual:
+        raise ValueError(f"Ungültige Spec: {spec!r}")
+    return mod, qual
+
+def _resolve_attr(mod: ModuleType, qualname: str) -> Any:
+    """Auflösen von 'Outer.Inner.Class' in verschachtelten Attributen."""
+    obj: Any = mod
+    for part in qualname.split("."):
+        obj = getattr(obj, part)
+    return obj
+
+@dataclass(frozen=True)
+class ExportItem:
+    name: str          # Attributname im Package (z.B. "SUUID")
+    spec: Spec         # Ziel "mod:QualName" (z.B. "sdata.suuid:SUUID")
+
+class LazyRegistry:
+    """
+    Registry verwaltet Name->Spec und hängt sich an ein Package-Modul.
+    - __getattr__ lädt Zielklasse on-demand und cached sie ins Modul.
+    - __dir__ gibt alle dynamischen Namen zurück (IDE-Autocomplete).
+    - register() / register_many() erweitern zur Laufzeit.
+    """
+    def __init__(self, pkg_name: str):
+        self.pkg_name = pkg_name
+        self._exports: Dict[str, Spec] = {}
+        self._lock = RLock()
+        self._attached = False
+
+    # -------- öffentliche API --------
+    def attach(self) -> None:
+        """Bindet __getattr__/__dir__ ans Ziel-Package."""
+        with self._lock:
+            if self._attached:
+                return
+            pkg = self._get_pkg()
+            # bestehende __getattr__/__dir__ respektieren? (hier überschreiben)
+            def _lazy_getattr(name: str) -> Any:
+                # Fallback auf normales Attribut
+                if name not in self._exports:
+                    raise AttributeError(f"no lazy import for '{name}'")
+                spec = self._exports[name]
+                mod_name, qual = _split_spec(spec)
+                mod = import_module(mod_name)           # lazy import
+                obj = _resolve_attr(mod, qual)
+                setattr(pkg, name, obj)                 # Cache im Package
+                return obj
+
+            def _lazy_dir() -> list[str]:
+                # Kombiniere vorhandene und dynamische Namen
+                base = set(pkg.__dict__.keys())
+                return sorted(base.union(self._exports.keys()))
+
+            pkg.__getattr__ = _lazy_getattr            # PEP 562
+            pkg.__dir__ = _lazy_dir                    # für Autocomplete
+            # __all__ optional pflegen
+            all_items = set(getattr(pkg, "__all__", ()))
+            pkg.__all__ = tuple(sorted(all_items.union(self._exports.keys())))
+            self._attached = True
+
+    def register(self, name: str, spec: Spec) -> None:
+        """Fügt/überschreibt einen Export."""
+        with self._lock:
+            self._exports[name] = spec
+            if self._attached:
+                # __all__ aktualisieren
+                pkg = self._get_pkg()
+                all_items = set(getattr(pkg, "__all__", ()))
+                pkg.__all__ = tuple(sorted(all_items.union({name})))
+
+    def register_many(self, mapping: Mapping[str, Spec]) -> None:
+        with self._lock:
+            for k, v in mapping.items():
+                self._exports[k] = v
+            if self._attached:
+                pkg = self._get_pkg()
+                all_items = set(getattr(pkg, "__all__", ()))
+                pkg.__all__ = tuple(sorted(all_items.union(mapping.keys())))
+
+    def exports(self) -> Dict[str, Spec]:
+        with self._lock:
+            return dict(self._exports)
+
+    # -------- Hilfen --------
+    def _get_pkg(self) -> ModuleType:
+        try:
+            return sys.modules[self.pkg_name]
+        except KeyError as e:
+            raise RuntimeError(f"Package {self.pkg_name!r} ist nicht importiert.") from e
+
+
+# -------- Hilfsfunktionen für (De-)Serialisierung --------
+
+TYPE_FIELD = "__type__"     # z.B. "SUUID" oder "pkg.SUUID"
+SPEC_FIELD = "__spec__"     # optional absoluter "mod:QualName"-Fallback
+
+def resolve_by_string(name_or_spec: str, registry: LazyRegistry | None = None) -> type:
+    """
+    Löst entweder einen Registry-Namen (z.B. 'SUUID') ODER eine absolute Spec
+    (z.B. 'sdata.suuid:SUUID') in eine Klasse auf.
+    """
+    if ":" in name_or_spec:
+        mod, qual = _split_spec(name_or_spec)
+        return _resolve_attr(import_module(mod), qual)
+    if registry is None:
+        raise ValueError("Registry erforderlich für Kurzname ohne Modul-Spec.")
+    pkg = sys.modules[registry.pkg_name]
+    return getattr(pkg, name_or_spec)  # triggert __getattr__ → lazy import
+
+def to_json(obj: Any, type_name: str | None = None, *, include_spec: bool = False) -> dict:
+    """
+    Serialisiert ein Objekt mit Typ-Metadaten.
+    - type_name: expliziter Schlüssel in der Registry, sonst obj.__class__.__name__
+    - include_spec=True ergänzt absolute 'mod:QualName' (robuster gegen Umbenennungen).
+    """
+    cls = obj.__class__
+    payload = getattr(obj, "to_dict", lambda: obj.__dict__)()
+    meta = {TYPE_FIELD: type_name or cls.__name__}
+    if include_spec:
+        meta[SPEC_FIELD] = f"{cls.__module__}:{cls.__qualname__}"
+    return {**meta, **payload}
+
+def from_json(data: dict, registry: LazyRegistry | None = None) -> Any:
+    """
+    Rekonstruiert Objekt:
+    - bevorzugt __spec__, sonst __type__ via Registry.
+    Erwartet Klassenmethode `from_dict(d: dict)` oder init(**d).
+    """
+    if SPEC_FIELD in data:
+        cls = resolve_by_string(data[SPEC_FIELD])
+    elif TYPE_FIELD in data and registry is not None:
+        cls = resolve_by_string(data[TYPE_FIELD], registry)
+    else:
+        raise ValueError(f"Kein {TYPE_FIELD}/{SPEC_FIELD} in Daten.")
+    # Metafelder entfernen
+    clean = {k: v for k, v in data.items() if k not in (TYPE_FIELD, SPEC_FIELD)}
+    if hasattr(cls, "from_dict"):
+        return cls.from_dict(clean)
+    return cls(**clean)

sdata/sclass/process.py

@@ -0,0 +1,383 @@
+from sdata.base import sdata_factory, Base
+from sdata import generate_safe_name
+from typing import List, Dict, Any, Type, Optional, Set, Tuple
+
+
+class ProcessData(Base):
+    PROCESS_DATATYPE = 'ProcessData'
+
+    def __init__(self, **kwargs):
+        # self.default_attributes = []
+        # if "default_attributes" in kwargs:
+        #     self.default_attributes.extend(kwargs.get("default_attributes"))
+        super().__init__(**kwargs)
+        # self.set_default_attributes()
+        attributes = kwargs.get('attributes', [])
+        self.set_attributes(attributes)
+        self.metadata.add(
+            self.SDATA_TOPOLOGY_CLASS, "sdata.sclass:GenericallyDependentContinuant", dtype="str",
+            description="sdata topology class name", required=True
+        )
+
+    def set_attributes(self, attributes: List[Any]):
+        for attribute in attributes:
+            self.metadata.add(**attribute)
+
+    def is_complete(self) -> bool:
+        for attr in self.metadata.values():
+            if attr.required is True and attr.value is None:
+                return False
+        return True
+
+
+class ProcessNode(Base):
+    """
+    Basisklasse für Prozessknoten. Definiert Inputs/Outputs und prüft Vollständigkeit.
+    """
+    processes: List[Type['ProcessNode']] = []  # Class var for subprocess classes
+
+    required_inputs: List[Type[ProcessData]] = []
+    required_outputs: List[Type[ProcessData]] = []
+
+    PROCESS_DATATYPE = 'ProcessNode'
+
+    def __init__(self, name: str = "ProcessNode", inputs: Dict[str, ProcessData] = None, **kwargs: Any):
+        super().__init__(name=name, **kwargs)
+        self.metadata.add(
+            self.SDATA_TOPOLOGY_CLASS, "sdata.sclass:Process", dtype="str",
+            description="sdata topology class name", required=True
+        )
+        self.inputs: Dict[str, ProcessData] = inputs or {}
+        self.outputs: Dict[str, ProcessData] = {}
+        self.process_classes = self.__class__.processes  # Instance access to class var
+
+    @classmethod
+    def get_dependencies(cls) -> Set[str]:
+        s = {cls.__base__.__name__ + ":" + cls.__name__: {x.__base__.__name__ + ":" + x.__name__ for x in cls.required_inputs},}
+        for x in cls.required_outputs:
+            s[x.__base__.__name__ + ":" + x.__name__] = {cls.__base__.__name__ + ":" + cls.__name__, }
+        return s
+
+    def validate_inputs(self) -> bool:
+        """
+        Prüft, ob alle erforderlichen Inputs vorhanden und vollständig sind.
+        """
+        for req_input in self.required_inputs:
+            found = False
+            for inp_key, inp in self.inputs.items():
+                if isinstance(inp, req_input):
+                    if not inp.is_complete():
+                        raise ValueError(f"Input '{inp_key}' ({inp.name}) ist nicht vollständig.")
+                    found = True
+                    break
+            if not found:
+                raise ValueError(f"Fehlender erforderlicher Input: {req_input.__name__}")
+        return True
+
+class CompositeProcess(ProcessNode):
+    def __init__(self, name: str, processes: List[Type[ProcessNode]], inputs: Dict[str, ProcessData] = None, **kwargs: Any):
+        super().__init__(name=name, inputs=inputs, **kwargs)
+        self.process_classes = processes  # Store class types
+        self.input_classes: Dict[str, Type[ProcessData]] = {}
+        self.output_classes: Dict[str, Type[ProcessData]] = {}
+        self._compute_aggregated_io()
+        self.required_inputs = list(self.input_classes.values())
+        self.required_outputs = list(self.output_classes.values())
+
+    def _compute_aggregated_io(self):
+        all_inputs = set()
+        all_outputs = set()
+        internal_connections = set()
+
+        for proc_type in self.process_classes:
+            for inp in proc_type.input_classes.keys():
+                all_inputs.add(inp)
+            for out in proc_type.output_classes.keys():
+                all_outputs.add(out)
+
+        for i, proc_type in enumerate(self.process_classes):
+            for out in proc_type.output_classes.keys():
+                for next_proc_type in self.process_classes[i+1:]:
+                    if out in next_proc_type.input_classes:
+                        internal_connections.add(out)
+
+        self.external_inputs = external_inputs = all_inputs - internal_connections
+        external_outputs = all_outputs - all_inputs
+
+        for inp in external_inputs:
+            for proc_type in self.process_classes:
+                if inp in proc_type.input_classes:
+                    self.input_classes[inp] = proc_type.input_classes[inp]
+                    break
+
+        for out in external_outputs:
+            for proc_type in self.process_classes:
+                if out in proc_type.output_classes:
+                    self.output_classes[out] = proc_type.output_classes[out]
+                    break
+
+        # self.computation = " + ".join([p.computation for p in self.process_classes])
+
+    # def execute(self) -> Dict[str, ProcessData]:
+    #     if not self.validate_inputs():
+    #         raise ValueError("Inputs not valid")
+    #     intermediate = self.inputs.copy()
+    #     for proc_type in self.process_classes:
+    #         proc = proc_type(inputs={k: intermediate[k] for k in proc_type.input_classes if k in intermediate})
+    #         proc_output = proc.execute()
+    #         intermediate.update(proc_output)
+    #     self.outputs = {k: intermediate[k] for k in self.output_classes}
+    #     return self.outputs
+
+def create_process_class(
+    process_name: str,
+    input_classes: Optional[Dict[str, Type[ProcessData]]] = None,
+    output_classes: Optional[Dict[str, Type[ProcessData]]] = None,
+    processes: Optional[List[Type[ProcessNode]]] = None
+) -> Type[ProcessNode]:
+    """
+    Factory function to generically create a subclass of ProcessNode.
+
+    :param process_name: Name of the new process class (e.g., 'Process_1').
+    :param input_classes: Dict mapping input names to ProcessData subclasses (default: {}).
+    :param output_classes: Dict mapping output names to ProcessData subclasses (default: {}).
+    :param processes: List of ProcessNode subclasses (default: []).
+    :return: A new subclass of ProcessNode.
+    """
+    input_classes = input_classes if input_classes is not None else {}
+    output_classes = output_classes if output_classes is not None else {}
+    processes = processes if processes is not None else []
+    class_dict = {
+        'input_classes': input_classes,
+        'output_classes': output_classes,
+        'required_inputs': list(input_classes.values()),
+        'required_outputs': list(output_classes.values()),
+        'processes': processes
+    }
+
+    return type(process_name, (ProcessNode,), class_dict)
+
+# Factory for composite processes
+def create_composite_process_class(
+    composite_name: str,
+    process_classes: List[Type[ProcessNode]]
+) -> Type[ProcessNode]:
+    # Compute aggregated IO statically
+    all_inputs = set()
+    all_outputs = set()
+    internal_connections = set()
+
+    for proc_type in process_classes:
+        for inp in proc_type.input_classes.keys():
+            all_inputs.add(inp)
+        for out in proc_type.output_classes.keys():
+            all_outputs.add(out)
+
+    for i, proc_type in enumerate(process_classes):
+        for out in proc_type.output_classes.keys():
+            for next_proc_type in process_classes[i+1:]:
+                if out in next_proc_type.input_classes:
+                    internal_connections.add(out)
+
+    external_inputs = all_inputs - internal_connections
+    external_outputs = all_outputs - all_inputs
+
+    input_classes = {}
+    for inp in external_inputs:
+        for proc_type in process_classes:
+            if inp in proc_type.input_classes:
+                input_classes[inp] = proc_type.input_classes[inp]
+                break
+
+    output_classes = {}
+    for out in external_outputs:
+        for proc_type in process_classes:
+            if out in proc_type.output_classes:
+                output_classes[out] = proc_type.output_classes[out]
+                break
+
+    class_dict = {
+        'input_classes': input_classes,
+        'output_classes': output_classes,
+        'required_inputs': list(input_classes.values()),
+        'required_outputs': list(output_classes.values()),
+        'processes': process_classes,
+    }
+
+    return type(composite_name, (ProcessNode,), class_dict)
+
+# def create_composite_process_class2(
+#     composite_name: str,
+#     process_classes: List[Type[ProcessNode]]
+# ) -> Type[CompositeProcess]:
+#     """
+#     Factory function to generically create a subclass of CompositeProcess.
+#
+#     :param composite_name: Name of the new composite process class (e.g., 'Process_1_plus_2').
+#     :param process_classes: List of Process subclasses to include in the composite.
+#     :return: A new subclass of CompositeProcess with fixed processes.
+#     """
+#
+#     # Compute aggregated IO statically
+#     all_inputs = set()
+#     all_outputs = set()
+#     internal_connections = set()
+#
+#     for proc_type in process_classes:
+#         for inp in proc_type.input_classes.keys():
+#             all_inputs.add(inp)
+#         for out in proc_type.output_classes.keys():
+#             all_outputs.add(out)
+#
+#     for i, proc_type in enumerate(process_classes):
+#         for out in proc_type.output_classes.keys():
+#             for next_proc_type in process_classes[i+1:]:
+#                 if out in next_proc_type.input_classes:
+#                     internal_connections.add(out)
+#
+#     external_inputs = all_inputs - internal_connections
+#     external_outputs = all_outputs - all_inputs
+#
+#     input_classes = {}
+#     for inp in external_inputs:
+#         for proc_type in process_classes:
+#             if inp in proc_type.input_classes:
+#                 input_classes[inp] = proc_type.input_classes[inp]
+#                 break
+#
+#     output_classes = {}
+#     for out in external_outputs:
+#         for proc_type in process_classes:
+#             if out in proc_type.output_classes:
+#                 output_classes[out] = proc_type.output_classes[out]
+#                 break
+#
+#     computation = " + ".join([p.computation for p in process_classes]) if all(hasattr(p, 'computation') for p in process_classes) else ""
+#
+#     class_dict = {
+#         'input_classes': input_classes,
+#         'output_classes': output_classes,
+#         'required_inputs': list(input_classes.values()),
+#         'required_outputs': list(output_classes.values()),
+#         'computation': computation,
+#     }
+#
+#     class GenericComposite(CompositeProcess):
+#         def __init__(self, inputs: Dict[str, ProcessData] = None, **kwargs):
+#             super().__init__(name=composite_name, processes=process_classes, inputs=inputs, **kwargs)
+#
+#     for k, v in class_dict.items():
+#         setattr(GenericComposite, k, v)
+#
+#     GenericComposite.__name__ = composite_name
+#     return GenericComposite
+#
+# def create_composite_process_class2(
+#         composite_name: str,
+#         process_classes: List[Type[ProcessNode]]
+# ) -> Type[CompositeProcess]:
+#     """
+#     Factory function to generically create a subclass of CompositeProcess.
+#
+#     :param composite_name: Name of the new composite process class (e.g., 'Process_1_plus_2').
+#     :param process_classes: List of Process subclasses to include in the composite.
+#     :return: A new subclass of CompositeProcess with fixed processes.
+#     """
+#
+#     class GenericComposite(CompositeProcess):
+#         def __init__(self, inputs: Dict[str, ProcessData] = None, **kwargs):
+#             super().__init__(name=composite_name, processes=process_classes, inputs=inputs, **kwargs)
+#
+#     GenericComposite.__name__ = composite_name
+#     return GenericComposite
+
+
+def processdata_class_factory(
+        class_name: str,
+        sdata_class: Type = ProcessData,
+        sdata_attrs: Optional[Dict[str, Any]] = None,
+        **kwargs: Any
+) -> Any:
+    """
+    Factory function to create an instance of a dynamically generated subclass.
+
+    :param class_name: The name of the class to generate (e.g., "Material").
+    :param sdata_class: The base class to inherit from (default: Base).
+    :param sdata_attrs: Optional dict of custom attributes/methods to add to the class.
+    :param kwargs: Keyword arguments to pass to the instance initialization.
+    :return: generated ProcessData class.
+    """
+    class_name = generate_safe_name(class_name)
+    sdata_attrs = sdata_attrs or {}
+    cls = type(class_name, (sdata_class,), sdata_attrs)
+
+    def __init__(self, **init_kwargs: Any) -> None:
+        super(cls, self).__init__(**init_kwargs)  # type: ignore
+
+    setattr(cls, '__init__', __init__)
+    cls.SDATA_CLS = f"{sdata_class.__module__}.{sdata_class.__name__}"
+    return cls
+
+def sclass(class_name) -> 'Base':
+    """create class from class_name"""
+    return processdata_class_factory(class_name)
+
+def pdata(class_name) -> 'Base':
+    """create class from class_name"""
+    return processdata_class_factory(class_name)
+
+
+# Beispiel: Spezifische Subklassen
+class SpecificInput(ProcessData):
+    def __init__(self, **kwargs):
+        kwargs['default_attributes'] = [{"name": "a", "value": None, "dtype": float, "unit": "-",
+                                         "description": "my a value", "label": "$a$", "required": True},
+                                        {"name": "b", "value": None, "dtype": int,  "unit": "MPa",
+                                         "description": "my b value", "label": "$b$", "required": True},
+                                        ]
+
+        super().__init__(**kwargs)
+
+
+class SpecificOutput(ProcessData):
+    pass
+
+
+class SpecificProcessNode(ProcessNode):
+    required_inputs = [SpecificInput]  # Definiert benötigte Inputs
+    required_outputs = [SpecificOutput]  # Definiert erzeugte Outputs
+
+    def run(self) -> Dict[str, ProcessData]:
+        self.validate_inputs()  # Validation vor Run
+
+        input1 = self.inputs.get("input1")
+
+        a = input1.md.get("a").value
+        b = input1.md.get("b").value
+
+        output = SpecificOutput(name="Output1")
+
+        # Berechnung
+        output.md.add("c", a + b)
+
+        self.outputs["output1"] = output
+
+        return self.outputs
+
+
+if __name__ == '__main__':
+    input_a = SpecificInput(name="input", attributes=[{"name": "a", "value": 1.2},
+                                                      {"name": "b", "value": 3}])
+
+    # Gültiger Knoten
+    node = SpecificProcessNode(
+        name="MyNode",
+        inputs={"input1": input_a}
+    )
+    try:
+        node.validate_inputs()  # Erfolgreich
+        outputs = node.run()  # Erzeugt Outputs
+        print("Valid node ran successfully.")
+        print(node.outputs['output1'].udf)
+    except ValueError as e:
+        print(f"Valid node error: {e}")