sysmlpy 0.28.1__tar.gz → 0.30.0__tar.gz

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/PKG-INFO

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

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.28.1"
+version = "0.30.0"
 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.28.1"
+version = "0.30.0"
 description = ""
 authors = ["Jon R. Fox (mycr0ft) <jon.fox@drfox.com>"]
 readme = "README.md"

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/__init__.py

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

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/definition.py

@@ -399,25 +399,31 @@ class Package(Searchable):
             self._set_name(shortname, short=True)
 
     def __repr__(self):
-        """Return a developer-friendly string representation.
+        """Return a constructor-mirroring string representation.
 
         Returns
         -------
         str
-            String showing name and shortname for debugging.
         """
         name = getattr(self, 'name', None)
-        shortname = getattr(self.grammar.declaration.identification, 'declaredShortName', None)
-        
+        # Suppress auto-generated UUID names
+        if name and len(name) == 36 and name.count('-') == 4:
+            name = None
+
+        try:
+            shortname = getattr(self.grammar.declaration.identification, 'declaredShortName', None)
+            if shortname:
+                shortname = shortname.strip('<').strip('>')
+        except (AttributeError, TypeError):
+            shortname = None
+
         cls_name = self.__class__.__name__
-        if name and shortname:
-            return f"{cls_name}(name={name!r}, shortname={shortname!r})"
-        elif name:
-            return f"{cls_name}(name={name!r})"
-        elif shortname:
-            return f"{cls_name}(shortname={shortname!r})"
-        else:
-            return f"{cls_name}()"
+        parts = []
+        if name:
+            parts.append(f'name={name!r}')
+        if shortname:
+            parts.append(f'shortname={shortname!r}')
+        return f"{cls_name}({', '.join(parts)})"
 
     def _set_name(self, name, short=False):
         """Set the declared name or short name on the package grammar.

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/grammar/classes.py

@@ -1412,10 +1412,11 @@ class ActionNodeUsageDeclaration:
                 self.declaration = UsageDeclaration(definition["declaration"])
 
     def dump(self):
+        # Only output keyword if there's a declaration (explicit "action" keyword)
         if self.declaration is not None:
             return " ".join([self.keyword, self.declaration.dump()])
         else:
-            return self.keyword
+            return ""  # No keyword when no declaration
 
     def get_definition(self):
         return {
@@ -2251,8 +2252,8 @@ class AcceptParameterPart:
 
 class SenderReceiverPart:
     # SenderReceiverPart :
-    # 	'via' nodeParameterMember 'to' emptyParameterMember
-    # 	| 'to' emptyParameterMember
+    # 	'via' nodeParameterMember 'to' nodeParameterMember
+    # 	| 'to' nodeParameterMember
     # ;
     def __init__(self, definition):
         self.via = None
@@ -2261,7 +2262,7 @@ class SenderReceiverPart:
             if definition.get("via") is not None:
                 self.via = NodeParameterMember(definition["via"])
             if definition.get("to") is not None:
-                self.to = EmptyParameterMember(definition["to"])
+                self.to = NodeParameterMember(definition["to"])
 
     def dump(self):
         output = []
@@ -2758,85 +2759,114 @@ class AcceptNode:
 
 class IfNode:
     # IfNode :
-    # 	prefix=OccurrenceUsagePrefix ifNodeDeclaration actionBody
+    # 	prefix=OccurrenceUsagePrefix IF condition thenBody (ELSE elseBody)?
     # ;
     def __init__(self, definition):
         self.prefix = None
-        self.declaration = None
-        self.body = None
+        self.condition = None
+        self.thenBody = None
+        self.elseBody = None
+        self.elseIf = None
         if valid_definition(definition, self.__class__.__name__):
             if definition.get("prefix") is not None:
                 self.prefix = OccurrenceUsagePrefix(definition["prefix"])
-            if definition.get("declaration") is not None:
-                self.declaration = IfNodeDeclaration(definition["declaration"])
-            if definition.get("body") is not None:
-                self.body = ActionBody(definition["body"])
+            self.condition = definition.get("condition")
+            if definition.get("thenBody") is not None:
+                self.thenBody = ActionBody(definition["thenBody"])
+            if definition.get("elseBody") is not None:
+                self.elseBody = ActionBody(definition["elseBody"])
+            if definition.get("elseIf") is not None:
+                self.elseIf = IfNode(definition["elseIf"])
 
     def dump(self):
         output = []
         if self.prefix is not None:
             output.append(self.prefix.dump())
-        if self.declaration is not None:
-            output.append(self.declaration.dump())
-        if self.body is not None:
-            output.append(self.body.dump())
+        output.append("if")
+        if self.condition is not None:
+            output.append(self.condition)
+        if self.thenBody is not None:
+            output.append(self.thenBody.dump())
+        if self.elseIf is not None:
+            output.append("else")
+            output.append(self.elseIf.dump())
+        elif self.elseBody is not None:
+            output.append("else")
+            output.append(self.elseBody.dump())
         return " ".join(output)
 
     def get_definition(self):
         output = {
             "name": self.__class__.__name__,
             "prefix": None,
-            "declaration": None,
-            "body": None,
+            "condition": None,
+            "thenBody": None,
+            "elseBody": None,
+            "elseIf": None,
         }
         if self.prefix is not None:
             output["prefix"] = self.prefix.get_definition()
-        if self.declaration is not None:
-            output["declaration"] = self.declaration.get_definition()
-        if self.body is not None:
-            output["body"] = self.body.get_definition()
+        output["condition"] = self.condition
+        if self.thenBody is not None:
+            output["thenBody"] = self.thenBody.get_definition()
+        if self.elseBody is not None:
+            output["elseBody"] = self.elseBody.get_definition()
+        if self.elseIf is not None:
+            output["elseIf"] = self.elseIf.get_definition()
         return output
 
 
 class WhileLoopNode:
     # WhileLoopNode :
-    # 	prefix=OccurrenceUsagePrefix whileLoopNodeDeclaration actionBody
+    # 	prefix=OccurrenceUsagePrefix (WHILE condition | LOOP) body (UNTIL untilCondition)?
     # ;
     def __init__(self, definition):
         self.prefix = None
-        self.declaration = None
+        self.keyword = None
+        self.condition = None
         self.body = None
+        self.until = None
         if valid_definition(definition, self.__class__.__name__):
             if definition.get("prefix") is not None:
                 self.prefix = OccurrenceUsagePrefix(definition["prefix"])
-            if definition.get("declaration") is not None:
-                self.declaration = WhileLoopNodeDeclaration(definition["declaration"])
+            self.keyword = definition.get("keyword")
+            self.condition = definition.get("condition")
             if definition.get("body") is not None:
                 self.body = ActionBody(definition["body"])
+            self.until = definition.get("until")
 
     def dump(self):
         output = []
         if self.prefix is not None:
             output.append(self.prefix.dump())
-        if self.declaration is not None:
-            output.append(self.declaration.dump())
+        if self.keyword is not None:
+            output.append(self.keyword)
+        if self.condition is not None:
+            output.append(self.condition)
         if self.body is not None:
             output.append(self.body.dump())
+        if self.until is not None:
+            output.append("until")
+            output.append(self.until)
+            output.append(";")
         return " ".join(output)
 
     def get_definition(self):
         output = {
             "name": self.__class__.__name__,
             "prefix": None,
-            "declaration": None,
+            "keyword": None,
+            "condition": None,
             "body": None,
+            "until": None,
         }
         if self.prefix is not None:
             output["prefix"] = self.prefix.get_definition()
-        if self.declaration is not None:
-            output["declaration"] = self.declaration.get_definition()
+        output["keyword"] = self.keyword
+        output["condition"] = self.condition
         if self.body is not None:
             output["body"] = self.body.get_definition()
+        output["until"] = self.until
         return output
 
 
@@ -2884,16 +2914,62 @@ class ForLoopNode:
 
 class ControlNode:
     # ControlNode :
-    # 	prefix=OccurrenceUsagePrefix controlNodeDeclaration
+    # 	prefix=OccurrenceUsagePrefix keyword actionBody
+    # ;
+    def __init__(self, definition):
+        self.prefix = None
+        self.keyword = None
+        self.body = None
+        if valid_definition(definition, self.__class__.__name__):
+            if definition.get("prefix") is not None:
+                self.prefix = OccurrenceUsagePrefix(definition["prefix"])
+            self.keyword = definition.get("keyword")
+            if definition.get("body") is not None:
+                self.body = ActionBody(definition["body"])
+
+    def dump(self):
+        output = []
+        if self.prefix is not None:
+            output.append(self.prefix.dump())
+        if self.keyword is not None:
+            output.append(self.keyword)
+        if self.body is not None:
+            output.append(self.body.dump())
+        return " ".join(output)
+
+    def get_definition(self):
+        output = {
+            "name": self.__class__.__name__,
+            "prefix": None,
+            "keyword": None,
+            "body": None,
+        }
+        if self.prefix is not None:
+            output["prefix"] = self.prefix.get_definition()
+        output["keyword"] = self.keyword
+        if self.body is not None:
+            output["body"] = self.body.get_definition()
+        return output
+
+
+class TerminateNode:
+    # TerminateNode :
+    # 	prefix=OccurrenceUsagePrefix actionNodeUsageDeclaration? TERMINATE nodeParameterMember? actionBody
     # ;
     def __init__(self, definition):
         self.prefix = None
         self.declaration = None
+        self.target = None
+        self.body = None
         if valid_definition(definition, self.__class__.__name__):
             if definition.get("prefix") is not None:
                 self.prefix = OccurrenceUsagePrefix(definition["prefix"])
             if definition.get("declaration") is not None:
-                self.declaration = ControlNodeDeclaration(definition["declaration"])
+                self.declaration = ActionNodeUsageDeclaration(definition["declaration"])
+            if definition.get("target") is not None:
+                self.target = NodeParameterMember(definition["target"])
+            if definition.get("body") is not None:
+                self.body = ActionBody(definition["body"])
 
     def dump(self):
         output = []
@@ -2901,6 +2977,11 @@ class ControlNode:
             output.append(self.prefix.dump())
         if self.declaration is not None:
             output.append(self.declaration.dump())
+        output.append("terminate")
+        if self.target is not None:
+            output.append(self.target.dump())
+        if self.body is not None:
+            output.append(self.body.dump())
         return " ".join(output)
 
     def get_definition(self):
@@ -2908,11 +2989,17 @@ class ControlNode:
             "name": self.__class__.__name__,
             "prefix": None,
             "declaration": None,
+            "target": None,
+            "body": None,
         }
         if self.prefix is not None:
             output["prefix"] = self.prefix.get_definition()
         if self.declaration is not None:
             output["declaration"] = self.declaration.get_definition()
+        if self.target is not None:
+            output["target"] = self.target.get_definition()
+        if self.body is not None:
+            output["body"] = self.body.get_definition()
         return output
 
 
@@ -2925,6 +3012,7 @@ class ActionNode:
     #   | node=WhileLoopNode
     #   | node=ForLoopNode
     # 	| node=ControlNode
+    #   | node=TerminateNode
     # ;
     def __init__(self, definition):
         if valid_definition(definition, self.__class__.__name__):

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/semantic.py

@@ -257,6 +257,10 @@ class SymbolTable:
         self._definition_features: dict[str, dict[str, Any]] = {}  # definition_name -> {element, features, supertypes}
         self._duplicate_names: list[tuple[str, Any]] = []  # (name, element) for duplicates
 
+    def __repr__(self) -> str:
+        return (f"SymbolTable(symbols={len(self._symbols)}, "
+                f"children={len(self._children)})")
+
     # -- public API ----------------------------------------------------------
 
     def register(self, name: str, element: Any) -> None:
@@ -934,6 +938,9 @@ _KNOWN_LIBRARY_SYMBOLS = frozenset({
 class SemanticAnalyzer:
     """Analyzes a parsed SysML model for semantic issues."""
 
+    def __repr__(self) -> str:
+        return "SemanticAnalyzer()"
+
     def analyze(
         self,
         model: Any,

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/store.py

@@ -238,6 +238,11 @@ class InMemoryStore(Store):
         self._parents: dict[str, list[str]] = {}
         self._edges: dict[str, list[tuple[str, str, dict]]] = {}
 
+    def __repr__(self) -> str:
+        n_elem = len(self._elements)
+        n_edge = sum(len(v) for v in self._edges.values())
+        return f"InMemoryStore(elements={n_elem}, edges={n_edge})"
+
     def put(self, element_id: str, data: dict,
             parent_id: Optional[str] = None,
             rel_type: str = REL_PARENT_CHILD) -> None:
@@ -473,12 +478,17 @@ class NetworkXStore(Store):
             a MultiGraph for undirected relationships.
         """
         import networkx as nx
+        self._directed = directed
         if directed:
             self._graph = nx.MultiDiGraph()
         else:
             self._graph = nx.MultiGraph()
         self._nx = nx
 
+    def __repr__(self) -> str:
+        return (f"NetworkXStore(nodes={self._graph.number_of_nodes()}, "
+                f"edges={self._graph.number_of_edges()}, directed={self._directed})")
+
     def put(self, element_id: str, data: dict,
             parent_id: Optional[str] = None,
             rel_type: str = REL_PARENT_CHILD) -> None:
@@ -852,10 +862,14 @@ class KuzuStore(Store):
             Path to the database directory, or ":memory:" for in-memory mode.
         """
         import kuzu
+        self._database = database
         self._db = kuzu.Database(database)
         self._conn = kuzu.Connection(self._db)
         self._init_schema()
 
+    def __repr__(self) -> str:
+        return f"KuzuStore(database={self._database!r})"
+
     def _init_schema(self) -> None:
         """Create the node and relationship tables if they don't exist."""
         self._conn.execute(
@@ -1422,10 +1436,15 @@ class CayleyStore(Store):
         label : str
             Quad label namespace for isolating data.
         """
+        self._host = host
+        self._port = port
         self._base_url = f"http://{host}:{port}"
         self._label = label
         self._session = None
 
+    def __repr__(self) -> str:
+        return f"CayleyStore(host={self._host!r}, port={self._port}, label={self._label!r})"
+
     def _get_session(self):
         """Get or create a requests session."""
         if self._session is None:

{sysmlpy-0.28.1 → sysmlpy-0.30.0}/src/sysmlpy/usage.py

@@ -18,6 +18,20 @@ import os
 
 ureg = pint.UnitRegistry()
 
+
+def _is_uuid(s: str) -> bool:
+    """Return True if *s* looks like an auto-generated UUID4 string."""
+    if not isinstance(s, str) or len(s) != 36:
+        return False
+    parts = s.split('-')
+    if len(parts) != 5:
+        return False
+    lengths = [8, 4, 4, 4, 12]
+    return all(
+        len(p) == n and all(c in '0123456789abcdef' for c in p.lower())
+        for p, n in zip(parts, lengths)
+    )
+
 # Load custom US Customary unit definitions
 _us_customary_path = os.path.join(os.path.dirname(__file__), "us_customary_units.txt")
 if os.path.exists(_us_customary_path):
@@ -300,57 +314,56 @@ class Usage(Searchable):
         return classtree(self._get_definition(child)).dump()
 
     def __repr__(self):
-        """Return a developer-friendly string representation of this element.
+        """Return a constructor-mirroring string representation.
+
+        Output can be passed back to the class constructor to recreate an
+        equivalent (though unpopulated-grammar) instance::
 
-        Includes class name, definition flag, name, and shortname when available.
+            Part(definition=True, name='Engine')
+            Part(name='wheel', shortname='w')
+            Action()
 
         Returns
         -------
         str
-            String representation suitable for debugging.
         """
-        # Safely get name
-        try:
-            name = getattr(self, 'name', None)
-            if not name:
-                id_obj = getattr(self.grammar, 'usage', None)
-                if id_obj:
-                    id_obj = getattr(id_obj.declaration, 'declaration', None)
-                    if id_obj:
-                        name = getattr(id_obj.identification, 'declaredName', None)
-        except (AttributeError, TypeError):
+        # Use the is_definition property — reliable across all 29 subclasses
+        is_def = self.is_definition
+
+        # Suppress auto-generated UUID names (they are meaningless to callers)
+        name = getattr(self, 'name', None)
+        if name and _is_uuid(name):
             name = None
-        
-        # Safely get shortname
+
+        # Shortname from grammar when present — path differs by definition vs usage
+        shortname = None
         try:
-            shortname = None
             id_obj = getattr(self.grammar, 'usage', None)
             if id_obj:
                 id_obj = getattr(id_obj.declaration, 'declaration', None)
                 if id_obj:
                     shortname = getattr(id_obj.identification, 'declaredShortName', None)
+            if not shortname:
+                # Definition path: grammar.definition.declaration.identification.declaredShortName
+                def_obj = getattr(self.grammar, 'definition', None)
+                if def_obj:
+                    id_obj = getattr(def_obj, 'declaration', None)
+                    if id_obj:
+                        shortname = getattr(id_obj.identification, 'declaredShortName', None)
             if shortname:
                 shortname = shortname.strip('<').strip('>')
         except (AttributeError, TypeError):
             shortname = None
-            
-        is_def = hasattr(self.grammar, 'definition')
+
         cls_name = self.__class__.__name__
-        
+        parts = []
         if is_def:
-            if name and shortname:
-                return f"{cls_name}(definition=True, name={name!r}, shortname={shortname!r})"
-            elif name:
-                return f"{cls_name}(definition=True, name={name!r})"
-            else:
-                return f"{cls_name}(definition=True)"
-        else:
-            if name and shortname:
-                return f"{cls_name}(name={name!r}, shortname={shortname!r})"
-            elif name:
-                return f"{cls_name}(name={name!r})"
-            else:
-                return f"{cls_name}()"
+            parts.append('definition=True')
+        if name:
+            parts.append(f'name={name!r}')
+        if shortname:
+            parts.append(f'shortname={shortname!r}')
+        return f"{cls_name}({', '.join(parts)})"
 
     def _set_name(self, name, short=False):
         """Set the declared name or short name on the grammar element.