sysmlpy 0.19.0__tar.gz → 0.19.2__tar.gz

{sysmlpy-0.19.0 → sysmlpy-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.19.0
+Version: 0.19.2
 Summary: SysML v2.0 Parser
 License: MIT License
          

{sysmlpy-0.19.0 → sysmlpy-0.19.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.19.0"
+version = "0.19.2"
 description = "SysML v2.0 Parser"
 authors = [
   { name="Jon R. Fox (mycr0ft)", email="jon.fox@drfox.com" },
@@ -114,7 +114,7 @@ build_command = "pip install poetry && poetry build"
 
 [tool.poetry]
 name = "sysmlpy"
-version = "0.19.0"
+version = "0.19.2"
 description = ""
 authors = ["Jon R. Fox (mycr0ft) <jon.fox@drfox.com>"]
 readme = "README.md"

{sysmlpy-0.19.0 → sysmlpy-0.19.2}/src/sysmlpy/__init__.py

@@ -15,7 +15,7 @@ __all__ = [
     "analyze", "SemanticIssue", "SemanticAnalyzer",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.15.0"
+__version__ = "0.19.2"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.19.0 → sysmlpy-0.19.2}/src/sysmlpy/grammar/classes.py

@@ -220,6 +220,10 @@ class DefinitionElement:
                 self.children.append(
                     SatisfyRequirementUsage(definition["ownedRelatedElement"])
                 )
+            elif de == "InterfaceUsage":
+                self.children.append(
+                    InterfaceUsage(definition["ownedRelatedElement"])
+                )
             else:
                 print(f"Unknown DefinitionElement type: {de}")  # pragma: no cover
                 raise NotImplementedError  # pragma: no cover
@@ -6311,6 +6315,13 @@ class InterfaceUsageDeclaration:
 
         return " ".join(output)
 
+    def get_definition(self):
+        output = {"name": self.__class__.__name__}
+        output["declaration"] = self.declaration.get_definition() if self.declaration else None
+        output["part1"] = self.part.get_definition() if self.part else None
+        output["part2"] = None
+        return output
+
 
 class InterfacePart:
     def __init__(self, definition):
@@ -6325,6 +6336,13 @@ class InterfacePart:
     def dump(self):
         return self.children.dump()
 
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "binarypart": self.children.get_definition() if self.children else None,
+            "narypart": None
+        }
+
 
 class BinaryInterfacePart:
     def __init__(self, definition):
@@ -6340,6 +6358,12 @@ class BinaryInterfacePart:
 
         return self.children[0].dump() + " to " + self.children[1].dump()
 
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "ownedRelationship": [c.get_definition() for c in self.children]
+        }
+
 
 class InterfaceEndMember:
     def __init__(self, definition):
@@ -6349,6 +6373,12 @@ class InterfaceEndMember:
     def dump(self):
         return self.child.dump()
 
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "ownedRelatedElement": self.child.get_definition()
+        }
+
 
 class InterfaceEnd:
     def __init__(self, definition):
@@ -6379,6 +6409,13 @@ class InterfaceEnd:
 
         return " ".join(output)
 
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "declaredName": self.name,
+            "ownedRelationship": [r.get_definition() for r in self.relationships]
+        }
+
 
 class PortUsage:
     def __init__(self, definition=None):

{sysmlpy-0.19.0 → sysmlpy-0.19.2}/src/sysmlpy/semantic.py

@@ -482,11 +482,14 @@ class SemanticAnalyzer:
         symtab = SymbolTable()
         symtab.build_from_model(model)
 
-        # Step 2: Collect all references with scope paths
+        # Step 2: Validate imports (check if import targets exist)
+        issues.extend(self._validate_imports(symtab))
+
+        # Step 3: Collect all references with scope paths
         collector = ReferenceCollector()
         references = collector.collect(model)
 
-        # Step 3: Cross-reference using scope-aware lookup
+        # Step 4: Cross-reference using scope-aware lookup
         for ref_str, element, scope_path in references:
             if self._is_resolved(ref_str, symtab, scope_path):
                 continue
@@ -501,6 +504,91 @@ class SemanticAnalyzer:
 
         return issues
 
+    def _validate_imports(self, symtab: SymbolTable) -> list[SemanticIssue]:
+        """Validate that all import targets exist in the model."""
+        issues: list[SemanticIssue] = []
+        self._check_imports_in_scope(symtab, symtab, issues)
+        return issues
+
+    def _check_imports_in_scope(
+        self, symtab: SymbolTable, table: SymbolTable, issues: list[SemanticIssue]
+    ) -> None:
+        """Check imports in this scope and recurse into children."""
+        for imp in table._imports:
+            self._validate_single_import(symtab, table, imp, issues)
+
+        for child_table in table._children.values():
+            self._check_imports_in_scope(symtab, child_table, issues)
+
+    def _validate_single_import(
+        self, symtab: SymbolTable, table: SymbolTable, imp: Any, issues: list[SemanticIssue]
+    ) -> None:
+        """Validate a single Import object."""
+        if not imp.children:
+            return
+
+        import_child = imp.children[0]
+        child_type = type(import_child).__name__
+
+        if child_type == "MembershipImport":
+            self._validate_membership_import(symtab, table, import_child, issues)
+        elif child_type == "NamespaceImport":
+            self._validate_namespace_import(symtab, table, import_child, issues)
+
+    def _validate_membership_import(
+        self, symtab: SymbolTable, table: SymbolTable, mem_import: Any, issues: list[SemanticIssue]
+    ) -> None:
+        """Validate a MembershipImport targets an existing element."""
+        imported_mem = getattr(mem_import, "membership", None)
+        if imported_mem is None:
+            return
+
+        qn = getattr(imported_mem, "name", None)
+        if qn is None:
+            return
+
+        names = getattr(qn, "names", [])
+        if not names:
+            return
+
+        ref_str = "::".join(names)
+        element = symtab._resolve_qualified_name(ref_str, table)
+        if element is None:
+            issues.append(SemanticIssue(
+                severity="error",
+                code="UNRESOLVED_IMPORT",
+                message=f"Import target '{ref_str}' does not exist",
+                element=None,
+                reference=ref_str,
+            ))
+
+    def _validate_namespace_import(
+        self, symtab: SymbolTable, table: SymbolTable, ns_import: Any, issues: list[SemanticIssue]
+    ) -> None:
+        """Validate a NamespaceImport targets an existing namespace."""
+        imported_ns = getattr(ns_import, "namespace", None)
+        if imported_ns is None:
+            return
+
+        qn = getattr(imported_ns, "namespaces", None)
+        if qn is None:
+            return
+
+        names = getattr(qn, "names", [])
+        if not names:
+            return
+
+        ref_str = "::".join(names)
+        target_table = symtab._find_namespace_table(ref_str, table)
+        if target_table is None:
+            issues.append(SemanticIssue(
+                severity="error",
+                code="UNRESOLVED_IMPORT",
+                message=f"Import namespace '{ref_str}' does not exist",
+                element=None,
+                reference=ref_str,
+            ))
+
     def _is_resolved(self, ref_str: str, symtab: SymbolTable, scope_path: list[str]) -> bool:
         """Check if a qualified name reference can be resolved from the given scope."""
         # Check known library symbols first