deriva-cli 0.8.1__tar.gz → 0.8.3__tar.gz

{deriva_cli-0.8.1 → deriva_cli-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deriva-cli
-Version: 0.8.1
+Version: 0.8.3
 Summary: Deriva is a research project aimed at enabling digital architects by automating the derivation of enterprise architecture models. Deriva uses dual knowledge graphs, heuristics and LLM's.
 Keywords: archimate,enterprise-architecture,code-analysis,llm,grafeo,fastapi
 Author: S. T. Grond
@@ -35,15 +35,14 @@ Requires-Dist: tree-sitter-c-sharp>=0.23
 Requires-Dist: pypdf>=6
 Requires-Dist: python-docx>=1.2
 Requires-Dist: spacy==3.8.16
-Requires-Dist: ctranslate2==4.8.2
+Requires-Dist: ctranslate2==4.8.3
 Requires-Dist: sentencepiece==0.2.2
 Requires-Dist: solvor>=0.6.3
-Requires-Dist: backoff>=2.2.1
-Requires-Dist: pydantic-ai-slim[openai,anthropic,mistral]>=2.55
-Requires-Dist: diskcache>=5.6.3
-Requires-Dist: structlog>=26.1.0
+Requires-Dist: pydantic-ai-slim[openai,anthropic]>=2.55
+Requires-Dist: httpx2>=2.13
+Requires-Dist: lmdb>=1.6
 Requires-Dist: typer>=0.27
-Requires-Dist: httpx>=0.28.1
+Requires-Dist: tree-sitter-typescript==0.23.2
 Requires-Python: >=3.14
 Project-URL: Homepage, https://deriva.dev
 Project-URL: Documentation, https://docs.deriva.dev

{deriva_cli-0.8.1 → deriva_cli-0.8.3}/deriva/adapters/archimate/manager.py

@@ -577,6 +577,35 @@ class ArchimateManager:
             key=lambda e: str(e["identifier"]),
         )
 
+    def update_element_properties(self, updates: dict[str, dict[str, Any]]) -> int:
+        """Merge keys into the properties of elements (identifier -> keys), leaving their other keys; returns how many changed."""
+        if self.db is None:
+            raise RuntimeError("Not connected to grafeo. Call connect() first.")
+        changed = 0
+        for identifier, keys in sorted(updates.items()):
+            rows = self.db.execute(f"MATCH (e:`{self.namespace}` {{identifier: $identifier}}) RETURN e.properties AS properties", {"identifier": identifier})
+            if not rows:
+                continue
+            merged = {**(rows[0].get("properties") or {}), **keys}
+            self.db.execute_write(f"MATCH (e:`{self.namespace}` {{identifier: $identifier}}) SET e.properties = $properties", {"identifier": identifier, "properties": merged})
+            changed += 1
+        return changed
+
+    def update_relationship_properties(self, updates: dict[str, dict[str, Any]]) -> int:
+        """Merge keys into the properties of relationships (identifier -> keys), in place; returns how many changed."""
+        if self.db is None:
+            raise RuntimeError("Not connected to grafeo. Call connect() first.")
+        changed = 0
+        for identifier, keys in sorted(updates.items()):
+            match = f"MATCH (:`{self.namespace}`)-[r {{identifier: $identifier}}]->(:`{self.namespace}`)"
+            rows = self.db.execute(f"{match} RETURN r.properties AS properties", {"identifier": identifier})
+            if not rows:
+                continue
+            merged = {**(rows[0].get("properties") or {}), **keys}
+            self.db.execute_write(f"{match} SET r.properties = $properties", {"identifier": identifier, "properties": merged})
+            changed += 1
+        return changed
+
     def delete_relationship(self, identifier: str) -> bool:
         """Delete a relationship by identifier.
 

{deriva_cli-0.8.1 → deriva_cli-0.8.3}/deriva/adapters/archimate/models.py

@@ -122,6 +122,13 @@ ELEMENT_TYPES: dict[str, ElementType] = {
         aspect="Behavior",
         description="An explicitly defined exposed technology behavior",
     ),
+    # A detail-level element (the export's detail level): the deployed image or package of a component
+    "Artifact": ElementType(
+        name="Artifact",
+        layer="Technology",
+        aspect="Passive",
+        description="A piece of data that is used or produced in a software development process, or by deployment and operation of an IT system",
+    ),
 }
 
 
@@ -152,6 +159,7 @@ BEHAVIOR_ELEMENTS: set[str] = {
 PASSIVE_ELEMENTS: set[str] = {
     "DataObject",
     "BusinessObject",
+    "Artifact",
 }
 
 # All elements
@@ -178,6 +186,7 @@ TECHNOLOGY_LAYER: set[str] = {
     "Device",
     "SystemSoftware",
     "TechnologyService",
+    "Artifact",
 }
 
 
@@ -196,7 +205,7 @@ def layer_of(element_type: str) -> str:
 # ArchiMate 3.2 Relationship Table
 # =============================================================================
 # Source: ArchiMate 3.2 Specification, Appendix B.5 "Relationship Tables", restricted
-# to the 13 element types Deriva derives. The spec publishes the tables as images;
+# to the 13 element types Deriva derives plus Artifact (the export's detail level). The spec publishes the tables as images;
 # letters were read from them and cross-checked (case-insensitively, all 169 cells)
 # against Archi's relationships.xml v3.2.
 #
@@ -233,24 +242,29 @@ _TABLE_COLUMNS = (
     "Device",
     "SystemSoftware",
     "TechnologyService",
+    "Artifact",
 )
 
+# Artifact (row and column) from Archi's relationships.xml; uppercase where the spec's metamodel figures show the
+# relationship: Node, Device and SystemSoftware are assigned to an artifact, an artifact realizes an application
+# component, a data object or system software; artifacts compose, aggregate and specialize artifacts.
 # Row = source, columns in _TABLE_COLUMNS order = target.
 # fmt: off
 _TABLE_ROWS: dict[str, tuple[str, ...]] = {
-    "BusinessActor":        ("SCGvtfO", "IvtfO", "IvtfO", "IvtfO", "aO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO"),
-    "BusinessProcess":      ("vtfO", "SCGvTFO", "CGvTFO", "vTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO"),
-    "BusinessFunction":     ("vtfO", "CGvTFO", "SCGvTFO", "vTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO"),
-    "BusinessEvent":        ("vtfO", "vTFO", "vTFO", "SCGvTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO"),
-    "BusinessObject":       ("O", "O", "O", "O", "SCGO", "O", "O", "O", "O", "O", "O", "O", "O"),
-    "ApplicationComponent": ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGRvtfO", "CgrvtfO", "irvtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO"),
-    "ApplicationInterface": ("VtfO", "vtfO", "vtfO", "vtfO", "aO", "VtfO", "SCGvtfO", "IvtfO", "aO", "VtfO", "VtfO", "VtfO", "vtfO"),
-    "ApplicationService":   ("VtfO", "VtfO", "VtfO", "vtfO", "aO", "VtfO", "vtfO", "SCGvTFO", "AO", "VtfO", "VtfO", "VtfO", "vtfO"),
-    "DataObject":           ("O", "O", "O", "O", "RO", "O", "O", "O", "SCGO", "O", "O", "O", "O"),
-    "Node":                 ("ivtfO", "irvtfO", "irvtfO", "irvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGivtfO", "CGirvtfO", "CGirvtfO", "irvtfO"),
-    "Device":               ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "SCGvtfO", "CGIrvtfO", "irvtfO"),
-    "SystemSoftware":       ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "vtfO", "SCGIrvtfO", "irvtfO"),
-    "TechnologyService":    ("VtfO", "VtfO", "VtfO", "vtfO", "aO", "VtfO", "vtfO", "RvtfO", "aO", "VtfO", "VtfO", "VtfO", "SCGvTFO"),
+    "BusinessActor":        ("SCGvtfO", "IvtfO", "IvtfO", "IvtfO", "aO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessProcess":      ("vtfO", "SCGvTFO", "CGvTFO", "vTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessFunction":     ("vtfO", "CGvTFO", "SCGvTFO", "vTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessEvent":        ("vtfO", "vTFO", "vTFO", "SCGvTFO", "AO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessObject":       ("O", "O", "O", "O", "SCGO", "O", "O", "O", "O", "O", "O", "O", "O", "O"),
+    "ApplicationComponent": ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGRvtfO", "CgrvtfO", "irvtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "ApplicationInterface": ("VtfO", "vtfO", "vtfO", "vtfO", "aO", "VtfO", "SCGvtfO", "IvtfO", "aO", "VtfO", "VtfO", "VtfO", "vtfO", "aO"),
+    "ApplicationService":   ("VtfO", "VtfO", "VtfO", "vtfO", "aO", "VtfO", "vtfO", "SCGvTFO", "AO", "VtfO", "VtfO", "VtfO", "vtfO", "aO"),
+    "DataObject":           ("O", "O", "O", "O", "RO", "O", "O", "O", "SCGO", "O", "O", "O", "O", "O"),
+    "Node":                 ("ivtfO", "irvtfO", "irvtfO", "irvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGivtfO", "CGirvtfO", "CGirvtfO", "irvtfO", "aIO"),
+    "Device":               ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "SCGvtfO", "CGIrvtfO", "irvtfO", "aIO"),
+    "SystemSoftware":       ("vtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "vtfO", "SCGIrvtfO", "irvtfO", "aIO"),
+    "TechnologyService":    ("VtfO", "VtfO", "VtfO", "vtfO", "aO", "VtfO", "vtfO", "RvtfO", "aO", "VtfO", "VtfO", "VtfO", "SCGvTFO", "aO"),
+    "Artifact":             ("O", "rO", "rO", "rO", "rO", "RO", "rO", "rO", "RO", "O", "O", "RO", "rO", "SCGrO"),
 }
 # fmt: on
 

deriva_cli-0.8.3/deriva/adapters/archimate/views.py

@@ -0,0 +1,154 @@
+"""Generated views (pure): ArchiMate viewpoints per level with a deterministic band layout.
+
+Each viewpoint (ArchiMate 3.2 Specification, chapter 13) shows the elements of its types on its level (enterprise or
+solution, from the element's ``levels``) and the relationships on that level; a cross-level link is in no view. A
+detail variant shows the solution elements of its types with their detail elements (property ``level`` = detail). The layout puts the
+layers in horizontal bands (business, application, technology) and the elements of a band in a grid, ordered by
+type and name, each detail element right after its parent, so the same model gives the same view in every run.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .models import Element, Relationship, layer_of
+
+ENTERPRISE, SOLUTION, DETAIL = "enterprise", "solution", "detail"
+DEPLOYMENT = frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService"})
+# (view name, viewpoint, element types, level), in export order
+VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, str], ...] = (
+    ("Layered (enterprise)", "Layered", None, ENTERPRISE),
+    ("Application Cooperation (enterprise)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface", "ApplicationService"}), ENTERPRISE),
+    ("Information Structure (enterprise)", "Information Structure", frozenset({"BusinessObject", "DataObject"}), ENTERPRISE),
+    ("Implementation and Deployment (enterprise)", "Implementation and Deployment", DEPLOYMENT, ENTERPRISE),
+    (
+        "Business (enterprise)",
+        "Business Process Cooperation",
+        frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}),
+        ENTERPRISE,
+    ),
+    ("Application Structure (solution)", "Application Structure", frozenset({"ApplicationComponent"}), SOLUTION),
+    ("Application Cooperation (solution)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface"}), SOLUTION),
+    ("Information Structure (solution)", "Information Structure", frozenset({"DataObject"}), SOLUTION),
+    ("Implementation and Deployment (solution)", "Implementation and Deployment", DEPLOYMENT, SOLUTION),
+    ("Information Structure (detail)", "Information Structure", frozenset({"DataObject"}), DETAIL),
+    ("Implementation and Deployment (detail)", "Implementation and Deployment", DEPLOYMENT | {"Artifact"}, DETAIL),
+    # The interfaces with their members (endpoints, pages, jobs); components are left out, their members are above
+    ("Application Interfaces (detail)", "Application Cooperation", frozenset({"ApplicationInterface"}), DETAIL),
+)
+
+# A view needs an element of its anchor types (the Business view: a business element, not application services alone)
+ANCHORS = {"Business (enterprise)": frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent"})}
+BANDS = ("Business", "Application", "Technology", "Other")
+TYPE_ORDER = (
+    "BusinessActor", "BusinessFunction", "BusinessProcess", "BusinessEvent", "BusinessObject",
+    "ApplicationComponent", "ApplicationInterface", "ApplicationService", "DataObject",
+    "Node", "Device", "SystemSoftware", "TechnologyService", "Artifact",
+)  # fmt: skip
+COLUMNS, WIDTH, HEIGHT, GAP, BAND_GAP, MARGIN = 6, 160, 60, 20, 60, 20
+
+
+@dataclass(frozen=True)
+class ViewNode:
+    identifier: str
+    element: str
+    x: int
+    y: int
+    w: int = WIDTH
+    h: int = HEIGHT
+
+
+@dataclass(frozen=True)
+class ViewConnection:
+    identifier: str
+    relationship: str
+    source: str  # node identifiers
+    target: str
+
+
+@dataclass
+class View:
+    identifier: str
+    name: str
+    viewpoint: str
+    level: str = ENTERPRISE  # enterprise, solution or detail (a detail view shows the detail elements too)
+    nodes: list[ViewNode] = field(default_factory=list)
+    connections: list[ViewConnection] = field(default_factory=list)
+
+
+def _level(e: Element) -> str:
+    return str((e.properties or {}).get("level") or "architect")
+
+
+def _levels(properties: dict | None) -> frozenset[str]:
+    """The levels of an element or relationship: ``level`` detail, else ``levels`` (empty: a cross-level link), else the
+    enterprise level (a model from before the levels)."""
+    properties = properties or {}
+    if properties.get("level") == DETAIL:
+        return frozenset({DETAIL})
+    levels = properties.get("levels")
+    if isinstance(levels, list):
+        return frozenset(str(v) for v in levels)
+    return frozenset() if properties.get("cross_level") else frozenset({ENTERPRISE})
+
+
+def _on(level: str, levels: frozenset[str]) -> bool:
+    """Whether something on ``levels`` belongs in a view of ``level`` (a detail view: the solution level and the detail)."""
+    return bool(levels & ({SOLUTION, DETAIL} if level == DETAIL else {level}))
+
+
+def _order(e: Element) -> tuple[int, str, str]:
+    return (TYPE_ORDER.index(e.element_type) if e.element_type in TYPE_ORDER else len(TYPE_ORDER), e.name.casefold(), e.identifier)
+
+
+def _layout(view: View, shown: list[Element]) -> None:
+    by_parent: dict[str, list[Element]] = {}
+    for e in shown:
+        if _level(e) == "detail":
+            by_parent.setdefault(str((e.properties or {}).get("parent") or ""), []).append(e)
+    shown_ids = {e.identifier for e in shown}
+    y = MARGIN
+    for band in BANDS:
+        # One group per element type (each starts a new row), every element followed by its detail members
+        groups: dict[str, list[Element]] = {}
+        for e in sorted((e for e in shown if _level(e) != "detail" and layer_of(e.element_type) == band), key=_order):
+            groups.setdefault(e.element_type, []).append(e)
+            groups[e.element_type] += sorted(by_parent.get(e.identifier, []), key=_order)
+        # Detail elements whose parent is not in the view still get a place, after the band's own
+        orphans = (e for e in shown if _level(e) == "detail" and layer_of(e.element_type) == band and str((e.properties or {}).get("parent")) not in shown_ids)
+        if rest := sorted(orphans, key=_order):
+            groups[""] = rest
+        if not groups:
+            continue
+        for group in groups.values():
+            for i, e in enumerate(group):
+                row, column = divmod(i, COLUMNS)
+                node_id = f"{view.identifier}-n-{e.identifier}"
+                view.nodes.append(ViewNode(identifier=node_id, element=e.identifier, x=MARGIN + column * (WIDTH + GAP), y=y + row * (HEIGHT + GAP)))
+            y += (len(group) + COLUMNS - 1) // COLUMNS * (HEIGHT + GAP)
+        y += BAND_GAP
+
+
+def build_views(elements: list[Element], relationships: list[Relationship], relationship_levels: dict[str, frozenset[str]] | None = None) -> list[View]:
+    """The views of the model, one per viewpoint that has elements on its level, in VIEWPOINTS order.
+
+    Args:
+        relationship_levels: Relationship id -> its levels, where the relationship's own properties do not say (the
+            export's detail relationships); else from the properties
+    """
+    views: list[View] = []
+    for number, (name, viewpoint, types, level) in enumerate(VIEWPOINTS, 1):
+        shown = [e for e in elements if (types is None or e.element_type in types) and _on(level, _levels(e.properties))]
+        anchors = ANCHORS.get(name)
+        if not shown or (anchors and not any(e.element_type in anchors for e in shown)) or (level == DETAIL and not any(_level(e) == DETAIL for e in shown)):
+            continue
+        view = View(identifier=f"view-{number}", name=name, viewpoint=viewpoint, level=level)
+        _layout(view, shown)
+        node_of = {n.element: n.identifier for n in view.nodes}
+        for r in sorted(relationships, key=lambda r: r.identifier):
+            on = (relationship_levels or {}).get(r.identifier) or _levels(r.properties)
+            if r.source in node_of and r.target in node_of and _on(level, on):
+                connection = ViewConnection(identifier=f"{view.identifier}-c-{r.identifier}", relationship=r.identifier, source=node_of[r.source], target=node_of[r.target])
+                view.connections.append(connection)
+        views.append(view)
+    return views

{deriva_cli-0.8.1 → deriva_cli-0.8.3}/deriva/adapters/archimate/xml_export.py

@@ -8,12 +8,14 @@ Reference: https://www.opengroup.org/archimate-forum/archimate-exchange-format
 
 from __future__ import annotations
 
+from collections.abc import Mapping, Sequence
 from datetime import datetime
 from pathlib import Path
 
 from lxml import etree
 
 from .models import Element, Relationship
+from .views import View
 
 
 class ArchiMateXMLExporter:
@@ -47,6 +49,9 @@ class ArchiMateXMLExporter:
         output_path: str,
         model_name: str = "ArchiMate Model",
         model_id: str = "model-001",
+        properties: Mapping[str, Mapping[str, str]] | None = None,
+        views: Sequence[View] | None = None,
+        relationship_properties: Mapping[str, Mapping[str, str]] | None = None,
     ) -> None:
         """
         Export ArchiMate model to XML file.
@@ -57,6 +62,9 @@ class ArchiMateXMLExporter:
             output_path: Path to output XML file
             model_name: Name of the model
             model_id: Unique identifier for the model
+            properties: Exported properties per element id (e.g. ``level``), declared as propertyDefinitions
+            views: Diagrams to export (see ``views.build_views``)
+            relationship_properties: Exported properties per relationship id, declared with the element ones
         """
         # Create root model element
         root = etree.Element(
@@ -76,17 +84,31 @@ class ArchiMateXMLExporter:
         # Add metadata
         self._add_metadata(root)
 
+        properties = properties or {}
+        relationship_properties = relationship_properties or {}
+        keys = sorted({key for values in [*properties.values(), *relationship_properties.values()] for key, value in values.items() if value})
+        definition_of = {key: f"propid-{key}" for key in keys}
+
         # Add elements section
         if elements:
             elements_section = etree.SubElement(root, "elements")
             for element in elements:
-                self._add_element(elements_section, element)
+                self._add_element(elements_section, element, properties.get(element.identifier, {}), definition_of)
 
         # Add relationships section
         if relationships:
             rels_section = etree.SubElement(root, "relationships")
             for relationship in relationships:
-                self._add_relationship(rels_section, relationship)
+                self._add_relationship(rels_section, relationship, relationship_properties.get(relationship.identifier, {}), definition_of)
+
+        # The exchange format's order: elements, relationships, organizations, propertyDefinitions, views
+        if keys:
+            definitions = etree.SubElement(root, "propertyDefinitions")
+            for key in keys:
+                definition = etree.SubElement(definitions, "propertyDefinition", attrib={"identifier": definition_of[key], "type": "string"})
+                etree.SubElement(definition, "name").text = key
+        if views:
+            self._add_views(root, views, definition_of.get("level"))
 
         # Write to file
         tree = etree.ElementTree(root)
@@ -124,13 +146,21 @@ class ArchiMateXMLExporter:
         description = etree.SubElement(metadata, f"{{{self.DC_NS}}}description")
         description.text = "ArchiMate model generated by Deriva from source code analysis"
 
-    def _add_element(self, parent: etree.Element, element: Element) -> None:
+    def _add_element(
+        self,
+        parent: etree.Element,
+        element: Element,
+        properties: Mapping[str, str] | None = None,
+        definition_of: Mapping[str, str] | None = None,
+    ) -> None:
         """
         Add an element to the XML tree.
 
         Args:
             parent: Parent XML element
             element: ArchiMate element to add
+            properties: The element's exported properties (key -> value)
+            definition_of: propertyDefinition identifier per key
         """
         elem = etree.SubElement(
             parent,
@@ -152,17 +182,77 @@ class ArchiMateXMLExporter:
             doc_elem.set(f"{{{self.XML_NS}}}lang", "en")
             doc_elem.text = element.documentation
 
-        # Note: Properties are not exported as they require propertyDefinitions
-        # at the model level per ArchiMate Exchange Format XSD.
-        # Internal metadata (source, confidence, derived_at) is omitted.
-
-    def _add_relationship(self, parent: etree.Element, relationship: Relationship) -> None:
+        # Only the properties passed in are exported (each needs a model-level propertyDefinition);
+        # internal metadata (source, derived_at) on the element is omitted.
+        shown = sorted((key, value) for key, value in (properties or {}).items() if value and key in (definition_of or {}))
+        if shown and definition_of:
+            props = etree.SubElement(elem, "properties")
+            for key, value in shown:
+                prop = etree.SubElement(props, "property", attrib={"propertyDefinitionRef": definition_of[key]})
+                value_elem = etree.SubElement(prop, "value")
+                value_elem.set(f"{{{self.XML_NS}}}lang", "en")
+                value_elem.text = value
+
+    def _add_views(self, root: etree.Element, views: Sequence[View], level_definition: str | None = None) -> None:
+        """Add the diagrams: element nodes with their bounds, relationship connections between them, and each view's
+        level as a property where the model declares one."""
+        diagrams = etree.SubElement(etree.SubElement(root, "views"), "diagrams")
+        for view in views:
+            diagram = etree.SubElement(
+                diagrams,
+                "view",
+                attrib={"identifier": view.identifier, f"{{{self.XSI_NS}}}type": "Diagram", "viewpoint": view.viewpoint},
+            )
+            name_elem = etree.SubElement(diagram, "name")
+            name_elem.set(f"{{{self.XML_NS}}}lang", "en")
+            name_elem.text = view.name
+            if level_definition:
+                prop = etree.SubElement(etree.SubElement(diagram, "properties"), "property", attrib={"propertyDefinitionRef": level_definition})
+                value_elem = etree.SubElement(prop, "value")
+                value_elem.set(f"{{{self.XML_NS}}}lang", "en")
+                value_elem.text = view.level
+            for node in view.nodes:
+                etree.SubElement(
+                    diagram,
+                    "node",
+                    attrib={
+                        "identifier": node.identifier,
+                        "elementRef": node.element,
+                        f"{{{self.XSI_NS}}}type": "Element",
+                        "x": str(node.x),
+                        "y": str(node.y),
+                        "w": str(node.w),
+                        "h": str(node.h),
+                    },
+                )
+            for connection in view.connections:
+                etree.SubElement(
+                    diagram,
+                    "connection",
+                    attrib={
+                        "identifier": connection.identifier,
+                        "relationshipRef": connection.relationship,
+                        f"{{{self.XSI_NS}}}type": "Relationship",
+                        "source": connection.source,
+                        "target": connection.target,
+                    },
+                )
+
+    def _add_relationship(
+        self,
+        parent: etree.Element,
+        relationship: Relationship,
+        properties: Mapping[str, str] | None = None,
+        definition_of: Mapping[str, str] | None = None,
+    ) -> None:
         """
         Add a relationship to the XML tree.
 
         Args:
             parent: Parent XML element
             relationship: ArchiMate relationship to add
+            properties: The relationship's exported properties (key -> value)
+            definition_of: propertyDefinition identifier per key
         """
         rel = etree.SubElement(
             parent,
@@ -185,8 +275,15 @@ class ArchiMateXMLExporter:
             doc_elem = etree.SubElement(rel, "documentation")
             doc_elem.text = relationship.documentation
 
-        # Note: Properties are not exported as they require propertyDefinitions
-        # at the model level per ArchiMate Exchange Format XSD.
+        # Only the properties passed in are exported (each needs a model-level propertyDefinition), after name and documentation
+        shown = sorted((key, value) for key, value in (properties or {}).items() if value and key in (definition_of or {}))
+        if shown and definition_of:
+            props = etree.SubElement(rel, "properties")
+            for key, value in shown:
+                prop = etree.SubElement(props, "property", attrib={"propertyDefinitionRef": definition_of[key]})
+                value_elem = etree.SubElement(prop, "value")
+                value_elem.set(f"{{{self.XML_NS}}}lang", "en")
+                value_elem.text = str(value)
 
     def export_to_string(
         self,

{deriva_cli-0.8.1 → deriva_cli-0.8.3}/deriva/adapters/database/__init__.py

@@ -25,10 +25,12 @@ Usage:
 
 from __future__ import annotations
 
+from .db_tool import DATA_DIR
 from .db_tool import export_all as export_database
 from .db_tool import import_all as import_database
 from .manager import (
     DB_PATH,
+    ConfigDatabaseBusy,
     ensure_database,
     get_connection,
     init_database,
@@ -37,7 +39,12 @@ from .manager import (
     seed_database,
 )
 
+# Bundled business function models (a config path names one of them, or a user-supplied file)
+FUNCTION_MODELS_DIR = DATA_DIR / "function_models"
+
 __all__ = [
+    "FUNCTION_MODELS_DIR",
+    "ConfigDatabaseBusy",
     "ensure_database",
     "get_connection",
     "init_database",