deriva-cli 0.8.7__tar.gz → 0.8.8__tar.gz

{deriva_cli-0.8.7 → deriva_cli-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deriva-cli
-Version: 0.8.7
+Version: 0.8.8
 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,7 +35,7 @@ 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.3
+Requires-Dist: ctranslate2==4.8.4
 Requires-Dist: sentencepiece==0.2.2
 Requires-Dist: solvor>=0.6.3
 Requires-Dist: pydantic-ai-slim[openai,anthropic]>=2.57

{deriva_cli-0.8.7 → deriva_cli-0.8.8}/deriva/adapters/archimate/manager.py

@@ -168,9 +168,7 @@ class ArchimateManager:
 
         # Validate relationship
         if validate:
-            is_valid, errors = self.validator.validate_relationship(relationship)
-            if not is_valid:
-                raise ValidationError(f"Relationship validation failed: {errors}")
+            self._validate_relationship(relationship)
 
         try:
             # Create Cypher query to add relationship
@@ -215,6 +213,26 @@ class ArchimateManager:
             logger.error(f"Failed to add relationship {relationship.identifier}: {e}")
             raise
 
+    def _validate_relationship(self, relationship: Relationship) -> None:
+        """Raise ValidationError for a relationship the validator or the metamodel refuses: the metamodel decides
+        the type pair of the stored source and target (an endpoint that is not stored fails when it is created)."""
+        if self.db is None:
+            raise RuntimeError("Not connected to grafeo. Call connect() first.")
+        is_valid, errors = self.validator.validate_relationship(relationship)
+        if is_valid:
+            rows = self.db.execute_read(
+                f"MATCH (e:`{self.namespace}`) WHERE e.identifier IN [$source, $target] "
+                f"RETURN e.identifier AS identifier, [lbl IN labels(e) WHERE lbl <> '{self.namespace}'][0] AS element_type",
+                {"source": relationship.source, "target": relationship.target},
+            )
+            types = {row["identifier"]: row["element_type"] for row in rows}
+            if (source := types.get(relationship.source)) and (target := types.get(relationship.target)):
+                allowed, reason = self.metamodel.can_relate(source, relationship.relationship_type, target)
+                if not allowed:
+                    is_valid, errors = False, [reason]
+        if not is_valid:
+            raise ValidationError(f"Relationship validation failed: {errors}")
+
     def get_element(self, identifier: str) -> Element | None:
         """Get an element by identifier.
 
@@ -672,9 +690,7 @@ class ArchimateManager:
             documentation=old.documentation,
             properties=old.properties,
         )
-        is_valid, errors = self.validator.validate_relationship(new)
-        if not is_valid:
-            raise ValidationError(f"Relationship validation failed: {errors}")
+        self._validate_relationship(new)
         # Attributes that steps wrote directly on the edge (such as a consolidated confidence) go along
         edge = f"(:`{self.namespace}`)-[r]->(:`{self.namespace}`)"
         rows = self.query(f"MATCH {edge} WHERE r.identifier = $identifier RETURN properties(r) AS attributes", {"identifier": identifier})

{deriva_cli-0.8.7 → deriva_cli-0.8.8}/deriva/adapters/archimate/models.py

@@ -60,6 +60,12 @@ ELEMENT_TYPES: dict[str, ElementType] = {
         aspect="Behavior",
         description="An explicitly defined exposed application behavior",
     ),
+    "ApplicationFunction": ElementType(
+        name="ApplicationFunction",
+        layer="Application",
+        aspect="Behavior",
+        description="Automated behavior that can be performed by an application component",
+    ),
     "DataObject": ElementType(
         name="DataObject",
         layer="Application",
@@ -97,6 +103,18 @@ ELEMENT_TYPES: dict[str, ElementType] = {
         aspect="Structure",
         description="An organizational entity that is capable of performing behavior",
     ),
+    "BusinessRole": ElementType(
+        name="BusinessRole",
+        layer="Business",
+        aspect="Structure",
+        description="The responsibility for performing specific behavior, to which an actor can be assigned",
+    ),
+    "BusinessService": ElementType(
+        name="BusinessService",
+        layer="Business",
+        aspect="Behavior",
+        description="An explicitly defined behavior that a business role, business actor, or business collaboration exposes to its environment",
+    ),
     # Technology Layer
     "Node": ElementType(
         name="Node",
@@ -116,13 +134,19 @@ ELEMENT_TYPES: dict[str, ElementType] = {
         aspect="Structure",
         description="Software that provides or contributes to an environment for storing, executing, and using software or data",
     ),
+    "TechnologyFunction": ElementType(
+        name="TechnologyFunction",
+        layer="Technology",
+        aspect="Behavior",
+        description="A collection of technology behavior that can be performed by a technology internal active structure element",
+    ),
     "TechnologyService": ElementType(
         name="TechnologyService",
         layer="Technology",
         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
+    # The deployed image, package or bundle of a component (one per component with a function; 0.8.8)
     "Artifact": ElementType(
         name="Artifact",
         layer="Technology",
@@ -141,6 +165,7 @@ STRUCTURE_ELEMENTS: set[str] = {
     "ApplicationComponent",
     "ApplicationInterface",
     "BusinessActor",
+    "BusinessRole",
     "Node",
     "Device",
     "SystemSoftware",
@@ -149,9 +174,12 @@ STRUCTURE_ELEMENTS: set[str] = {
 # Behavior elements (processes, services, functions)
 BEHAVIOR_ELEMENTS: set[str] = {
     "ApplicationService",
+    "ApplicationFunction",
     "BusinessProcess",
     "BusinessFunction",
     "BusinessEvent",
+    "BusinessService",
+    "TechnologyFunction",
     "TechnologyService",
 }
 
@@ -170,11 +198,14 @@ APPLICATION_LAYER: set[str] = {
     "ApplicationComponent",
     "ApplicationInterface",
     "ApplicationService",
+    "ApplicationFunction",
     "DataObject",
 }
 
 BUSINESS_LAYER: set[str] = {
     "BusinessActor",
+    "BusinessRole",
+    "BusinessService",
     "BusinessProcess",
     "BusinessFunction",
     "BusinessEvent",
@@ -185,6 +216,7 @@ TECHNOLOGY_LAYER: set[str] = {
     "Node",
     "Device",
     "SystemSoftware",
+    "TechnologyFunction",
     "TechnologyService",
     "Artifact",
 }
@@ -201,13 +233,39 @@ def layer_of(element_type: str) -> str:
     return "Other"
 
 
+# Internal behaviour per layer: the same behaviour is often modelled as any of these (a function or a process)
+INTERNAL_BEHAVIOUR: dict[str, str] = {f"{layer}{kind}": layer for layer in ("Business", "Application", "Technology") for kind in ("Process", "Function", "Interaction", "Event")}
+
+
+def types_match(derived: str, reference: str) -> bool:
+    """Whether a derived element's type counts as a reference element's type when a model is compared with a reference:
+    the same type, or both internal behaviour (process, function, interaction, event) of one layer (user, 2026-10-19).
+    Services and structure types stay strict."""
+    if derived == reference:
+        return True
+    layer = INTERNAL_BEHAVIOUR.get(derived)
+    return layer is not None and layer == INTERNAL_BEHAVIOUR.get(reference)
+
+
+def match_kind(element_type: str) -> str:
+    """The key an element type is matched under: internal behaviour as its layer's behaviour, else the type itself (two
+    types match exactly when their keys are equal, as ``types_match`` says)."""
+    layer = INTERNAL_BEHAVIOUR.get(element_type)
+    return f"{layer} behaviour" if layer else element_type
+
+
 # =============================================================================
 # ArchiMate 3.2 Relationship Table
 # =============================================================================
-# Source: ArchiMate 3.2 Specification, Appendix B.5 "Relationship Tables", restricted
-# 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.
+# Source: ArchiMate 3.2 Specification (C226), restricted to the element types Deriva derives plus Artifact. Letters:
+# Archi's relationships.xml v3.2 (Influence left out), which matches the spec's Appendix B.5 tables in every cell. Tier,
+# from the metamodel figures (0.8.8; B.4, p. 140: the restrictions apply to derived relationships only, not to those the
+# metamodel diagrams define): uppercase where a figure draws the relationship, else lowercase. The figures: within a
+# layer Fig. 52 p. 58 (business), Fig. 70 p. 73 (application), Fig. 82 p. 83 (technology), with Fig. 53 p. 59 (actor
+# assigned to role), Fig. 71 p. 74 (component realizes component), Fig. 83 p. 84 (node, device, system software) and
+# Fig. 97 p. 93 (artifact); across layers Fig. 104 p. 101 and Fig. 105 p. 102; the note under every layer figure for
+# same-type composition, aggregation and specialization. Triggering and flow only where a figure draws both line ends
+# unambiguously. Association is allowed between any two elements (uppercase everywhere).
 #
 # Uppercase letter: relationship explicit in the metamodel figures ("direct").
 # Lowercase letter: allowed only via the spec's derivation rules ("derived").
@@ -230,46 +288,70 @@ _LETTER_BY_RELATIONSHIP = {name: letter for letter, name in RELATIONSHIP_LETTERS
 
 _TABLE_COLUMNS = (
     "BusinessActor",
+    "BusinessRole",
     "BusinessProcess",
     "BusinessFunction",
     "BusinessEvent",
+    "BusinessService",
     "BusinessObject",
     "ApplicationComponent",
     "ApplicationInterface",
     "ApplicationService",
+    "ApplicationFunction",
     "DataObject",
     "Node",
     "Device",
     "SystemSoftware",
+    "TechnologyFunction",
     "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", "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"),
+    "BusinessActor":        ("SCGvtfO", "IvtfO", "IvtfO", "IvtfO", "IvtfO", "irvtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessRole":         ("vtfO", "SCGvtfO", "IvtfO", "IvtfO", "IvtfO", "irvtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessProcess":      ("vtfO", "vtfO", "SCGvTFO", "CGvTFO", "vTFO", "RvtfO", "AO", "vtfO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessFunction":     ("vtfO", "vtfO", "CGvTFO", "SCGvTFO", "vTFO", "RvtfO", "AO", "vtfO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessEvent":        ("vtfO", "vtfO", "vTFO", "vTFO", "SCGvTFO", "vtfO", "AO", "vtfO", "vtfO", "vtfO", "vtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "BusinessService":      ("VtfO", "VtfO", "VtfO", "VtfO", "vtfO", "SCGvTFO", "AO", "vtfO", "vtfO", "vtfO", "VtfO", "aO", "vtfO", "vtfO", "vtfO", "VtfO", "vtfO", "aO"),
+    "BusinessObject":       ("O", "O", "O", "O", "O", "O", "SCGO", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O", "O"),
+    "ApplicationComponent": ("vtfO", "vtfO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGRvtfO", "CgrvtfO", "irvtfO", "IrvtfO", "aO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),  # noqa: E501
+    "ApplicationInterface": ("VtfO", "VtfO", "vtfO", "vtfO", "vtfO", "rvtfO", "aO", "VtfO", "SCGvtfO", "IvtfO", "vtfO", "aO", "VtfO", "VtfO", "VtfO", "vtfO", "vtfO", "aO"),
+    "ApplicationService":   ("vtfO", "vtfO", "VtfO", "VtfO", "vtfO", "RvtfO", "aO", "VtfO", "vtfO", "SCGvTFO", "VtfO", "AO", "vtfO", "vtfO", "vtfO", "VtfO", "vtfO", "aO"),
+    "ApplicationFunction":  ("vtfO", "vtfO", "RvtfO", "RvtfO", "vtfO", "rvtfO", "aO", "vtfO", "vtfO", "RvtfO", "SCGvTFO", "AO", "vtfO", "vtfO", "vtfO", "vtfO", "vtfO", "aO"),
+    "DataObject":           ("O", "O", "O", "O", "O", "O", "RO", "O", "O", "O", "O", "SCGO", "O", "O", "O", "O", "O", "O"),
+    "Node":                 ("ivtfO", "ivtfO", "irvtfO", "irvtfO", "irvtfO", "irvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "SCGivtfO", "CGirvtfO", "CGirvtfO", "IrvtfO", "irvtfO", "iaO"),  # noqa: E501
+    "Device":               ("vtfO", "vtfO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "SCGvtfO", "CGIrvtfO", "IrvtfO", "irvtfO", "IaO"),  # noqa: E501
+    "SystemSoftware":       ("vtfO", "vtfO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "rvtfO", "rvtfO", "rvtfO", "rvtfO", "aO", "vtfO", "vtfO", "SCGIrvtfO", "IrvtfO", "irvtfO", "IaO"),  # noqa: E501
+    "TechnologyFunction":   ("vtfO", "vtfO", "RvtfO", "RvtfO", "vtfO", "rvtfO", "aO", "vtfO", "vtfO", "rvtfO", "RvtfO", "aO", "vtfO", "vtfO", "vtfO", "SCGvTFO", "RvtfO", "AO"),
+    "TechnologyService":    ("vtfO", "vtfO", "VtfO", "VtfO", "vtfO", "RvtfO", "aO", "vtfO", "vtfO", "RvtfO", "VtfO", "aO", "VtfO", "VtfO", "VtfO", "VtfO", "SCGvTFO", "AO"),
+    "Artifact":             ("O", "O", "rO", "rO", "rO", "rO", "RO", "RO", "rO", "rO", "rO", "RO", "O", "O", "RO", "rO", "rO", "SCGrO"),
 }
 # fmt: on
 
 RELATIONSHIP_TABLE: dict[tuple[str, str], str] = {(source, target): cell for source, row in _TABLE_ROWS.items() for target, cell in zip(_TABLE_COLUMNS, row, strict=True)}
 
+# The valid derivation rules of ArchiMate 3.2, Appendix B.2 (spec pp. 127-131; the potential rules of B.3 are left out),
+# as plain data for the derivation engine: (number, first relationship types, second types, join, derived type).
+# Joins: "chain" p(a,b) q(b,c) -> r(a,c); "back" p(a,b) q(c,b) -> r(c,a). Derived type: "weakest" (by
+# STRUCTURAL_STRENGTH), "first" (p's type) or "second" (q's type). The restrictions of B.4 (p. 139) hold through the
+# relationship table, which is built from the figures and these rules: a derived triple the table does not allow is none.
+STRUCTURAL_RELATIONSHIPS = ("Composition", "Aggregation", "Assignment", "Realization")  # Section 5.1
+DEPENDENCY_RELATIONSHIPS = ("Serving", "Access", "Influence", "Association")  # Section 5.2
+DYNAMIC_RELATIONSHIPS = ("Triggering", "Flow")  # Section 5.3
+STRUCTURAL_STRENGTH = ("Realization", "Assignment", "Aggregation", "Composition")  # B.2.2, weakest first
+VALID_DERIVATION_RULES: tuple[tuple[str, tuple[str, ...], tuple[str, ...], str, str], ...] = (
+    ("DR 1", ("Specialization",), ("Specialization",), "chain", "first"),  # p. 127: transitivity of specialization
+    ("DR 2", STRUCTURAL_RELATIONSHIPS, STRUCTURAL_RELATIONSHIPS, "chain", "weakest"),  # p. 128
+    ("DR 3", STRUCTURAL_RELATIONSHIPS, DEPENDENCY_RELATIONSHIPS, "chain", "second"),  # p. 129: in line
+    ("DR 4", STRUCTURAL_RELATIONSHIPS, DEPENDENCY_RELATIONSHIPS, "back", "second"),  # p. 129: opposing
+    ("DR 5", STRUCTURAL_RELATIONSHIPS, DYNAMIC_RELATIONSHIPS, "chain", "second"),  # p. 130
+    ("DR 6", STRUCTURAL_RELATIONSHIPS, ("Flow",), "back", "second"),  # p. 130
+    ("DR 7", ("Triggering",), STRUCTURAL_RELATIONSHIPS, "chain", "first"),  # p. 130
+    ("DR 8", ("Triggering",), ("Triggering",), "chain", "first"),  # p. 131: transitivity of triggering
+)
+
 # Relationship types Deriva may propose. Association, Specialization and Influence
 # are valid ArchiMate but deliberately not derived.
 DERIVABLE_RELATIONSHIP_TYPES: tuple[str, ...] = (
@@ -338,11 +420,18 @@ class ArchiMateMetamodel:
     # ArchiMate 3.2: a part is composed into at most one whole, and composition hierarchies are acyclic.
     single_parent_relationship_types: frozenset[str] = frozenset({"Composition"})
     acyclic_relationship_types: frozenset[str] = frozenset({"Composition"})
+    # Appendix B.2: the valid derivation rules as data, and the structural strength order they use (weakest first)
+    derivation_rules = VALID_DERIVATION_RULES
+    structural_strength = STRUCTURAL_STRENGTH
 
     def __init__(self):
         self.element_types = ELEMENT_TYPES
         self.relationship_types = RELATIONSHIP_TYPES
 
+    def tier(self, source_element_type: str, relationship_type: str, target_element_type: str) -> str | None:
+        """ "direct" (a metamodel figure draws it), "derived", or None if ArchiMate 3.2 does not allow it."""
+        return relationship_tier(source_element_type, relationship_type, target_element_type)
+
     def is_valid_element_type(self, element_type: str) -> bool:
         """Check if element type is valid."""
         return element_type in self.element_types

{deriva_cli-0.8.7 → deriva_cli-0.8.8}/deriva/adapters/archimate/views.py

@@ -14,7 +14,7 @@ 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"})
+DEPLOYMENT = frozenset({"ApplicationComponent", "Node", "Device", "SystemSoftware", "TechnologyFunction", "TechnologyService", "Artifact"})
 # (view name, viewpoint, element types, level), in export order
 VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, str], ...] = (
     ("Layered (enterprise)", "Layered", None, ENTERPRISE),
@@ -24,11 +24,11 @@ VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, str], ...] = (
     (
         "Business (enterprise)",
         "Business Process Cooperation",
-        frozenset({"BusinessActor", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}),
+        frozenset({"BusinessActor", "BusinessRole", "BusinessProcess", "BusinessFunction", "BusinessEvent", "ApplicationService"}),
         ENTERPRISE,
     ),
     ("Application Structure (solution)", "Application Structure", frozenset({"ApplicationComponent"}), SOLUTION),
-    ("Application Cooperation (solution)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface"}), SOLUTION),
+    ("Application Cooperation (solution)", "Application Cooperation", frozenset({"ApplicationComponent", "ApplicationInterface", "ApplicationFunction"}), 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),
@@ -38,12 +38,12 @@ VIEWPOINTS: tuple[tuple[str, str, frozenset[str] | None, str], ...] = (
 )
 
 # 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"})}
+ANCHORS = {"Business (enterprise)": frozenset({"BusinessActor", "BusinessRole", "BusinessProcess", "BusinessFunction", "BusinessEvent"})}
 BANDS = ("Business", "Application", "Technology", "Other")
 TYPE_ORDER = (
-    "BusinessActor", "BusinessFunction", "BusinessProcess", "BusinessEvent", "BusinessObject",
-    "ApplicationComponent", "ApplicationInterface", "ApplicationService", "DataObject",
-    "Node", "Device", "SystemSoftware", "TechnologyService", "Artifact",
+    "BusinessActor", "BusinessRole", "BusinessFunction", "BusinessProcess", "BusinessEvent", "BusinessObject",
+    "ApplicationComponent", "ApplicationInterface", "ApplicationService", "ApplicationFunction", "DataObject",
+    "Node", "Device", "SystemSoftware", "TechnologyFunction", "TechnologyService", "Artifact",
 )  # fmt: skip
 COLUMNS, WIDTH, HEIGHT, GAP, BAND_GAP, MARGIN = 6, 160, 60, 20, 60, 20
 

{deriva_cli-0.8.7 → deriva_cli-0.8.8}/deriva/adapters/archimate/xml_export.py

@@ -29,7 +29,11 @@ class ArchiMateXMLExporter:
 
     NSMAP = {None: ARCHIMATE_NS, "xsi": XSI_NS, "dc": DC_NS}
 
-    SCHEMA_LOCATION = "http://www.opengroup.org/xsd/archimate/3.0/ http://www.opengroup.org/xsd/archimate/3.1/archimate3_Model.xsd"
+    # As the exchange format's own examples: the diagram schema (the export carries views) and Dublin Core (the metadata)
+    SCHEMA_LOCATION = (
+        "http://www.opengroup.org/xsd/archimate/3.0/ http://www.opengroup.org/xsd/archimate/3.1/archimate3_Diagram.xsd "
+        "http://purl.org/dc/elements/1.1/ http://www.opengroup.org/xsd/archimate/3.1/dc.xsd"
+    )
 
     def __init__(self, pretty_print: bool = True, encoding: str = "UTF-8"):
         """