deriva-cli 0.8.0__tar.gz → 0.8.2__tar.gz

{deriva_cli-0.8.0 → deriva_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deriva-cli
-Version: 0.8.0
+Version: 0.8.2
 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
@@ -27,7 +27,6 @@ Requires-Dist: rich>=15
 Requires-Dist: lxml>=6
 Requires-Dist: duckdb>=1.5
 Requires-Dist: grafeo>=0.6.0b1
-Requires-Dist: sqlglot>=30
 Requires-Dist: tree-sitter>=0.26
 Requires-Dist: tree-sitter-python>=0.23.0
 Requires-Dist: tree-sitter-javascript>=0.23.0
@@ -36,20 +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>=2.55
-Requires-Dist: authlib>=1.8.0
-Requires-Dist: pyasn1>=0.6.4
-Requires-Dist: pyjwt>=2.15
-Requires-Dist: diskcache>=5.6.3
-Requires-Dist: nest-asyncio>=1.6.0
-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: pydantic-ai-slim[mistral]>=2.55
+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.0 → deriva_cli-0.8.2}/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.2/deriva/adapters/archimate/views.py

@@ -0,0 +1,121 @@
+"""Generated views (pure): ArchiMate viewpoints per level with a deterministic band layout.
+
+Each viewpoint (ArchiMate 3.2 Specification, chapter 13) shows the architect elements of its types; a detail
+variant adds the detail elements (property ``level`` = detail) nested under those types. 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
+
+# (view name, viewpoint, element types, with detail elements)
+VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, bool], ...] = (
+    ("Layered", "Layered", None, False),
+    ("Application Cooperation", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface", "ApplicationService"}), False),
+    ("Information Structure", "Information Structure", frozenset({"BusinessObject", "DataObject"}), False),
+    ("Information Structure (detail)", "Information Structure", frozenset({"BusinessObject", "DataObject"}), True),
+    ("Implementation and Deployment", "Implementation and Deployment", frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService"}), False),
+    (
+        "Implementation and Deployment (detail)",
+        "Implementation and Deployment",
+        frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyService", "Artifact"}),
+        True,
+    ),
+    ("Business", "Business Process Cooperation", frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}), False),
+)
+# A view needs an element of its anchor types (the Business view: a business element, not application services alone)
+ANCHORS = {"Business": 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 = "architect"  # detail: the 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 _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]) -> list[View]:
+    """The views of the model, one per viewpoint that has elements, in VIEWPOINTS order."""
+    views: list[View] = []
+    for number, (name, viewpoint, types, with_detail) in enumerate(VIEWPOINTS, 1):
+        shown = [e for e in elements if (types is None or e.element_type in types) and (with_detail or _level(e) != "detail")]
+        anchors = ANCHORS.get(name)
+        if not shown or (anchors and not any(e.element_type in anchors for e in shown)) or (with_detail and not any(_level(e) == "detail" for e in shown)):
+            continue
+        view = View(identifier=f"view-{number}", name=name, viewpoint=viewpoint, level="detail" if with_detail else "architect")
+        _layout(view, shown)
+        node_of = {n.element: n.identifier for n in view.nodes}
+        for r in sorted(relationships, key=lambda r: r.identifier):
+            if r.source in node_of and r.target in node_of:
+                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.0 → deriva_cli-0.8.2}/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,8 @@ 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,
     ) -> None:
         """
         Export ArchiMate model to XML file.
@@ -57,6 +61,8 @@ 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``)
         """
         # Create root model element
         root = etree.Element(
@@ -76,11 +82,15 @@ class ArchiMateXMLExporter:
         # Add metadata
         self._add_metadata(root)
 
+        properties = properties or {}
+        keys = sorted({key for values in 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:
@@ -88,6 +98,15 @@ class ArchiMateXMLExporter:
             for relationship in relationships:
                 self._add_relationship(rels_section, relationship)
 
+        # 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)
+
         # Write to file
         tree = etree.ElementTree(root)
         output_file = Path(output_path)
@@ -124,13 +143,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,9 +179,55 @@ 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.
+        # 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]) -> None:
+        """Add the diagrams: element nodes with their bounds, relationship connections between them."""
+        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
+            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) -> None:
         """

{deriva_cli-0.8.0 → deriva_cli-0.8.2}/deriva/adapters/database/__init__.py

@@ -25,6 +25,7 @@ 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 (
@@ -37,7 +38,11 @@ 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",
     "ensure_database",
     "get_connection",
     "init_database",