sysmlpy 0.56.0__tar.gz → 0.59.0__tar.gz

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/PKG-INFO

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

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/pyproject.toml

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

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/__init__.py

@@ -25,7 +25,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.56.0"
+__version__ = "0.59.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/antlr_visitor.py

@@ -7148,10 +7148,12 @@ def _extract_multiplicity_from_mp(mp_ctx):
         else:
             return None
         
+        is_ordered = bool(mp_ctx.ORDERED()) if hasattr(mp_ctx, 'ORDERED') else False
+        is_nonunique = bool(mp_ctx.NONUNIQUE()) if hasattr(mp_ctx, 'NONUNIQUE') else False
         return {
             "name": "MultiplicityPart",
-            "isOrdered": False,
-            "isNonunique": False,
+            "isOrdered": is_ordered,
+            "isNonunique": is_nonunique,
             "ownedRelationship": [
                 {
                     "name": "OwnedMultiplicity",
@@ -13597,11 +13599,18 @@ def _get_multiplicity_part(fsp_ctx):
             bound_dicts = [_make_bound(members[0].getText()), _make_bound(members[1].getText())]
         else:
             return None
-        
+
+        # ORDERED / NONUNIQUE indicators follow ownedMultiplicity in
+        # multiplicityPart (grammar: `ownedMultiplicity ( ORDERED ( NONUNIQUE )?
+        # | NONUNIQUE ( ORDERED )? )?`).  Previously hardcoded False, silently
+        # dropping the keywords on dump.
+        is_ordered = bool(mp_ctx.ORDERED()) if hasattr(mp_ctx, 'ORDERED') else False
+        is_nonunique = bool(mp_ctx.NONUNIQUE()) if hasattr(mp_ctx, 'NONUNIQUE') else False
+
         return {
             "name": "MultiplicityPart",
-            "isOrdered": False,
-            "isNonunique": False,
+            "isOrdered": is_ordered,
+            "isNonunique": is_nonunique,
             "ownedRelationship": [
                 {
                     "name": "OwnedMultiplicity",

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/definition.py

@@ -170,28 +170,46 @@ class Model(Searchable):
     def _ensure_body(self):
         """Rebuild the grammar body from current children and imports.
 
-        Serializes all child elements into PackageMember wrappers and
-        preserves any existing Import or AliasMember entries. Updates
-        self.grammar with the reconstructed RootNamespace.
+        Serializes all child elements into PackageMember wrappers while
+        preserving ``Import`` and ``AliasMember`` declarations **at their
+        original source positions** (v0.58.0).  The existing grammar body
+        is used as the ordering template: each ``PackageMember`` slot is
+        refilled with the fresh serialization of the next child, and any
+        children beyond the recorded slots are appended at the end.
 
         Returns
         -------
         Model
             Self for chaining.
         """
-        body = []
+        # Serialize all current children into PackageMember definitions
+        child_defs = []
         for abc in self.children:
             v = abc._get_definition(child="PackageBody")
             if isinstance(v, list):
                 for subchild in v:
-                    body.append(PackageMember(subchild).get_definition())
+                    child_defs.append(PackageMember(subchild).get_definition())
             else:
-                body.append(PackageMember(v).get_definition())
+                child_defs.append(PackageMember(v).get_definition())
 
-        if hasattr(self, 'grammar') and self.grammar:
-            for child in self.grammar.children:
-                if child.__class__.__name__ in ('Import', 'AliasMember'):
-                    body.append(child.get_definition())
+        existing = getattr(getattr(self, 'grammar', None), 'children', None)
+
+        body = []
+        if existing:
+            member_iter = iter(child_defs)
+            for item in existing:
+                cn = item.__class__.__name__
+                if cn in ('Import', 'AliasMember'):
+                    body.append(item.get_definition())
+                elif cn == 'PackageMember':
+                    try:
+                        body.append(next(member_iter))
+                    except StopIteration:
+                        break  # children shrank; drop stale members
+            # children added programmatically beyond recorded slots
+            body.extend(member_iter)
+        else:
+            body = child_defs
 
         if len(body) > 0:
             self.grammar = RootNamespace(
@@ -567,22 +585,43 @@ class Package(Searchable):
     def _ensure_body(self):
         """Rebuild the package grammar body from current children and imports.
 
-        Serializes all child elements into PackageMember wrappers and
-        preserves any existing Import or AliasMember entries.
+        Serializes all child elements into PackageMember wrappers while
+        preserving ``Import`` and ``AliasMember`` declarations **at their
+        original source positions** (v0.58.0).  The existing grammar body
+        is used as the ordering template: each ``PackageMember`` slot is
+        refilled with the fresh serialization of the next child, and any
+        children beyond the recorded slots are appended at the end.
         """
-        body = []
+        # Serialize all current children into PackageMember definitions
+        child_defs = []
         for abc in self.children:
             v = abc._get_definition(child="PackageBody")
             if isinstance(v, list):
                 for subchild in v:
-                    body.append(PackageMember(subchild).get_definition())
+                    child_defs.append(PackageMember(subchild).get_definition())
             else:
-                body.append(PackageMember(v).get_definition())
+                child_defs.append(PackageMember(v).get_definition())
 
-        if hasattr(self.grammar, 'body') and self.grammar.body:
-            for child in self.grammar.body.children:
-                if child.__class__.__name__ in ('Import', 'AliasMember'):
-                    body.append(child.get_definition())
+        body_children = getattr(
+            getattr(getattr(self, 'grammar', None), 'body', None), 'children', None
+        )
+
+        body = []
+        if body_children:
+            member_iter = iter(child_defs)
+            for item in body_children:
+                cn = item.__class__.__name__
+                if cn in ('Import', 'AliasMember'):
+                    body.append(item.get_definition())
+                elif cn == 'PackageMember':
+                    try:
+                        body.append(next(member_iter))
+                    except StopIteration:
+                        break  # children shrank; drop stale members
+            # children added programmatically beyond recorded slots
+            body.extend(member_iter)
+        else:
+            body = child_defs
 
         if len(body) > 0:
             self.grammar.body = PackageBody(

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/examples/attribute_values.py

@@ -107,8 +107,9 @@ print(f"\nColors as list: {colors}")
 # 5. Type Resolution
 # =============================================================================
 
-# The type is stored in the grammar structure.
-# typedby may not be populated during load_from_grammar (known issue).
+# The declared type name is preserved on load (v0.57.0): use
+# attr.typed_by_name. The resolved definition object (`typedby`) still
+# requires programmatic wiring via set_typed_by().
 
 model = loads('''
 package Example {
@@ -122,15 +123,16 @@ package Example {
 vehicle = model.children[0].children[0]
 
 for attr in vehicle.children:
-    # Access grammar to see type info
-    print(f"{attr.name}: grammar type = {type(attr.grammar).__name__}")
+    # typed_by_name carries the declared type name since v0.57.0
+    print(f"{attr.name}: declared type = {attr.typed_by_name}")
 
 # =============================================================================
 # 6. Attribute Multiplicity
 # =============================================================================
 
 # Attributes can have multiplicity like Real[3] for arrays
-# The type information is stored in the grammar but not yet exposed via Python API
+# Note: top-level (package-level) attribute multiplicity is still a known
+# visitor gap; multiplicity on attributes inside definitions is preserved.
 
 model = loads('''
 package Example {

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/examples/part_attributes.py

@@ -97,7 +97,9 @@ print(f"\nAfter setting: {attr.get_value()}")
 # 5. Checking Type
 # =============================================================================
 
-# NOTE: typedby is populated during load_from_grammar but may need verification
+# NOTE (v0.57.0): the declared type name is preserved on load via
+# `typed_by_name`; the resolved definition object (`typedby`) requires
+# programmatic wiring via set_typed_by().
 
 model = loads('''
 package Example {
@@ -111,11 +113,11 @@ package Example {
 vehicle = model.children[0].children[0]
 
 for attr in vehicle.children:
-    if attr.typedby:
-        print(f"{attr.name} : {attr.typedby.name}")
+    if attr.typed_by_name:
+        print(f"{attr.name} : {attr.typed_by_name}")
     else:
         # Access type from grammar structure
-        print(f"{attr.name} : (type in grammar, typedby not populated)")
+        print(f"{attr.name} : (type in grammar, typing not declared)")
 
 # =============================================================================
 # 6. Nested Parts

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/grammar/classes.py

@@ -8380,15 +8380,16 @@ class MultiplicityPart:
     def dump(self):
         output = [child.dump() for child in self.children]
 
-        if self.isOrdered and not self.isOrdered2:
+        # isOrdered/isOrdered2 are populated from the same dict field during
+        # round-trip (the ANTLR dict carries a single isOrdered flag), so the
+        # X OR Y logic below never fired — silently dropping the keyword on
+        # `attribute x[3] ordered;`. Emit whichever flag is set (v0.59.0).
+        if self.isOrdered or self.isOrdered2:
             output.append("ordered")
 
         if self.isNonunique or self.isNonunique2:
             output.append("nonunique")
 
-        if self.isOrdered2 and not self.isOrdered:
-            output.append("ordered")
-
         return " ".join(output)
 
     def get_definition(self):

{sysmlpy-0.56.0 → sysmlpy-0.59.0}/src/sysmlpy/usage.py

@@ -167,6 +167,13 @@ class Usage(Searchable):
         self.typedby = None
         self._is_definition = None  # overridden via the setter below
         self.parent = None
+        # Re-declaration chains captured from grammar (v0.57.0).
+        # Previously only Action initialized these; all other usage kinds
+        # loaded from grammar lost their typing / subsetting information.
+        self._typed_by_name = None
+        self._specializes_names = []
+        self._redefined_refs = []
+        self._referenced_refs = []
 
     @property
     def is_definition(self):
@@ -354,6 +361,22 @@ class Usage(Searchable):
             return rn
         return ""
 
+    @property
+    def typed_by_name(self):
+        """The declared type of this usage as a name string (v0.57.0).
+
+        Populated by ``load_from_grammar`` from the grammar's feature
+        specialization (``part engine : Engine`` → ``"Engine"``,
+        ``attribute mass : ScalarValues::Real`` → ``"ScalarValues::Real"``).
+        ``None`` when the element was not loaded from grammar or carries
+        no typing relationship.
+
+        Note: this is the *declared name*; ``self.typedby`` holds the
+        resolved definition object (only when set programmatically via
+        ``set_typed_by`` or when a second resolution pass has run).
+        """
+        return getattr(self, '_typed_by_name', None)
+
     def _get_definition(self, child=None):
         """Build the grammar tree dict for this element.
 
@@ -1038,6 +1061,96 @@ class Usage(Searchable):
                             c.parent = self
                             self.children.append(c)
 
+        self._extract_specialization_info(grammar)
+
+        return self
+
+    def _extract_specialization_info(self, grammar):
+        """Capture Typings / Subsettings / Redefinitions / References names
+        from the grammar's feature specialization so ``_typed_by_name`` and
+        friends are populated on every usage kind loaded from grammar
+        (v0.57.0 — previously only ``Action`` did this, leaving ``Part``,
+        ``Attribute``, ``Item``, ``Port``, etc. without typing information
+        on the public-API object even though the grammar object kept it).
+
+        Handles both grammar layouts:
+          - usage-style: ``grammar.usage.declaration.declaration.specialization``
+            (PartUsage, AttributeUsage, ItemUsage, PortUsage, ...)
+          - behavior-style: ``grammar.declaration.declaration.declaration.specialization``
+            (ActionUsage, ...)
+        """
+        spec = None
+        g = getattr(grammar, 'grammar', grammar)
+        ud = getattr(g, 'usage', None)
+        if ud is not None and getattr(ud, 'declaration', None) is not None:
+            d = ud.declaration
+            if not hasattr(d, 'declaration'):
+                spec = getattr(d, 'specialization', None)
+            else:
+                inner = getattr(d, 'declaration', None)
+                spec = getattr(inner, 'specialization', None) if inner is not None else None
+        else:
+            node = getattr(g, 'declaration', None)
+            for _ in range(3):
+                if node is None or hasattr(node, 'specialization'):
+                    break
+                node = getattr(node, 'declaration', None)
+            spec = getattr(node, 'specialization', None) if node is not None else None
+        if spec is None:
+            return
+        for fs in getattr(spec, 'specializations', None) or []:
+            rel = getattr(fs, 'relationship', None)
+            kind = rel.__class__.__name__ if rel is not None else None
+            if kind == 'Typings':
+                tb = getattr(rel, 'typing', None)
+                for ft in getattr(tb, 'relationships', []) or []:
+                    rel2 = getattr(ft, 'relationship', None)
+                    ftype = getattr(rel2, 'type', None)
+                    qn = getattr(ftype, 'type', None)
+                    names = getattr(qn, 'names', None)
+                    if names:
+                        self._typed_by_name = '::'.join(names)
+                        break
+                    elements = getattr(ftype, 'elements', None) or []
+                    seg_names = []
+                    for el in elements:
+                        if hasattr(el, 'names') and el.names:
+                            seg_names.extend(el.names)
+                        elif hasattr(el, 'feature'):
+                            for seg in getattr(el.feature, 'children', []) or []:
+                                cf = getattr(seg, 'chainingFeature', None)
+                                if cf is not None and getattr(cf, 'names', None):
+                                    seg_names.extend(cf.names)
+                    if seg_names:
+                        self._typed_by_name = '.'.join(seg_names)
+                        break
+            elif kind in ('Subsettings', 'Redefinitions', 'References'):
+                target = (
+                    self._specializes_names if kind == 'Subsettings'
+                    else self._redefined_refs if kind == 'Redefinitions'
+                    else self._referenced_refs
+                )
+                for child in getattr(rel, 'children', None) or []:
+                    qn = (
+                        getattr(child, 'redefinedFeature', None)
+                        or getattr(child, 'referencedFeature', None)
+                    )
+                    if qn is not None and getattr(qn, 'names', None):
+                        target.append('::'.join(qn.names))
+                        continue
+                    elements = getattr(child, 'elements', None) or []
+                    seg_names = []
+                    for el in elements:
+                        if hasattr(el, 'names') and el.names:
+                            seg_names.extend(el.names)
+                        elif hasattr(el, 'feature'):
+                            for seg in getattr(el.feature, 'children', []) or []:
+                                cf = getattr(seg, 'chainingFeature', None)
+                                if cf is not None and getattr(cf, 'names', None):
+                                    seg_names.extend(cf.names)
+                    if seg_names:
+                        target.append('.'.join(seg_names))
+
         return self
 
     def add_directed_feature(self, direction, name=str(uuidlib.uuid4())):
@@ -1131,25 +1244,31 @@ def _load_behavior_child(parent, inner, inner_name):
                         return name_obj.getText()
         return None
 
+    # Behavior usages created without load_from_grammar still capture their
+    # typing from the grammar's feature specialization (v0.57.0).
     if inner_name == "AssertConstraintUsage":
         c = Constraint()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "ConstraintUsage":
         c = Constraint()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "CalculationUsage":
         c = Calculation()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "StateUsage":
         c = State()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "ActionUsage":
         c = Action(grammar=inner).load_from_grammar(inner)
@@ -1158,16 +1277,19 @@ def _load_behavior_child(parent, inner, inner_name):
         c = Requirement()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "SatisfyRequirementUsage":
         c = Requirement()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     if inner_name == "AllocationUsage":
         c = Allocation()
         c.grammar = inner
         c.name = _name_from_declaration(inner)
+        c._extract_specialization_info(inner)
         return c
     return None
 
@@ -1910,7 +2032,9 @@ class Interface(Usage):
                         feat_decl = inner_decl.declaration
                         if hasattr(feat_decl, 'identification') and feat_decl.identification:
                             self.name = feat_decl.identification.declaredName
-        
+
+        self._extract_specialization_info(grammar)
+
         return self
 
 
@@ -2099,73 +2223,6 @@ class Action(Usage):
 
         return self
 
-    def _extract_specialization_info(self, grammar):
-        """Capture Typings / Subsettings / Redefinitions / References names
-        from the grammar's feature specialization so ``dump()`` can render
-        them (v0.41.0)."""
-        fd = None
-        if getattr(grammar, 'declaration', None) is not None:
-            ud = getattr(grammar.declaration, 'declaration', None)
-            if ud is not None:
-                fd = getattr(ud, 'declaration', None)
-        spec = getattr(fd, 'specialization', None) if fd is not None else None
-        if spec is None:
-            return
-        for fs in getattr(spec, 'specializations', None) or []:
-            rel = getattr(fs, 'relationship', None)
-            kind = rel.__class__.__name__ if rel is not None else None
-            if kind == 'Typings':
-                tb = getattr(rel, 'typing', None)
-                for ft in getattr(tb, 'relationships', []) or []:
-                    rel2 = getattr(ft, 'relationship', None)
-                    ftype = getattr(rel2, 'type', None)
-                    qn = getattr(ftype, 'type', None)
-                    names = getattr(qn, 'names', None)
-                    if names:
-                        self._typed_by_name = '::'.join(names)
-                        break
-                    elements = getattr(ftype, 'elements', None) or []
-                    seg_names = []
-                    for el in elements:
-                        if hasattr(el, 'names') and el.names:
-                            seg_names.extend(el.names)
-                        elif hasattr(el, 'feature'):
-                            for seg in getattr(el.feature, 'children', []) or []:
-                                cf = getattr(seg, 'chainingFeature', None)
-                                if cf is not None and getattr(cf, 'names', None):
-                                    seg_names.extend(cf.names)
-                    if seg_names:
-                        self._typed_by_name = '.'.join(seg_names)
-                        break
-            elif kind in ('Subsettings', 'Redefinitions', 'References'):
-                target = (
-                    self._specializes_names if kind == 'Subsettings'
-                    else self._redefined_refs if kind == 'Redefinitions'
-                    else self._referenced_refs
-                )
-                for child in getattr(rel, 'children', None) or []:
-                    qn = (
-                        getattr(child, 'redefinedFeature', None)
-                        or getattr(child, 'referencedFeature', None)
-                    )
-                    if qn is not None and getattr(qn, 'names', None):
-                        target.append('::'.join(qn.names))
-                        continue
-                    elements = getattr(child, 'elements', None) or []
-                    seg_names = []
-                    for el in elements:
-                        if hasattr(el, 'names') and el.names:
-                            seg_names.extend(el.names)
-                        elif hasattr(el, 'feature'):
-                            for seg in getattr(el.feature, 'children', []) or []:
-                                cf = getattr(seg, 'chainingFeature', None)
-                                if cf is not None and getattr(cf, 'names', None):
-                                    seg_names.extend(cf.names)
-                    if seg_names:
-                        target.append('.'.join(seg_names))
-
-        return self
-    
     def _extract_initial_node(self, node):
         """Extract the source name from an InitialNodeMember."""
         if hasattr(node, 'child') and node.child:
@@ -2766,7 +2823,9 @@ class UseCase(Usage):
                         feat_decl = inner_decl.declaration
                         if hasattr(feat_decl, 'identification') and feat_decl.identification:
                             self.name = feat_decl.identification.declaredName
-        
+
+        self._extract_specialization_info(grammar)
+
         return self
 
 
@@ -3044,7 +3103,9 @@ class Requirement(Usage):
                         pass  # could extract subject
                     elif child_class == "ActorMember":
                         pass  # could extract actors
-        
+
+        self._extract_specialization_info(grammar)
+
         return self
 
     def _extract_nested_requirements(self, def_body_item):
@@ -3611,7 +3672,9 @@ class State(_BehaviorUsage):
                 decl = decl.declaration
             if hasattr(decl, 'identification') and decl.identification:
                 self.name = decl.identification.declaredName
-        
+
+        self._extract_specialization_info(grammar)
+
         # Extract nested states, transitions, and actions from body
         # StateDefinition: grammar.body -> StateDefBody -> children -> StateBodyPart -> children -> items
         # StateUsage: grammar.body -> StateUsageBody -> children -> StateDefBody -> children -> StateBodyPart -> children -> items