sysmlpy 0.29.0__tar.gz → 0.30.0__tar.gz

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

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

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

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

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

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

{sysmlpy-0.29.0 → 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.29.0 → 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.29.0 → 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.29.0 → 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.