feat: Add automatic cs.Part creation when creating a cs.Component

- Added an optional `class_` parameter to RoleTagAccessor such that
`.parts` wouldn't include `Port`s in its list due to matching role-tag
"ownedFeatures".
- Added a test case for component creation audit events.
- Also fxed `cs.Part`s name: Now these take their name from their
`.type` instead of their own `name` attribute in the XML code.

Author: ewuerger

capellambse/model/common/accessors.py

@@ -1249,18 +1249,19 @@ def __get__(self, obj, objtype=None):
         return self._make_list(obj, matches)
 
 
-class RoleTagAccessor(PhysicalAccessor):
+class RoleTagAccessor(DirectProxyAccessor[T]):
     __slots__ = ("role_tag",)
 
     def __init__(
         self,
         role_tag: str,
+        class_: type[T] | None = None,
         *,
         aslist: type[element.ElementList[T]] | None = None,
         list_extra_args: dict[str, t.Any] | None = None,
     ) -> None:
         super().__init__(
-            element.GenericElement,
+            class_ or element.GenericElement,
             (),
             aslist=aslist,
             list_extra_args=list_extra_args,
@@ -1273,12 +1274,48 @@ def __get__(self, obj, objtype=None):
             return self
 
         elts = list(obj._element.iterchildren(self.role_tag))
+        if self.class_ is not element.GenericElement:
+            xtype = build_xtype(self.class_)
+            elts = [elt for elt in elts if elt.get(helpers.ATT_XT) == xtype]
+
         rv = self._make_list(obj, elts)
         if obj._constructed:
             sys.audit("capellambse.read_attribute", obj, self.__name__, rv)
             sys.audit("capellambse.getattr", obj, self.__name__, rv)
         return rv
 
+    def create(
+        self,
+        elmlist: element.GenericElement | ElementListCouplingMixin,
+        /,
+        *type_hints: str | None,
+        **kw: t.Any,
+    ) -> T:
+        if self.aslist is None:
+            raise TypeError("Cannot create multiple of this object")
+
+        assert isinstance(elmlist, ElementListCouplingMixin)
+        assert isinstance(elmlist._parent, element.GenericElement)
+
+        if not type_hints:
+            if not self.class_:
+                raise ValueError("Need type hint for creating object")
+            type_hints = (self.class_.__name__,)
+
+        kw["_xmltag"] = self.role_tag
+        return super().create(elmlist, *type_hints, **kw)
+
+    def insert(
+        self,
+        elmlist: ElementListCouplingMixin,
+        index: int,
+        value: element.ModelObject,
+    ) -> None:
+        if self.class_:
+            assert isinstance(value, self.class_)
+        assert value._element.tag == self.role_tag
+        super().insert(elmlist, index, value)
+
 
 def no_list(
     desc: Accessor,

capellambse/model/common/element.py

@@ -199,9 +199,12 @@ def __init__(
 
         super().__init__()
         if self._xmltag is None:
-            raise TypeError(
-                f"Cannot instantiate {type(self).__name__} directly"
-            )
+            try:
+                self._xmltag = kw.pop("_xmltag")
+            except KeyError as error:
+                raise TypeError(
+                    f"Cannot instantiate {type(self).__name__} directly"
+                ) from error
         self._constructed = False
         self._model = model
         self._element: etree._Element = etree.Element(self._xmltag)

capellambse/model/crosslayer/cs.py

@@ -16,11 +16,13 @@
 import operator
 import typing as t
 
+from lxml import etree
+
 from .. import common as c
 from . import capellacommon, fa, information
 
 if t.TYPE_CHECKING:
-    pass
+    import capellambse
 
 XT_DEPLOY_LINK = (
     "org.polarsys.capella.core.data.pa.deployment:PartDeploymentLink"
@@ -36,6 +38,10 @@ class Part(c.GenericElement):
 
     deployed_parts: c.Accessor
 
+    @property
+    def name(self) -> str:  # type: ignore[override]
+        return self.type.name
+
 
 @c.xtype_handler(None)
 class ExchangeItemAllocation(c.GenericElement):
@@ -127,7 +133,9 @@ class Component(c.GenericElement):
     )
     ports = c.DirectProxyAccessor(fa.ComponentPort, aslist=c.ElementList)
     physical_ports = c.DirectProxyAccessor(PhysicalPort, aslist=c.ElementList)
-    parts = c.RoleTagAccessor("ownedFeatures", aslist=c.ElementList)
+    parts = c.RoleTagAccessor[Part](
+        "ownedFeatures", Part, aslist=c.ElementList
+    )
     representing_parts = c.ReferenceSearchingAccessor(
         Part, "type", aslist=c.ElementList
     )
@@ -144,6 +152,17 @@ class Component(c.GenericElement):
         aslist=c.ElementList,
     )
 
+    def __init__(
+        self,
+        model: capellambse.MelodyModel,
+        parent: etree._Element,
+        /,
+        **kw: t.Any,
+    ) -> None:
+        super().__init__(model, parent, **kw)
+
+        self.parent.parts.create(name=self.name, type=self)
+
 
 @c.xtype_handler(None)
 class ComponentRealization(c.GenericElement):
@@ -158,7 +177,7 @@ class ComponentPkg(c.GenericElement):
     exchanges = c.DirectProxyAccessor(
         fa.ComponentExchange, aslist=c.ElementList
     )
-    parts = c.RoleTagAccessor("ownedParts", aslist=c.ElementList)
+    parts = c.RoleTagAccessor[Part]("ownedParts", Part, aslist=c.ElementList)
     state_machines = c.DirectProxyAccessor(
         capellacommon.StateMachine, aslist=c.ElementList
     )

capellambse/model/crosslayer/information/__init__.py

@@ -116,12 +116,14 @@ class Property(c.GenericElement):
         "aggregationKind", modeltypes.AggregationKind, default="UNSET"
     )
     type = c.AttrProxyAccessor(c.GenericElement, "abstractType")
-    default_value = c.RoleTagAccessor("ownedDefaultValue")
-    min = c.RoleTagAccessor("ownedMinValue")
-    max = c.RoleTagAccessor("ownedMaxValue")
-    null_value = c.RoleTagAccessor("ownedNullValue")
-    min_card = c.RoleTagAccessor("ownedMinCard")
-    max_card = c.RoleTagAccessor("ownedMaxCard")
+    default_value = c.RoleTagAccessor[datavalue.LiteralValue](
+        "ownedDefaultValue"
+    )
+    min = c.RoleTagAccessor[datavalue.LiteralValue]("ownedMinValue")
+    max = c.RoleTagAccessor[datavalue.LiteralValue]("ownedMaxValue")
+    null_value = c.RoleTagAccessor[datavalue.LiteralValue]("ownedNullValue")
+    min_card = c.RoleTagAccessor[datavalue.LiteralValue]("ownedMinCard")
+    max_card = c.RoleTagAccessor[datavalue.LiteralValue]("ownedMaxCard")
     association = c.ReferenceSearchingAccessor(Association, "roles")
 
 

capellambse/model/crosslayer/information/datavalue.py

@@ -35,7 +35,7 @@ class ValuePart(c.GenericElement):
     referenced_property = c.AttrProxyAccessor(
         c.GenericElement, "referencedProperty"
     )
-    value = c.RoleTagAccessor("ownedValue")
+    value = c.RoleTagAccessor[LiteralValue]("ownedValue")
 
 
 @c.xtype_handler(None)

capellambse/model/layers/pa.py

@@ -84,7 +84,7 @@ def deployed_components(
     ) -> c.ElementList[PhysicalComponent]:
         items = [
             cmp.type._element
-            for part in self.parts
+            for part in self.representing_parts
             for cmp in part.deployed_parts
         ]
         return c.ElementList(self._model, items, PhysicalComponent)

tests/data/melodymodel/6_0/Melody Model Test.capella

@@ -2390,6 +2390,8 @@ The predator is far away</bodies>
             name="R. Weasley" abstractType="#ff7b8672-84db-4b93-9fea-22a410907fb1"/>
         <ownedParts xsi:type="org.polarsys.capella.core.data.cs:Part" id="249fed97-366f-4240-9e20-101cef32cda2"
             name="LogicalActor 5" abstractType="#3e0ee19f-0e3f-49d4-ae99-29bd4a3260c5"/>
+        <ownedParts xsi:type="org.polarsys.capella.core.data.cs:Part" id="b01f70e0-f8fc-4a2d-855d-cc00ebcbf39d"
+            name="Hogwarts" abstractType="#0d2edb8f-fa34-4e73-89ec-fb9a63001440"/>
         <ownedComponentExchanges xsi:type="org.polarsys.capella.core.data.fa:ComponentExchange"
             id="c0bc49e1-8043-4418-8c0a-de6c6b749eab" name="Headmaster Responsibilities"
             convoyedInformations="#408f9055-bdcf-4181-865c-db3e823bd93d" source="#fcbf6881-720c-421f-9fe9-12fc3dfefe9c"

tests/test_auditing.py

@@ -334,12 +334,12 @@ def test_attribute_assignment_fires_exactly_one_setattr_event(
     ["obj_id", "attr", "args_factory", "accessor_type"],
     [
         pytest.param(
-            "0d2edb8f-fa34-4e73-89ec-fb9a63001440",
-            "components",
+            "21bc1668-0632-4287-b126-ea9a01635c8d",
+            "functions",
             lambda m: {
-                "name": "Unfair advantages",
-                "allocated_functions": [
-                    m.by_uuid("c1a42acc-1f53-42bb-8404-77a5c08c414b")
+                "name": "New Function",
+                "functions": [
+                    m.by_uuid("edbd1ad4-31c0-4d53-b856-3ffa60e0e99b")
                 ],
             },
             common.DirectProxyAccessor,
@@ -387,3 +387,42 @@ def test_creating_objects_fires_exactly_one_create_event(
     assert ev[0] == obj
     assert ev[1] == attr
     assert ev[2] is new_obj
+
+
+def test_creating_components_fires_exactly_two_create_events(
+    model: capellambse.MelodyModel, audit_events: list[tuple[t.Any, ...]]
+) -> None:
+    obj = model.by_uuid("0d2edb8f-fa34-4e73-89ec-fb9a63001440")
+    attr = "components"
+    descriptor = getattr(type(obj), attr, None)
+    assert descriptor is not None, f"{type(obj).__name__} has no {attr}"
+    assert isinstance(
+        descriptor, common.DirectProxyAccessor
+    ), "Bad descriptor type"
+    create_args = {
+        "name": "Unfair advantages",
+        "allocated_functions": [
+            model.by_uuid("c1a42acc-1f53-42bb-8404-77a5c08c414b")
+        ],
+    }
+    target = getattr(obj, attr)
+    audit_events.clear()
+
+    with prohibit_events("capellambse.insert", "capellambse.setattr"):
+        new_obj = target.create(**create_args)
+
+    event_filter = {
+        "capellambse.create",
+        "capellambse.insert",
+        "capellambse.setattr",
+    }
+    events = [i for i in audit_events if i[0] in event_filter]
+    assert len(events) == 2
+    assert set(i[0] for i in events) == {"capellambse.create"}
+    for attr, event, new_obj in zip(
+        ("parts", attr), events, (new_obj.representing_parts[0], new_obj)
+    ):
+        _, *ev = event
+        assert ev[0] == obj
+        assert ev[1] == attr
+        assert ev[2] == new_obj

tests/test_xlayer_cs.py

@@ -1,7 +1,11 @@
 # SPDX-FileCopyrightText: Copyright DB Netz AG and the capellambse contributors
 # SPDX-License-Identifier: Apache-2.0
+import pytest
 
 from capellambse import MelodyModel
+from capellambse.model.crosslayer import cs
+
+HOGWARTS_UUID = "0d2edb8f-fa34-4e73-89ec-fb9a63001440"
 
 
 def test_PhysicalPath_has_ordered_list_of_involved_items(model: MelodyModel):
@@ -74,3 +78,45 @@ def test_PhysicalLink_setting_source_and_target(model: MelodyModel):
     assert source_pp == link.source
     assert target_pp == link.ends[1]
     assert target_pp == link.target
+
+
+def test_Component_parts(model: MelodyModel):
+    comp = model.by_uuid(HOGWARTS_UUID)
+
+    for part in comp.parts:
+        assert isinstance(part, cs.Part)
+
+
+@pytest.mark.parametrize(
+    "uuid",
+    [
+        pytest.param(HOGWARTS_UUID, id="Component"),
+        pytest.param(
+            "84c0978d-9a32-4f5b-8013-5b0b6adbfd73", id="ComponentPkg"
+        ),
+    ],
+)
+def test_component_creation_also_creates_a_part(model: MelodyModel, uuid: str):
+    name = "Test"
+    logical_parts = model.search("Part", below=model.la).by_name
+    assert name not in logical_parts, "Part already exists"  # type: ignore[operator]
+    obj = model.by_uuid(uuid)
+
+    comp = obj.components.create(name=name)
+
+    assert (part := model.search("Part", below=model.la).by_name(name))
+    assert isinstance(part, cs.Part)
+    assert part in comp.representing_parts
+    assert part.type == comp
+
+
+def test_component_modification_also_modifies_parts(model: MelodyModel):
+    name = "Test"
+
+    comp = model.by_uuid(HOGWARTS_UUID)
+    assert comp.representing_parts
+    comp.name = name
+    comp.allocated_functions.append(model.la.root_function)
+
+    assert (part := comp.representing_parts[0]).name == name
+    assert part.type.allocated_functions == comp.allocated_functions