sysnet-persons-model 1.2.5__tar.gz → 1.2.7__tar.gz

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysnet-persons-model
-Version: 1.2.5
+Version: 1.2.7
 Summary: SYSNET Persons Data Model
 Author-email: Data Developer <info@sysnet.cz>
 License-Expression: LicenseRef-SYSNET-FreeForHomeUse
@@ -93,7 +93,7 @@ person.tags.add_tag(TagItemType(tag="aktivni", color="#00FF00"))
 |---|---|
 | `PersonEntityLinkType` | Odkaz na navázaný subjekt |
 | `PersonEntityEntryType` | Položka subjektu v kontextu |
-| `PersonEntityBaseType` | Základní atributy subjektu |
+| `PersonEntityBaseType` | Základní atributy subjektu (včetně `scope`) |
 | `PersonEntityType` | Plný záznam (fyzická / právnická osoba) |
 | `PersonEntityListType` | Stránkovaný seznam subjektů |
 

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/README.md

@@ -73,7 +73,7 @@ person.tags.add_tag(TagItemType(tag="aktivni", color="#00FF00"))
 |---|---|
 | `PersonEntityLinkType` | Odkaz na navázaný subjekt |
 | `PersonEntityEntryType` | Položka subjektu v kontextu |
-| `PersonEntityBaseType` | Základní atributy subjektu |
+| `PersonEntityBaseType` | Základní atributy subjektu (včetně `scope`) |
 | `PersonEntityType` | Plný záznam (fyzická / právnická osoba) |
 | `PersonEntityListType` | Stránkovaný seznam subjektů |
 

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/persons_model/individual.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import List, Optional
 
-from pydantic import BaseModel, Field, SecretStr, StrictBool
+from pydantic import BaseModel, Field, SecretStr, StrictBool, AliasChoices
 from sysnet_pyutils.models.general import LocationType, ListTypeBase, MetadataEssentialType
 
 from persons_model.common import ContactType, RegistryType
@@ -46,7 +46,13 @@ class IndividualType(IndividualBaseType):
     pid: Optional[str] = Field(default=None, description="identifikátor PID")
     registry: Optional[RegistryType] = Field(default=None, description="Referenční registr")
     tags: Optional[TagType] = Field(default=None, description="Seznam tagů objektu")
-    document: Optional[MetadataEssentialType] = Field(default=None, description="Metadata")
+    """Sekce metadat životního cyklu pod aliasem 'metadata' (Redmine #9850)."""
+    document: Optional[MetadataEssentialType] = Field(
+        default=None,
+        description='Metadata životního cyklu objektu (vytvoření, modifikace, smazání). Přístupné i jako alias "metadata".',
+        validation_alias=AliasChoices('document', 'metadata'),
+        serialization_alias='document',
+    )
 
 
 class IndividualListType(ListTypeBase):

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/persons_model/person_entity.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from datetime import datetime
 from typing import TYPE_CHECKING, List, Optional, Union
 
-from pydantic import BaseModel, Field, StrictBool
+from pydantic import BaseModel, Field, StrictBool, AliasChoices
 from sysnet_pyutils.models.general import LocationType, PersonTypeEnum, ListTypeBase, MetadataEssentialType
 
-from persons_model.common import RedundantType, DepartmentType, ContactType, IssuingType, RegistryType, MemberType
+from persons_model.common import RedundantType, DepartmentType, ContactType, IssuingType, RegistryType, MemberType, ScopeType
 from persons_model.legal_form import LegalFormEnum, LegalFormType, make_legal_form, person_type_from_legal_form
 from persons_model.tag import TagType
 
@@ -63,6 +63,7 @@ class PersonEntityBaseType(BaseModel):
     contacts: Optional[List[Optional[ContactType]]] = Field(default=None, description="Další kontaktní osoby")
     note: Optional[str] = Field(default=None, description="Poznámka")
     issuing: Optional[List[Optional[IssuingType]]] = Field(default=None, description="Osoba je autoritou vydávající nějaké dokumenty")
+    scope: Optional[ScopeType] = Field(default=None, description="Rozsah působnosti subjektu")
 
     def set_legal_form(self, code: Union[LegalFormEnum, str]) -> "PersonEntityBaseType":
         """Nastaví atribut legal_form podle kódu právní formy.
@@ -115,4 +116,10 @@ class PersonEntityType(PersonEntityBaseType):
     members: Optional[List[Optional[MemberType]]] = Field(default=None, description="Členové subjektu")
     linked_persons: Optional[List[Optional[PersonEntityLinkType]]] = Field(default=None, description="Vazba na jiný subjekt")
     tags: Optional[TagType] = Field(default=None, description="Seznam tagů")
-    document: Optional[MetadataEssentialType] = Field(default=None, description='Document metadata')
+    """Sekce metadat životního cyklu pod aliasem 'metadata' (Redmine #9850)."""
+    document: Optional[MetadataEssentialType] = Field(
+        default=None,
+        description='Metadata životního cyklu objektu (vytvoření, modifikace, smazání). Přístupné i jako alias "metadata".',
+        validation_alias=AliasChoices('document', 'metadata'),
+        serialization_alias='document',
+    )

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/persons_model/role.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Optional, List
 
-from pydantic import BaseModel, Field, StrictBool
+from pydantic import BaseModel, Field, StrictBool, AliasChoices
 from sysnet_pyutils.models.general import ListTypeBase, BaseEnum, MetadataEssentialType
 
 from persons_model.common import RegistryType
@@ -43,7 +43,13 @@ class RoleType(RoleBaseType):
     admins_individual: Optional[List[Optional[str]]] = Field(default=None, description="Správci role - jednotlivci")
     admins_personal: Optional[List[Optional[str]]] = Field(default=None, description="Správci role - osoby")
     tags: Optional[TagType] = Field(default=None, description="Seznam značek")
-    document: Optional[MetadataEssentialType] = Field(default=None, description='Metadata')
+    """Sekce metadat životního cyklu pod aliasem 'metadata' (Redmine #9850)."""
+    document: Optional[MetadataEssentialType] = Field(
+        default=None,
+        description='Metadata životního cyklu objektu (vytvoření, modifikace, smazání). Přístupné i jako alias "metadata".',
+        validation_alias=AliasChoices('document', 'metadata'),
+        serialization_alias='document',
+    )
 
 
 class RoleEntryType(RoleBaseType):

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sysnet-persons-model"
-version = "1.2.5"
+version = "1.2.7"
 authors = [
   { name="Data Developer", email="info@sysnet.cz" },
 ]

{sysnet_persons_model-1.2.5 → sysnet_persons_model-1.2.7}/sysnet_persons_model.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysnet-persons-model
-Version: 1.2.5
+Version: 1.2.7
 Summary: SYSNET Persons Data Model
 Author-email: Data Developer <info@sysnet.cz>
 License-Expression: LicenseRef-SYSNET-FreeForHomeUse
@@ -93,7 +93,7 @@ person.tags.add_tag(TagItemType(tag="aktivni", color="#00FF00"))
 |---|---|
 | `PersonEntityLinkType` | Odkaz na navázaný subjekt |
 | `PersonEntityEntryType` | Položka subjektu v kontextu |
-| `PersonEntityBaseType` | Základní atributy subjektu |
+| `PersonEntityBaseType` | Základní atributy subjektu (včetně `scope`) |
 | `PersonEntityType` | Plný záznam (fyzická / právnická osoba) |
 | `PersonEntityListType` | Stránkovaný seznam subjektů |
 

sysnet_persons_model-1.2.7/tests/test_person_entity.py

@@ -0,0 +1,137 @@
+import pytest
+from datetime import datetime
+from typing import List, Optional
+from pydantic import ValidationError
+from sysnet_pyutils.models.general import LocationType, PersonTypeEnum
+from persons_model.person_entity import (
+    PersonEntityLinkType,
+    PersonEntityEntryType,
+    PersonEntityListType,
+    PersonEntityBaseType,
+    PersonEntityType
+)
+from persons_model.legal_form import LegalFormEnum
+
+@pytest.fixture
+def sample_person_entity():
+    return PersonEntityEntryType(identifier="test-id", name="Sample")
+
+class TestPersonEntityLinkType:
+    def test_prazdny(self):
+        l = PersonEntityLinkType()
+        assert l.identifier is None
+        assert l.name is None
+
+    def test_s_hodnotami(self):
+        l = PersonEntityLinkType(identifier="x", name="Test", link_type="parent")
+        assert l.identifier == "x"
+        assert l.link_type == "parent"
+
+
+class TestPersonEntityEntryType:
+    def test_prazdny(self):
+        p = PersonEntityEntryType()
+        assert p.identifier is None
+        assert p.is_admin is False
+
+    def test_s_hodnotami(self):
+        p = PersonEntityEntryType(identifier="x", name="Test", is_admin=True)
+        assert p.identifier == "x"
+        assert p.is_admin == True
+
+
+class TestPersonEntityType:
+    def test_prazdny(self):
+        p = PersonEntityType()
+        assert p.identifier is None
+
+    def test_serialization(self):
+        p = PersonEntityType(identifier="x", name="Test")
+        data = p.model_dump()
+        p2 = PersonEntityType.model_validate(data)
+        assert p2.identifier == "x"
+        assert p2.name == "Test"
+
+
+class TestPersonEntityListType:
+    def test_prazdny(self):
+        lst = PersonEntityListType()
+        assert lst.hits is None
+        assert lst.entries is None
+
+    def test_s_polozkami(self):
+        entries = [
+            PersonEntityEntryType(identifier="pe1", name="Firma A"),
+            PersonEntityEntryType(identifier="pe2", name="Firma B"),
+        ]
+        lst = PersonEntityListType(hits=2, entries=entries)
+        assert lst.hits == 2
+        assert lst.entries[1].name == "Firma B"
+
+    def test_persons_list(self, sample_person_entity):
+        lst = PersonEntityListType(hits=1, entries=[sample_person_entity])
+        assert lst.hits == 1
+        assert len(lst.entries) == 1
+
+    def test_scope_in_base_type(self):
+        from persons_model.common import ScopeType, ScopeLevelEnum
+        entity = PersonEntityBaseType(
+            name="Test Subjekt",
+            scope=ScopeType(level=ScopeLevelEnum.GLOBAL)
+        )
+        assert entity.scope.level == ScopeLevelEnum.GLOBAL
+        assert entity.name == "Test Subjekt"
+
+
+class TestPersonEntityBaseTypeSetLegalForm:
+    def test_set_legal_form_z_retezce(self):
+        """set_legal_form('112') nastaví legal_form s kódem PF_112 a českým názvem."""
+        p = PersonEntityBaseType(name="ACME s.r.o.")
+        result = p.set_legal_form("112")
+        assert result is p  # vrací self
+        assert p.legal_form is not None
+        assert p.legal_form.code == LegalFormEnum.PF_112
+        assert p.legal_form.name == "Společnost s ručením omezeným"
+
+    def test_set_legal_form_z_enumu(self):
+        p = PersonEntityBaseType(name="Kraj JHC")
+        p.set_legal_form(LegalFormEnum.PF_804)
+        assert p.legal_form.code == LegalFormEnum.PF_804
+        assert p.legal_form.name == "Kraj"
+
+    def test_set_legal_form_vraci_self(self):
+        """Metoda vrací self pro method chaining."""
+        p = PersonEntityBaseType()
+        assert p.set_legal_form("112") is p
+
+    def test_neplatny_kod_vyhodi_chybu(self):
+        p = PersonEntityBaseType()
+        with pytest.raises(ValueError):
+            p.set_legal_form("999")
+
+
+class TestPersonEntityBaseTypeSetPersonTypeFromLegalForm:
+    def test_legal_entity(self):
+        p = PersonEntityBaseType()
+        p.set_legal_form("112")
+        p.set_person_type_from_legal_form()
+        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
+
+    def test_individual_entrepreneur(self):
+        p = PersonEntityBaseType()
+        # Kód 100 jako příklad
+        p.set_legal_form("100")
+        p.set_person_type_from_legal_form()
+        assert p.person_type == PersonTypeEnum.BUSINESS_NATURAL_PERSON
+
+    def test_bez_legal_form_nic_nenastavi(self):
+        p = PersonEntityBaseType(person_type=None)
+        p.set_person_type_from_legal_form()
+        assert p.person_type is None
+
+    def test_neznamy_kod_nic_nenastavi(self):
+        p = PersonEntityBaseType(person_type=None)
+        # Použijeme validní kód, ale simulujeme situaci, kdy pt je None
+        # V tomto modelu jsou všechny enums validní, takže test je spíše formální
+        p.set_person_type_from_legal_form()
+        assert p.person_type is None

sysnet_persons_model-1.2.5/tests/test_person_entity.py

@@ -1,333 +0,0 @@
-"""
-Testy pro modul persons_model.person_entity
-"""
-import pytest
-from datetime import datetime, timezone
-from sysnet_pyutils.models.general import PersonTypeEnum, LocationType
-
-from persons_model.person_entity import (
-    PersonEntityLinkType, PersonEntityEntryType,
-    PersonEntityBaseType, PersonEntityType, PersonEntityListType,
-)
-from persons_model.common import (
-    RegistryType, MemberType, MembershipEnum,
-    ContactType, IssuingType, RedundantType, DepartmentType,
-)
-from persons_model.legal_form import LegalFormType, LegalFormEnum
-from persons_model.tag import TagType, TagItemType
-
-
-class TestPersonEntityLinkType:
-    def test_prazdny(self):
-        p = PersonEntityLinkType()
-        assert p.identifier is None
-        assert p.code is None
-        assert p.name is None
-        assert p.link_type is None
-
-    def test_s_hodnotami(self):
-        p = PersonEntityLinkType(
-            identifier="pe-uuid", code="PE01",
-            name="Vazba s.r.o.", link_type="subsidiary",
-        )
-        assert p.identifier == "pe-uuid"
-        assert p.link_type == "subsidiary"
-
-
-class TestPersonEntityEntryType:
-    def test_vychozi_hodnoty(self):
-        e = PersonEntityEntryType()
-        assert e.identifier is None
-        assert e.is_admin is False
-        assert e.membership is None
-        assert e.tags is None
-        assert e.ico is None
-        assert e.headquarters is None
-
-    def test_s_hodnotami(self):
-        e = PersonEntityEntryType(
-            identifier="pe-1",
-            name="ACME s.r.o.",
-            is_admin=True,
-            membership="admin",
-        )
-        assert e.identifier == "pe-1"
-        assert e.is_admin is True
-
-    def test_ico(self):
-        """Pole ico je přítomno a správně nastaveno."""
-        e = PersonEntityEntryType(identifier="pe-2", name="Firma s.r.o.", ico="12345678")
-        assert e.ico == "12345678"
-
-    def test_ico_none(self):
-        """Pole ico je Optional — default None."""
-        e = PersonEntityEntryType(name="Fyzická osoba")
-        assert e.ico is None
-
-    def test_headquarters(self):
-        """Pole headquarters přijme LocationType."""
-        loc = LocationType(city="Praha", zip="11000")
-        e = PersonEntityEntryType(name="ACME s.r.o.", headquarters=loc)
-        assert e.headquarters is not None
-        assert e.headquarters.city == "Praha"
-        assert e.headquarters.zip == "11000"
-
-    def test_headquarters_none(self):
-        """Pole headquarters je Optional — default None."""
-        e = PersonEntityEntryType(name="Firma")
-        assert e.headquarters is None
-
-    def test_plny_entry(self):
-        """Všechna pole včetně ico a headquarters najednou."""
-        loc = LocationType(city="Brno")
-        e = PersonEntityEntryType(
-            identifier="pe-3",
-            person_type=PersonTypeEnum.LEGAL_ENTITY,
-            ico="87654321",
-            name="Beta a.s.",
-            headquarters=loc,
-            is_admin=False,
-            membership="member",
-        )
-        assert e.identifier == "pe-3"
-        assert e.person_type == PersonTypeEnum.LEGAL_ENTITY
-        assert e.ico == "87654321"
-        assert e.name == "Beta a.s."
-        assert e.headquarters.city == "Brno"
-
-    def test_serializace_ico_headquarters(self):
-        """model_dump obsahuje ico a headquarters."""
-        loc = LocationType(city="Ostrava")
-        e = PersonEntityEntryType(ico="11223344", headquarters=loc)
-        data = e.model_dump()
-        assert data["ico"] == "11223344"
-        assert data["headquarters"]["city"] == "Ostrava"
-
-    def test_deserializace_ico_headquarters(self):
-        """model_validate správně načte ico a headquarters."""
-        data = {
-            "identifier": "pe-4",
-            "ico": "99887766",
-            "name": "Gamma s.r.o.",
-            "headquarters": {"city": "Plzeň"},
-        }
-        e = PersonEntityEntryType.model_validate(data)
-        assert e.ico == "99887766"
-        assert e.headquarters.city == "Plzeň"
-
-
-class TestPersonEntityBaseType:
-    def test_prazdny(self):
-        p = PersonEntityBaseType()
-        assert p.code is None
-        assert p.ico is None
-        assert p.birthdate is None
-        assert p.name is None
-        assert p.full_name is None
-        assert p.headquarters is None
-        assert p.note is None
-        assert p.legal_form is None
-
-    def test_s_hodnotami(self):
-        p = PersonEntityBaseType(
-            code="PE001",
-            ico="12345678",
-            name="ACME s.r.o.",
-            full_name="ACME spol. s ručením omezeným",
-        )
-        assert p.code == "PE001"
-        assert p.ico == "12345678"
-
-    def test_legal_form_sro(self):
-        lf = LegalFormType(code=LegalFormEnum.PF_112, name="Společnost s ručením omezeným")
-        p = PersonEntityBaseType(name="ACME s.r.o.", legal_form=lf)
-        assert p.legal_form is not None
-        assert p.legal_form.code == LegalFormEnum.PF_112
-        assert p.legal_form.name == "Společnost s ručením omezeným"
-
-    def test_legal_form_jen_code(self):
-        p = PersonEntityBaseType(name="Kraj JHC", legal_form=LegalFormType(code=LegalFormEnum.PF_804))
-        assert p.legal_form.code == LegalFormEnum.PF_804
-        assert p.legal_form.name is None
-
-    def test_legal_form_serializace(self):
-        lf = LegalFormType(code=LegalFormEnum.PF_121, name="Akciová společnost")
-        p = PersonEntityBaseType(name="Firma a.s.", legal_form=lf)
-        data = p.model_dump()
-        assert data["legal_form"]["code"] == "121"
-        p2 = PersonEntityBaseType.model_validate(data)
-        assert p2.legal_form.code == LegalFormEnum.PF_121
-
-    def test_s_issuing(self):
-        issuing = IssuingType(code="ORG01", authority="MZe")
-        p = PersonEntityBaseType(issuing=[issuing])
-        assert len(p.issuing) == 1
-        assert p.issuing[0].authority == "MZe"
-
-
-class TestPersonEntityType:
-    def test_vychozi_hodnoty(self):
-        p = PersonEntityType()
-        assert p.identifier is None
-        assert p.pid is None
-        assert p.registry is None
-        assert p.admins is None
-        assert p.members is None
-        assert p.linked_persons is None
-        assert p.tags is None
-        assert p.document is None
-
-    def test_plny_zaznam(self):
-        reg = RegistryType(uuid="reg-uuid")
-        member = MemberType(
-            identifier="m1", name="Jan Novák",
-            membership=MembershipEnum.EMPLOYEE,
-        )
-        link = PersonEntityLinkType(identifier="pe-2", name="Dcera s.r.o.")
-        tag = TagType()
-        tag.add_tag(TagItemType(tag="aktivni"))
-        p = PersonEntityType(
-            identifier="pe-uuid",
-            pid="pid-001",
-            code="PE001",
-            name="Matka a.s.",
-            registry=reg,
-            admins=["admin-uuid"],
-            members=[member],
-            linked_persons=[link],
-            tags=tag,
-        )
-        assert p.identifier == "pe-uuid"
-        assert p.registry.identifier == "reg-uuid"
-        assert len(p.admins) == 1
-        assert len(p.members) == 1
-        assert p.members[0].membership == MembershipEnum.EMPLOYEE
-        assert len(p.linked_persons) == 1
-        assert p.tags.has_tag("aktivni") is True
-
-    def test_serializace_deserializace(self):
-        p = PersonEntityType(identifier="x", code="C1", name="Test")
-        data = p.model_dump()
-        p2 = PersonEntityType.model_validate(data)
-        assert p2.identifier == "x"
-        assert p2.name == "Test"
-
-
-class TestPersonEntityListType:
-    def test_prazdny(self):
-        lst = PersonEntityListType()
-        assert lst.hits is None
-        assert lst.entries is None
-
-    def test_s_polozkami(self):
-        entries = [
-            PersonEntityEntryType(identifier="pe1", name="Firma A"),
-            PersonEntityEntryType(identifier="pe2", name="Firma B"),
-        ]
-        lst = PersonEntityListType(hits=2, entries=entries)
-        assert lst.hits == 2
-        assert lst.entries[1].name == "Firma B"
-
-
-class TestPersonEntityBaseTypeSetLegalForm:
-    def test_set_legal_form_z_retezce(self):
-        """set_legal_form('112') nastaví legal_form s kódem PF_112 a českým názvem."""
-        p = PersonEntityBaseType(name="ACME s.r.o.")
-        result = p.set_legal_form("112")
-        assert result is p  # vrací self
-        assert p.legal_form is not None
-        assert p.legal_form.code == LegalFormEnum.PF_112
-        assert p.legal_form.name == "Společnost s ručením omezeným"
-
-    def test_set_legal_form_z_enumu(self):
-        p = PersonEntityBaseType(name="Kraj JHC")
-        p.set_legal_form(LegalFormEnum.PF_804)
-        assert p.legal_form.code == LegalFormEnum.PF_804
-        assert p.legal_form.name == "Kraj"
-
-    def test_set_legal_form_vraci_self(self):
-        """Metoda vrací self pro method chaining."""
-        p = PersonEntityBaseType()
-        assert p.set_legal_form("121") is p
-
-    def test_set_legal_form_prepise_existujici(self):
-        """Volání set_legal_form přepíše předchozí hodnotu."""
-        p = PersonEntityBaseType()
-        p.set_legal_form("112")
-        p.set_legal_form("121")
-        assert p.legal_form.code == LegalFormEnum.PF_121
-        assert p.legal_form.name == "Akciová společnost"
-
-    def test_set_legal_form_neplatny_kod(self):
-        """Neplatný kód vyhodí ValueError."""
-        p = PersonEntityBaseType()
-        with pytest.raises(ValueError):
-            p.set_legal_form("999")
-
-    def test_set_legal_form_dedeno_person_entity_type(self):
-        """Metoda funguje i na potomkovi PersonEntityType."""
-        p = PersonEntityType(name="Firma")
-        p.set_legal_form("325")
-        assert p.legal_form.code == LegalFormEnum.PF_325
-
-
-class TestPersonEntityBaseTypeSetPersonTypeFromLegalForm:
-    def test_sro_legal_entity(self):
-        """s.r.o. (112) -> LEGAL_ENTITY."""
-        p = PersonEntityBaseType(name="ACME s.r.o.")
-        p.set_legal_form("112").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
-
-    def test_as_legal_entity(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("121").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
-
-    def test_obec_legal_entity(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("801").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
-
-    def test_org_slozka_legal_entity_wo_ico(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("325").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY_WO_ICO
-
-    def test_zahranicni_po_foreign_legal_entity(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("421").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.FOREIGN_LEGAL_ENTITY
-
-    def test_fo_podnikajici_business_natural_person(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("100").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.BUSINESS_NATURAL_PERSON
-
-    def test_zahranicni_fo_foreign_natural_person(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("424").set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.FOREIGN_NATURAL_PERSON
-
-    def test_bez_legal_form_person_type_se_nezmeni(self):
-        """Bez nastaveného legal_form person_type zůstane None."""
-        p = PersonEntityBaseType()
-        p.set_person_type_from_legal_form()
-        assert p.person_type is None
-
-    def test_bez_legal_form_existujici_person_type_se_nezmeni(self):
-        """Bez nastaveného legal_form se původní person_type nepřepíše."""
-        p = PersonEntityBaseType(person_type=PersonTypeEnum.LEGAL_ENTITY)
-        p.set_person_type_from_legal_form()
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
-
-    def test_chaining_jednokrokovy(self):
-        """Řetězení set_legal_form + set_person_type_from_legal_form v jednom výrazu."""
-        p = PersonEntityBaseType(name="Spolek")
-        p.set_legal_form("706").set_person_type_from_legal_form()
-        assert p.legal_form.code == LegalFormEnum.PF_706
-        assert p.person_type == PersonTypeEnum.LEGAL_ENTITY
-
-    def test_vraci_self(self):
-        p = PersonEntityBaseType()
-        p.set_legal_form("112")
-        assert p.set_person_type_from_legal_form() is p