Index: flexoentity/__init__.py =================================================================== --- flexoentity/__init__.py (revision 95929362edb4f1170dc4e04ed3ae0c1ac0ce5e3c) +++ flexoentity/__init__.py (revision b24d72edae2d5bbe05e8b7b3a62711b85c88d649) @@ -14,5 +14,4 @@ from .flexo_entity import FlexoEntity, EntityType, EntityState from .domain import Domain -from .domain_manager import DomainManager __all__ = [ @@ -22,5 +21,4 @@ "EntityType", "Domain", - "DomainManager" "EntityState", "logger" Index: exoentity/domain_manager.py =================================================================== --- flexoentity/domain_manager.py (revision 95929362edb4f1170dc4e04ed3ae0c1ac0ce5e3c) +++ (revision ) @@ -1,94 +1,0 @@ -from typing import Dict, Optional -from flexoentity import FlexOID, EntityType, EntityState -from .domain import Domain - - -class DomainManager: - """ - I manage all Domain instances in the system. - - Responsibilities: - • ensure unique domain codes - • provide lookup by code and by FlexOID - • restore domains from dict/json safely - • serve as the canonical source of domain objects - """ - - _by_code: Dict[str, Domain] = {} - _by_oid: Dict[str, Domain] = {} - - # --------------------------------------------------------------- - # Registration - # --------------------------------------------------------------- - @classmethod - def register(cls, domain: Domain): - """Register a domain; raise error if code already exists.""" - code = domain.domain_id - oid = str(domain.flexo_id) - - if code in cls._by_code: - raise ValueError(f"Domain code already registered: {code}") - - cls._by_code[code] = domain - cls._by_oid[oid] = domain - return domain - - @classmethod - def register_or_replace(cls, domain: Domain): - """Replace an existing domain with same code — rarely useful, but optional.""" - code = domain.code - oid = str(domain.flexo_id) - cls._by_code[code] = domain - cls._by_oid[oid] = domain - return domain - - @classmethod - def get(cls, code: str) -> Domain: - """Return the domain for given code; error if missing.""" - if code not in cls._by_code: - raise KeyError(f"Unknown domain code: {code}") - return cls._by_code[code] - - # --------------------------------------------------------------- - # Lookup helpers - # --------------------------------------------------------------- - @classmethod - def get_by_oid(cls, oid) -> Domain: - """Return the domain with the given FlexOID string or object.""" - key = str(oid) - if key not in cls._by_oid: - raise KeyError(f"Unknown domain OID: {key}") - return cls._by_oid[key] - - # --------------------------------------------------------------- - # Creation helpers - # --------------------------------------------------------------- - @classmethod - def create(cls, domain_id: str, **kwargs) -> Domain: - """ - Create a new domain, register it, and return it. - Raises if code exists. - """ - flexo_id = FlexOID.safe_generate(domain_id=domain_id, - entity_type=EntityType.DOMAIN.value, - state=EntityState.DRAFT.value, text=domain_id) - domain = Domain(flexo_id=flexo_id, _in_factory=True, **kwargs) - return cls.register(domain) - - # --------------------------------------------------------------- - # Utility - # --------------------------------------------------------------- - @classmethod - def list(cls): - """Return all domain objects.""" - return list(cls._by_code.values()) - - @classmethod - def all_domain_ids(cls): - return list(cls._by_code.keys()) - - @classmethod - def clear(cls): - """Clear registry — useful for tests.""" - cls._by_code.clear() - cls._by_oid.clear() Index: flexoentity/flexo_entity.py =================================================================== --- flexoentity/flexo_entity.py (revision 95929362edb4f1170dc4e04ed3ae0c1ac0ce5e3c) +++ flexoentity/flexo_entity.py (revision b24d72edae2d5bbe05e8b7b3a62711b85c88d649) @@ -205,20 +205,20 @@ @classmethod def with_domain_id(cls, domain_id: str, **kwargs): - from .domain_manager import DomainManager + # from .domain_manager import DomainManager entity_type = getattr(cls, "ENTITY_TYPE", None) if not entity_type: raise ValueError(f"{cls.__name__} must define ENTITY_TYPE") - if entity_type == EntityType.DOMAIN: - DomainManager.create(domain_id=domain_id, - fullname=kwargs.get("fullname", ""), - description=kwargs.get("description", "")) - else: + #if entity_type == EntityType.DOMAIN: + # DomainManager.create(domain_id=domain_id, + # fullname=kwargs.get("fullname", ""), + # description=kwargs.get("description", "")) + #else: # require that this domain already exists - if domain_id not in DomainManager.all_domain_ids(): - raise ValueError( - f"Domain '{domain_id}' does not exist. " - f"Create it first via Domain.with_domain_id(...)." - ) + # if domain_id not in DomainManager.all_domain_ids(): + # raise ValueError( + # f"Domain '{domain_id}' does not exist. " + # f"Create it first via Domain.with_domain_id(...)." + # ) flexo_id = FlexOID.safe_generate( @@ -235,40 +235,18 @@ def __post_init__(self): - """ - FINAL LOGIC: - - If flexo_id exists → restore domain_id via DomainManager. - - If flexo_id missing → create via safe_generate. - - Domain must always match flexo_id.domain. - """ if not self._in_factory: raise RuntimeError( - f"{self.__class__.__name__} must be created via with_domain_id() " - f"or from_dict(), not via direct construction." + f"{self.__class__.__name__} must be created via " + f"with_domain_id() or from_dict()." ) - # Step 1: If flexo_id exists, restore canonical domain - if self.flexo_id: - return - # Step 2: flexo_id missing → generate one - entity_type = getattr(self.__class__, "ENTITY_TYPE", None) - if not entity_type: - raise ValueError(f"{self.__class__.__name__} must define ENTITY_TYPE") - - if not self.domain_id: - raise ValueError( - f"{self.__class__.__name__} created without domain; " - f"use {self.__class__.__name__}.with_domain_id(domain=...) or pass domain explicitly." + + if not self.flexo_id: + raise RuntimeError( + f"{self.__class__.__name__} created without flexo_id. " + f"Factory must assign it before __post_init__." ) - # Create identity - self.flexo_id = FlexOID.safe_generate( - domain_id=self.domain_id, - entity_type=entity_type.value, - state=EntityState.DRAFT.value, - text=self.text_seed, - version=1, - ) - - # Compute fingerprint - self.fingerprint = self._compute_fingerprint() + if not self.fingerprint: + self.fingerprint = self._compute_fingerprint() def __str__(self): @@ -282,5 +260,5 @@ return { "flexo_id": str(self.flexo_id), - "domain_id": self.domain_id, + "domain_id": self.flexo_id.domain_id, "fingerprint": self.fingerprint, "origin": self.origin, @@ -359,5 +337,4 @@ raise ValueError( f"Illegal state transition: {self.state.name} → {target_state.name}. " - f"Allowed: {', '.join([each.name for each in self.allowed_transitions()]) or 'none'}" ) @@ -434,5 +411,4 @@ raise ValueError( f"Illegal state transition: {self.state.name} → PUBLISHED. " - f"Allowed: {', '.join([each.name for each in self.allowed_transitions()]) or 'none'}" ) @@ -451,9 +427,7 @@ def obsolete(self): """I mark myself as obsolete""" - allowed = self.allowed_transitions() if EntityState.OBSOLETE not in self.allowed_transitions(): raise ValueError( f"Illegal state transition: {self.state.name} -> OBSOLETE. " - f"Allowed: {', '.join([each.name for each in self.allowed_transitions()]) or 'none'}" ) if self.state != EntityState.OBSOLETE: Index: tests/conftest.py =================================================================== --- tests/conftest.py (revision 95929362edb4f1170dc4e04ed3ae0c1ac0ce5e3c) +++ tests/conftest.py (revision b24d72edae2d5bbe05e8b7b3a62711b85c88d649) @@ -4,5 +4,5 @@ from dataclasses import dataclass, field from typing import List -from flexoentity import FlexOID, FlexoEntity, EntityType, EntityState, Domain, DomainManager +from flexoentity import FlexOID, FlexoEntity, EntityType, EntityState, Domain @pytest.fixture @@ -14,15 +14,4 @@ monkeypatch.setattr("flexoentity.id_factory.datetime", FixedDate) return FixedDate - -@pytest.fixture(autouse=True) -def reset_domain_manager(): - DomainManager.clear() # You need to implement this - yield - DomainManager.clear() - -@pytest.fixture(autouse=True) -def auto_domains(): - Domain.with_domain_id("GENERAL", fullname="General Domain") - Domain.with_domain_id("TEST", fullname="Test Domain") @dataclass Index: sts/test_domain.py =================================================================== --- tests/test_domain.py (revision 95929362edb4f1170dc4e04ed3ae0c1ac0ce5e3c) +++ (revision ) @@ -1,96 +1,0 @@ -import pytest -from uuid import UUID -from flexoentity import FlexOID, EntityType -from flexoentity.domain import Domain -from flexoentity.domain_manager import DomainManager - - -# --------------------------------------------------------------- -# Setup/Teardown (clear DomainManager between tests) -# --------------------------------------------------------------- -@pytest.fixture(autouse=True) -def clear_domain_manager(): - DomainManager.clear() - yield - DomainManager.clear() - - -# --------------------------------------------------------------- -# Domain creation + registration -# --------------------------------------------------------------- -def test_domain_creation_and_registration(): - d = DomainManager.create( - domain_id="PY_ARITHM", - fullname="Python Arithmetic", - description="Basic arithmetic operations", - classification="UNCLASSIFIED", - ) - - assert d.domain_id == "PY_ARITHM" - assert d.entity_type == EntityType.DOMAIN - assert isinstance(d.flexo_id, FlexOID) - - # Manager must know it now - assert DomainManager.get("PY_ARITHM") is d - - -# --------------------------------------------------------------- -# Uniqueness: registering the same code twice must fail -# --------------------------------------------------------------- -def test_domain_uniqueness_enforced(): - DomainManager.create("AF") - - with pytest.raises(ValueError): - DomainManager.create("AF") # duplicate code rejected - - -# --------------------------------------------------------------- -# Lookup by FlexOID -# --------------------------------------------------------------- -def test_lookup_by_oid(): - d = DomainManager.create("PY_ARITHM") - found = DomainManager.get_by_oid(d.flexo_id) - assert found is d - - -# --------------------------------------------------------------- -# JSON roundtrip should preserve identity and not regenerate FlexOID -# --------------------------------------------------------------- -def test_domain_json_roundtrip(): - orig = DomainManager.create( - domain_id="ELEKTRO_BASICS", - fullname="Elektronik Grundlagen", - ) - - data = orig.to_dict() - loaded = Domain.from_dict(data) - - # Same exact instance - assert loaded == orig - - # Same FlexOID - assert str(loaded.flexo_id) == str(orig.flexo_id) - - -# --------------------------------------------------------------- -# Loading a domain from dict that was not previously registered -# --------------------------------------------------------------- -def test_domain_restore_new_from_dict(): - d = Domain.with_domain_id( - domain_id="PY_LOOPS", - fullname="Python Loops", - classification="UNCLASSIFIED", - ) - - serialized = d.to_dict() - - # Simulate fresh startup — no domains registered - DomainManager.clear() - - restored = Domain.from_dict(serialized) - assert restored.domain_id == "PY_LOOPS" - assert str(restored.flexo_id) == str(d.flexo_id) - - # Manager must now contain it - # assert DomainManager.get("PY_LOOPS") == restored -