sysmlpy 0.45.0__tar.gz → 0.47.0__tar.gz

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.45.0
+Version: 0.47.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.45.0"
+version = "0.47.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/src/sysmlpy/__init__.py

@@ -25,14 +25,14 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.45.0"
+__version__ = "0.47.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
     State, Constraint, Connection, Flow, Calculation, Enumeration,
     Allocation, Metadata, Rendering, Individual, FlowDef,
     View, Viewpoint, Concern,
-    Case, AnalysisCase, VerificationCase,
+    Case, AnalysisCase, VerificationCase, Dependency,
 )
 
 from sysmlpy.definition import Model, Package

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/src/sysmlpy/antlr_visitor.py

@@ -826,6 +826,12 @@ def _visit_definition_element_dict(def_elem_ctx, prefix=None):
         # the round-trip dict preserves the `standard library` keywords.
         ctx = def_elem_ctx.libraryPackage()
         return _make_nested_package_dict(ctx, prefix, is_standard_library=True)
+    elif hasattr(def_elem_ctx, 'dependency') and def_elem_ctx.dependency():
+        # Issue #4: dependency statements were silently dropped. The grammar
+        # class Dependency is fully implemented but no visitor dispatch
+        # constructed it.
+        ctx = def_elem_ctx.dependency()
+        return _make_dependency_dict(ctx, prefix)
     elif hasattr(def_elem_ctx, 'itemDefinition') and def_elem_ctx.itemDefinition():
         ctx = def_elem_ctx.itemDefinition()
         return _make_item_definition_dict(ctx, prefix)
@@ -7470,14 +7476,15 @@ def _make_nested_connection_usage_dict(ctx, prefix=None):
 
 def _build_connector_part_dict(ctx):
     """Build a ConnectorPart dictionary from a connectorPart context.
-    
+
     Grammar:
       connectorPart : binaryConnectorPart | naryConnectorPart ;
       binaryConnectorPart : connectorEndMember TO connectorEndMember ;
+      naryConnectorPart : LPAREN connectorEndMember (COMMA connectorEndMember)* RPAREN ;
     """
     if ctx is None:
         return None
-    
+
     if hasattr(ctx, 'binaryConnectorPart') and ctx.binaryConnectorPart():
         bcp = ctx.binaryConnectorPart()
         owned_rel = []
@@ -7489,7 +7496,7 @@ def _build_connector_part_dict(ctx):
                 end_dict = _visit_connector_end_member(end)
                 if end_dict:
                     owned_rel.append(end_dict)
-        
+
         return {
             "name": "ConnectorPart",
             "part": {
@@ -7497,7 +7504,27 @@ def _build_connector_part_dict(ctx):
                 "ownedRelationship": owned_rel
             }
         }
-    
+
+    if hasattr(ctx, 'naryConnectorPart') and ctx.naryConnectorPart():
+        ncp = ctx.naryConnectorPart()
+        owned_rel = []
+        if hasattr(ncp, 'connectorEndMember') and ncp.connectorEndMember():
+            ends = ncp.connectorEndMember()
+            if not isinstance(ends, list):
+                ends = [ends]
+            for end in ends:
+                end_dict = _visit_connector_end_member(end)
+                if end_dict:
+                    owned_rel.append(end_dict)
+
+        return {
+            "name": "ConnectorPart",
+            "part": {
+                "name": "NaryConnectorPart",
+                "ownedRelationship": owned_rel
+            }
+        }
+
     return None
 
 
@@ -7918,20 +7945,30 @@ def _make_concern_usage_dict(ctx, prefix=None):
 
 def _make_allocation_usage_dict(ctx, prefix=None):
     """Create an AllocationUsage dictionary.
-    
+
     allocationUsage: occurrenceUsagePrefix allocationUsageDeclaration usageBody
+    allocationUsageDeclaration
+        : ALLOCATION usageDeclaration? (ALLOCATE connectorPart)?
+        | ALLOCATE connectorPart
+        ;
+
+    Issue #5: the connector endpoints (`allocate X to Y`) were silently
+    dropped before reaching the dict. Mirror the InterfaceUsage pattern:
+    walk `aud.connectorPart()` (when present) and emit a ConnectorPart
+    dict with binary or nary ends.
     """
     name = None
     shortname = None
+    connector_part = None
     if ctx is not None:
         aud = None
         if hasattr(ctx, 'allocationUsageDeclaration') and ctx.allocationUsageDeclaration():
             aud = ctx.allocationUsageDeclaration()
-        
+
         ud = None
         if aud and hasattr(aud, 'usageDeclaration') and aud.usageDeclaration():
             ud = aud.usageDeclaration()
-        
+
         if ud and hasattr(ud, 'identification') and ud.identification():
             ident = ud.identification()
             if hasattr(ident, 'name'):
@@ -7943,7 +7980,13 @@ def _make_allocation_usage_dict(ctx, prefix=None):
                     elif len(name_list) == 1:
                         name_text = name_list[0].getText()
                         name, shortname = _extract_name_shortname(name_text)
-    
+
+        # Issue #5: capture the `allocate X to Y` (or `allocate X, Y to Z`)
+        # connector part. Either standalone or appended after the
+        # allocation keyword + optional usageDeclaration.
+        if aud and hasattr(aud, 'connectorPart') and aud.connectorPart():
+            connector_part = _build_connector_part_dict(aud.connectorPart())
+
     return {
         "name": "PackageMember",
         "prefix": None,
@@ -7968,6 +8011,7 @@ def _make_allocation_usage_dict(ctx, prefix=None):
                                 "specialization": None
                             }
                         },
+                        "connectorPart": connector_part,
                         "body": {
                             "name": "UsageBody",
                             "body": {
@@ -8117,6 +8161,134 @@ def _make_individual_usage_dict(ctx, prefix=None):
     }
 
 
+def _make_dependency_dict(ctx, member_prefix=None):
+    """Create a Dependency dictionary.
+
+    Grammar (SysML v2):
+      dependency
+        : (prefixMetadataAnnotation)* DEPENDENCY (identification? FROM)?
+            qualifiedName (COMMA qualifiedName)* TO qualifiedName
+            (COMMA qualifiedName)* relationshipBody
+        | (prefixMetadataAnnotation)* DEPENDENCY dependencyDeclaration
+            relationshipBody
+        ;
+
+    Wrapped in PackageMember + DefinitionElement so the loader places it in
+    the enclosing package / namespace body.
+    """
+    if ctx is None:
+        return None
+
+    identification = None
+    clients = []
+    suppliers = []
+    body = {"name": "RelationshipBody", "ownedRelationship": []}
+
+    if hasattr(ctx, 'dependencyDeclaration') and ctx.dependencyDeclaration():
+        # Alternative 2: dependencyDeclaration carries identification / FROM /
+        # client-list / supplier-list / TO. relationshipBody is the next
+        # sibling on the dependency context.
+        dep_decl = ctx.dependencyDeclaration()
+        if hasattr(dep_decl, 'identification') and dep_decl.identification():
+            identification = _build_identification_dict(dep_decl.identification())
+        qn_list = dep_decl.qualifiedName()
+        if not isinstance(qn_list, list):
+            qn_list = [qn_list] if qn_list is not None else []
+        # Split on TO: first batch is clients, second batch is suppliers.
+        to_token = dep_decl.TO()
+        if to_token is not None:
+            # ANTLR TerminalNodeImpl doesn't expose `.start` directly; use
+            # `.symbol.start` (the underlying token's char position).
+            to_start = to_token.symbol.start
+            split_idx = len(qn_list)
+            for i, qn in enumerate(qn_list):
+                if qn.start.start > to_start:
+                    split_idx = i
+                    break
+            clients = qn_list[:split_idx]
+            suppliers = qn_list[split_idx:]
+        else:
+            clients = qn_list
+        # relationshipBody sits on the parent dependency context
+        if hasattr(ctx, 'relationshipBody') and ctx.relationshipBody():
+            body = _visit_dependency_relationship_body_dict(ctx.relationshipBody())
+    else:
+        # Alternative 1: bare `dependency [ident]? [from]? qn , qn , ... to qn , qn , ... {body}`
+        if hasattr(ctx, 'identification') and ctx.identification():
+            identification = _build_identification_dict(ctx.identification())
+        qn_list = ctx.qualifiedName()
+        if not isinstance(qn_list, list):
+            qn_list = [qn_list] if qn_list is not None else []
+        to_token = ctx.TO()
+        if to_token is not None:
+            to_start = to_token.symbol.start
+            split_idx = len(qn_list)
+            for i, qn in enumerate(qn_list):
+                if qn.start.start > to_start:
+                    split_idx = i
+                    break
+            clients = qn_list[:split_idx]
+            suppliers = qn_list[split_idx:]
+        else:
+            clients = qn_list
+        if hasattr(ctx, 'relationshipBody') and ctx.relationshipBody():
+            body = _visit_dependency_relationship_body_dict(ctx.relationshipBody())
+
+    return {
+        "name": "PackageMember",
+        "prefix": member_prefix,
+        "ownedRelatedElement": {
+            "name": "DefinitionElement",
+            "ownedRelatedElement": {
+                "name": "Dependency",
+                "identification": identification,
+                "clients": [
+                    {"name": "QualifiedName", "names": qn.getText().split("::")}
+                    for qn in clients if qn is not None
+                ],
+                "suppliers": [
+                    {"name": "QualifiedName", "names": qn.getText().split("::")}
+                    for qn in suppliers if qn is not None
+                ],
+                "body": body,
+            }
+        }
+    }
+
+
+def _visit_dependency_relationship_body_dict(rb_ctx):
+    """Capture a dependency's relationshipBody.
+
+    Mirrors the aliasMember pattern: walk the body for any
+    OwnedAnnotation / CommentSysML so doc comments survive the round-trip.
+    For the `;` form (empty body), returns the empty shape.
+    """
+    if rb_ctx is None:
+        return {"name": "RelationshipBody", "ownedRelationship": []}
+    owned = []
+    for child in rb_ctx.children:
+        if type(child).__name__ == 'RelationshipOwnedElementContext':
+            for c2 in child.children:
+                if type(c2).__name__ == 'OwnedAnnotationContext':
+                    for c3 in c2.children:
+                        if type(c3).__name__ == 'AnnotatingElementContext':
+                            owned.append({
+                                "name": "OwnedAnnotation",
+                                "ownedRelatedElement": [
+                                    {
+                                        "name": "AnnotatingElement",
+                                        "ownedRelatedElement": {
+                                            "name": "CommentSysML",
+                                            "body": c3.getText(),
+                                            "identification": None,
+                                            "ownedRelationship": []
+                                        }
+                                    }
+                                ]
+                            })
+    return {"name": "RelationshipBody", "ownedRelationship": owned}
+
+
 def _make_enumeration_definition_dict(ctx, member_prefix=None):
     """Create an EnumerationDefinition dictionary.
     

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/src/sysmlpy/definition.py

@@ -20,7 +20,7 @@ from sysmlpy.grammar.classes import (
 )
 from sysmlpy.grammar.classes import Package as PackageGrammar
 
-from sysmlpy import Part, Item, Port, Requirement, UseCase, Attribute, Action, Case, AnalysisCase, VerificationCase, Interface, Message
+from sysmlpy import Part, Item, Port, Requirement, UseCase, Attribute, Action, Case, AnalysisCase, VerificationCase, Interface, Message, Dependency
 from sysmlpy.usage import (
     State, Constraint, Connection, Flow, Calculation, Enumeration,
     Allocation, Metadata, Rendering, Individual, FlowDef,
@@ -1299,6 +1299,16 @@ class Package(Searchable):
                             r.name = feat_decl.identification.declaredName
                 r.parent = self
                 self.children.append(r)
+            elif inner_class == "Dependency":
+                # Issue #4: dependency statements were silently dropped
+                # because no visitor dispatch produced a Dependency dict and
+                # Package.load_from_grammar had no branch for it.
+                d = Dependency()
+                d.grammar = inner_element
+                if hasattr(inner_element, 'identification') and inner_element.identification:
+                    d.name = inner_element.identification.declaredName
+                d.parent = self
+                self.children.append(d)
             else:
                 print(f"[Package.load_from_grammar] Unknown class: {inner_class} - skipping")  # pragma: no cover
         

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/src/sysmlpy/grammar/classes.py

@@ -226,6 +226,17 @@ class DefinitionElement:
                 self.children.append(
                     InterfaceUsage(definition["ownedRelatedElement"])
                 )
+            elif de == "Dependency":
+                # Issue #4: dependency statements were silently dropped
+                # because no visitor dispatch produced a Dependency dict and
+                # no DefinitionElement branch constructed it.
+                self.children.append(Dependency(definition["ownedRelatedElement"]))
+            elif de == "LibraryPackage":
+                # `standard library package Foo { ... }` shares the same
+                # {identification, body} shape as `package Foo { ... }` plus
+                # an isStandardLibrary flag. Reuse Package; the flag is read
+                # from the dict in Package.__init__.
+                self.children.append(Package(definition["ownedRelatedElement"]))
             else:
                 print(f"Unknown DefinitionElement type: {de}")  # pragma: no cover
 
@@ -7375,6 +7386,8 @@ class ConnectorPart:
         if valid_definition(definition, self.__class__.__name__):
             if definition["part"]["name"] == "BinaryConnectorPart":
                 self.part = BinaryConnectorPart(definition["part"])
+            elif definition["part"]["name"] == "NaryConnectorPart":
+                self.part = NaryConnectorPart(definition["part"])
             else:
                 print(f"ConnectorPart: unhandled {definition['part']['name']}")  # pragma: no cover
                 self.part = None  # pragma: no cover
@@ -7406,6 +7419,23 @@ class BinaryConnectorPart:
         }
 
 
+class NaryConnectorPart:
+    def __init__(self, definition):
+        if valid_definition(definition, self.__class__.__name__):
+            self.children = []
+            for relationship in definition["ownedRelationship"]:
+                self.children.append(ConnectorEndMember(relationship))
+
+    def dump(self):
+        return "(" + ", ".join([child.dump() for child in self.children]) + ")"
+
+    def get_definition(self):
+        return {
+            "name": self.__class__.__name__,
+            "ownedRelationship": [c.get_definition() for c in self.children],
+        }
+
+
 class ConnectorEndMember:
     def __init__(self, definition):
         if valid_definition(definition, self.__class__.__name__):
@@ -9778,6 +9808,12 @@ class Dependency:
         output = [self.keyword]
         if self.identification is not None:
             output.append(self.identification.dump())
+            # Issue #4: the ANTLR grammar ambiguity means an unnamed-form
+            # `dependency name a to X;` is unparseable — `name` is taken as
+            # the identification and `a` then has nowhere to go. To round-trip
+            # safely we always emit `from` between the identification and the
+            # client list.
+            output.append("from")
         output.append(", ".join([c.dump() for c in self.clients]))
         output.append("to")
         output.append(", ".join([s.dump() for s in self.suppliers]))
@@ -9845,8 +9881,39 @@ class _PrefixedUsageBase:
 
 class AllocationUsage(_PrefixedUsageBase):
     # allocationUsage : occurrenceUsagePrefix ALLOCATION usageDeclaration? usageBody
+    # allocationUsageDeclaration : ALLOCATION usageDeclaration? (ALLOCATE connectorPart)?
+    #                          | ALLOCATE connectorPart
     keyword = "allocation"
 
+    def __init__(self, definition=None):
+        super().__init__(definition)
+        self.connectorPart = None
+        if definition is not None and valid_definition(definition, self.__class__.__name__):
+            if definition.get("connectorPart") is not None:
+                self.connectorPart = ConnectorPart(definition["connectorPart"])
+
+    def dump(self):
+        parts = []
+        if self.prefix is not None:
+            parts.append(self.prefix.dump())
+        # Render as `allocation [name] [allocate X to Y]`
+        parts.append(self.keyword)
+        if self.declaration is not None:
+            decl_dump = self.declaration.dump()
+            if decl_dump:
+                parts.append(decl_dump)
+        if self.connectorPart is not None:
+            parts.append("allocate")
+            parts.append(self.connectorPart.dump())
+        if self.body is not None:
+            parts.append(self.body.dump())
+        return " ".join(parts)
+
+    def get_definition(self):
+        output = super().get_definition()
+        output["connectorPart"] = self.connectorPart.get_definition() if self.connectorPart else None
+        return output
+
 
 class RenderingUsage(_PrefixedUsageBase):
     # renderingUsage : occurrenceUsagePrefix RENDERING usage

{sysmlpy-0.45.0 → sysmlpy-0.47.0}/src/sysmlpy/usage.py

@@ -4285,3 +4285,70 @@ class DefaultReference(Usage):
     #             )
 
     #     return package
+
+
+class Dependency(Usage):
+    """SysML v2 Dependency usage.
+
+    Represents a UML-style dependency between model elements.
+    Usage:
+        Dependency()                                  # dependency ;
+        Dependency(name='D')                         # dependency D from x to y;
+    """
+    sysml_type = 'dependency'
+
+    def __init__(self, name=None, clients=None, suppliers=None, shortname=None):
+        Usage.__init__(self)
+        self.grammar = None
+        self.clients = clients or []
+        self.suppliers = suppliers or []
+        # Usage.__init__ assigns a UUID-based name; override to None when
+        # the dependency is anonymous (the common case for
+        # `dependency b to A;`).
+        self.name = name
+        if shortname is not None:
+            self._set_name(shortname, short=True)
+
+    def dump(self):
+        # Issue #4: dependencies are emitted from the grammar tree; this
+        # method exists for compatibility with the Usage API.
+        if self.grammar is not None and hasattr(self.grammar, 'dump'):
+            return self.grammar.dump()
+        return "dependency"
+
+    def _get_definition(self, child=None):
+        """Build a PackageMember-wrapped Dependency dict for the model tree.
+
+        The Dependency grammar class returns the bare inner shape
+        (`{"name": "Dependency", "identification": ..., "clients": ...,
+        "suppliers": ..., "body": ...}`). For inclusion in a package body
+        we wrap it the same way other definitions are wrapped:
+        `PackageMember -> DefinitionElement -> Dependency`.
+        """
+        if self.grammar is not None and hasattr(self.grammar, 'get_definition'):
+            grammar_def = self.grammar.get_definition()
+        else:
+            grammar_def = {
+                "name": "Dependency",
+                "identification": None,
+                "clients": [],
+                "suppliers": [],
+                "body": None,
+            }
+        # Sync identification name
+        if self.name is not None and grammar_def.get("identification"):
+            grammar_def["identification"]["declaredName"] = self.name
+        elif self.name is not None:
+            grammar_def["identification"] = {
+                "name": "Identification",
+                "declaredName": self.name,
+                "declaredShortName": None,
+            }
+        return {
+            "name": "PackageMember",
+            "prefix": None,
+            "ownedRelatedElement": {
+                "name": "DefinitionElement",
+                "ownedRelatedElement": grammar_def,
+            },
+        }