sysmlpy 0.1.0__py3-none-any.whl

sysmlpy/examples/attribute_values.py

@@ -0,0 +1,161 @@
+"""Examples: Attribute Values, Types, and Complex Objects
+
+This document explains how sysmlpy handles different types of attribute values:
+- Simple values (strings, numbers)
+- Pint quantities with units
+- Tuples and lists (partial support)
+"""
+
+from sysmlpy import loads, Part, Attribute
+from sysmlpy.usage import ureg
+
+# =============================================================================
+# 1. Simple Values
+# =============================================================================
+
+# Strings
+model = loads('''
+package Example {
+    attribute name : String = "Tesla";
+}
+''')
+attr = model.children[0].children[0]
+print(f"String: {attr.name} = {attr.get_value()}")
+
+# Integers
+model = loads('''
+package Example {
+    attribute count : Integer = 42;
+}
+''')
+attr = model.children[0].children[0]
+print(f"Integer: {attr.name} = {attr.get_value()}")
+
+# Reals
+model = loads('''
+package Example {
+    attribute price : Real = 49999.99;
+}
+''')
+attr = model.children[0].children[0]
+print(f"Real: {attr.name} = {attr.get_value()}")
+
+# =============================================================================
+# 2. Pint Quantities with Units
+# =============================================================================
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute mass : Real = 1000 [kilogram];
+        attribute speed : Real = 60 [mile/hour];
+        attribute height : Real = 1.5 [meter];
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+
+for attr in vehicle.children:
+    val = attr.get_value()
+    print(f"{attr.name} = {val}")
+    if hasattr(val, 'magnitude'):
+        print(f"  magnitude: {val.magnitude}")
+        print(f"  units: {val.units}")
+
+# =============================================================================
+# 3. Setting Values Programmatically
+# =============================================================================
+
+attr = Attribute()
+attr._set_name("weight")
+
+# With pint Quantity
+attr.set_value(1500 * ureg.kilogram)
+print(f"\nAfter setting: {attr.get_value()}")
+
+# =============================================================================
+# 4. Tuples and Lists (LIMITED SUPPORT)
+# =============================================================================
+
+# NOTE: The ANTLR4 grammar has partial support for sequences.
+# Curly braces {} with commas do not currently parse.
+# Workaround: Use multiple single-value attributes and combine in code.
+
+# Workaround approach:
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute color1 : String = "red";
+        attribute color2 : String = "green";
+        attribute color3 : String = "blue";
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+colors = []
+for child in vehicle.children:
+    if isinstance(child, Attribute):
+        try:
+            colors.append(child.get_value())
+        except:
+            pass
+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).
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute mass : Real;
+        attribute name : String;
+    }
+}
+''')
+
+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__}")
+
+# =============================================================================
+# 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
+
+model = loads('''
+package Example {
+    attribute coords : Real[3];
+}
+''')
+attr = model.children[0].children[0]
+print(f"\nAttribute: {attr.name}")
+
+# =============================================================================
+# 7. Nested Attribute Bodies
+# =============================================================================
+
+# Attributes can contain nested elements (rare but valid)
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute sensors {
+            attribute temperature : Real;
+            attribute pressure : Real;
+        }
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+sensors = vehicle.children[0]
+print(f"\n{sensors.name} children: {[c.name for c in sensors.children]}")

sysmlpy/examples/part_attributes.py

@@ -0,0 +1,139 @@
+"""Examples: Checking Attributes of a Part
+
+NOTE: Currently, children are only loaded for 'part def' (definitions).
+      Using 'part' (usage) may not load nested children - this is a known limitation.
+"""
+
+from sysmlpy import loads, Part, Attribute
+from sysmlpy.usage import ureg
+
+# =============================================================================
+# 1. Basic Attribute Access
+# =============================================================================
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute maxSpeed : Real;
+        attribute mass : Real;
+        part Engine { }
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+
+print("All children:", vehicle.children)
+
+# Filter for attributes
+attrs = [c for c in vehicle.children if isinstance(c, Attribute)]
+print("Attributes:", [a.name for a in attrs])
+
+# Filter for nested parts
+nested_parts = [c for c in vehicle.children if isinstance(c, Part)]
+print("Nested parts:", [p.name for p in nested_parts])
+
+# =============================================================================
+# 2. Attribute Properties
+# =============================================================================
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute maxSpeed : Real;
+        attribute mass : Real = 1000 [kilogram];
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+
+for attr in vehicle.children:
+    print(f"\nAttribute: {attr.name}")
+    print(f"  is_definition: {type(attr.grammar).__name__ == 'AttributeDefinition'}")
+    print(f"  grammar type: {type(attr.grammar).__name__}")
+
+# =============================================================================
+# 3. Working with Values (Single Values)
+# =============================================================================
+
+# NOTE: get_value() requires the attribute to have been set with a value
+# and the valuepart to exist in the grammar. This is still being improved.
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute mass : Real = 1000 [kilogram];
+        attribute name : String = "Tesla";
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+
+for attr in vehicle.children:
+    try:
+        val = attr.get_value()
+        print(f"{attr.name} = {val}")
+    except Exception as e:
+        print(f"{attr.name}: get_value() needs valuepart - {type(e).__name__}")
+
+# =============================================================================
+# 4. Setting Values Programmatically
+# =============================================================================
+
+attr = Attribute()
+attr._set_name("weight")
+
+# Set with pint Quantity (recommended)
+attr.set_value(1500 * ureg.kilogram)
+print(f"\nAfter setting: {attr.get_value()}")
+
+# NOTE: Setting with strings has a known bug where get_value() fails to parse.
+# This will be fixed in a future update.
+# attr.set_value("1200 [kilogram]")  # BUG: get_value() fails after string assignment
+
+# =============================================================================
+# 5. Checking Type
+# =============================================================================
+
+# NOTE: typedby is populated during load_from_grammar but may need verification
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute mass : Real;
+        attribute name : String;
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+
+for attr in vehicle.children:
+    if attr.typedby:
+        print(f"{attr.name} : {attr.typedby.name}")
+    else:
+        # Access type from grammar structure
+        print(f"{attr.name} : (type in grammar, typedby not populated)")
+
+# =============================================================================
+# 6. Nested Parts
+# =============================================================================
+
+model = loads('''
+package Example {
+    part def Vehicle {
+        attribute mass : Real;
+        part Engine {
+            attribute displacement : Real;
+        }
+    }
+}
+''')
+
+vehicle = model.children[0].children[0]
+engine = vehicle.children[1]  # Engine
+
+print(f"\n{vehicle.name} contains: {[c.name for c in vehicle.children]}")
+print(f"{engine.name} contains: {[c.name for c in engine.children]}")

sysmlpy/examples/tuples_sequences.py

@@ -0,0 +1,231 @@
+"""Examples: Tuples and Sequences in SysML v2
+
+SysML v2 supports tuples/sequences for collections. This document explains
+the syntax and current status in sysmlpy.
+"""
+
+from sysmlpy import loads, Part, Attribute
+from sysmlpy.usage import ureg
+
+# =============================================================================
+# 1. Tuple Syntax in SysML v2
+# =============================================================================
+
+# SysML v2 uses parentheses with commas for tuples:
+#   attribute point : Anything[2] = (10, 20);
+#   attribute rgb : Anything[3] = (255, 128, 0);
+
+# =============================================================================
+# 2. Using Collections Library Types
+# =============================================================================
+
+# The Collections library (kernel/Collections.kerml) provides:
+#   - Array: Fixed-size multi-dimensional collection
+#   - List: Variable-size ordered collection
+#   - Set: Variable-size unordered unique collection
+#   - Bag: Variable-size unordered non-unique collection
+#   - Map: Collection of key-value pairs
+#   - KeyValuePair: A tuple of (key, value)
+
+print("=" * 60)
+print("Tuples and Sequences in SysML v2 - sysmlpy")
+print("=" * 60)
+
+# =============================================================================
+# 3. Current Status
+# =============================================================================
+
+print("\n3. Current Status")
+print("-" * 40)
+
+# Simple values: WORKING
+print("\nSimple values (Integer, Real, String, Boolean):")
+model = loads('''
+package Example {
+    attribute count : Integer = 42;
+    attribute price : Real = 19.99;
+    attribute name : String = "Widget";
+    attribute mass : Real = 100 [kilogram];
+}
+''')
+pkg = model.children[0]
+for attr in pkg.children:
+    try:
+        val = attr.get_value()
+        print(f"  {attr.name} = {val}")
+    except Exception as e:
+        print(f"  {attr.name}: ERROR - {type(e).__name__}")
+
+# Tuples: PARTIAL (parse succeeds but value extraction needs work)
+print("\nTuples like (10, 20):")
+try:
+    model = loads('''
+    package Example {
+        attribute point : Real[2] = (10, 20);
+    }
+    ''')
+    print("  SUCCESS - tuple parsing works!")
+except Exception as e:
+    print(f"  FAILED - {type(e).__name__}")
+    print("  (Known limitation: tuple syntax not yet fully supported)")
+
+# =============================================================================
+# 4. Recommended Workaround: Use Parts Instead of Tuples
+# =============================================================================
+
+print("\n4. Recommended Workaround: Use Parts with Named Fields")
+print("-" * 40)
+
+# Instead of tuples, use parts with named attributes:
+model = loads('''
+package Example {
+    /** A 2D position using a Part */
+    part def Position2D {
+        attribute x : Real = 10;
+        attribute y : Real = 20;
+    }
+    
+    /** RGB Color using a Part */
+    part def RGBColor {
+        attribute red : Integer = 255;
+        attribute green : Integer = 128;
+        attribute blue : Integer = 0;
+    }
+    
+    /** A vehicle with position and color */
+    part def Vehicle {
+        attribute mass : Real = 1000 [kilogram];
+        part position : Position2D;
+        part bodyColor : RGBColor;
+    }
+}
+''')
+
+# Get parts directly
+parts = [c for c in model.children[0].children if isinstance(c, Part)]
+print("\nPackage contents:")
+for part in parts:
+    print(f"  Part: {part.name}")
+
+# Find Vehicle
+vehicle = next((p for p in parts if p.name == 'Vehicle'), None)
+if vehicle:
+    print(f"\nVehicle '{vehicle.name}':")
+    for child in vehicle.children:
+        if isinstance(child, Attribute):
+            try:
+                print(f"  {child.name} = {child.get_value()}")
+            except Exception as e:
+                print(f"  {child.name}: (get_value pending)")
+        elif isinstance(child, Part):
+            print(f"  {child.name}:")
+            for subchild in child.children:
+                if isinstance(subchild, Attribute):
+                    try:
+                        print(f"    {subchild.name} = {subchild.get_value()}")
+                    except:
+                        pass
+
+# =============================================================================
+# 5. Alternative: Use Multiple Attributes
+# =============================================================================
+
+print("\n5. Alternative: Use Multiple Single-Value Attributes")
+print("-" * 40)
+
+model = loads('''
+package Example {
+    part def TemperatureReading {
+        attribute reading1 : Real;
+        attribute reading2 : Real;
+        attribute reading3 : Real;
+    }
+    
+    part sensor1 : TemperatureReading {
+        reading1 = 22.5 [degC];
+        reading2 = 23.0 [degC];
+        reading3 = 21.5 [degC];
+    }
+}
+''')
+
+pkg = model.children[0]
+parts = [c for c in pkg.children if isinstance(c, Part)]
+sensor = next((p for p in parts if p.name == 'sensor1'), None)
+if sensor:
+    print(f"\nTemperature readings for '{sensor.name}':")
+    for attr in sensor.children:
+        if isinstance(attr, Attribute):
+            try:
+                print(f"  {attr.name} = {attr.get_value()}")
+            except:
+                pass
+
+# =============================================================================
+# 6. Collections Library Reference
+# =============================================================================
+
+print("\n6. Collections Library Reference")
+print("-" * 40)
+
+print("""
+The kernel/Collections.kerml library provides these types:
+
+  datatype Collection          - Base collection type with 'elements' feature
+  datatype OrderedCollection   - Ordered collections
+  datatype UniqueCollection   - Collections with unique elements
+  
+  datatype Array              - Fixed-size multi-dimensional collection
+                              - Use 'dimensions' to specify shape
+                              - Use 'elements' for flattened access
+  
+  datatype List               - Variable-size ordered collection
+  datatype Set                - Variable-size unordered unique collection
+  datatype Bag                - Variable-size unordered non-unique collection
+  
+  datatype Map                - Collection of key-value pairs
+  datatype KeyValuePair       - A tuple of (key, value)
+  
+  datatype OrderedMap         - Ordered map
+
+Example usage in SysML:
+  import Collections::*;
+  
+  attribute measurements : List = #("temp1", "temp2", "temp3");
+  attribute dataPoint : KeyValuePair = (key = "x", val = 10);
+""")
+
+# =============================================================================
+# 7. Summary
+# =============================================================================
+
+print("\n" + "=" * 60)
+print("Summary: Tuple/Sequence Support in sysmlpy")
+print("=" * 60)
+print("""
++---------------------------+------------+
+| Feature                   | Status     |
++---------------------------+------------+
+| Simple values             | WORKS      |
+|   Integer, Real, String   |            |
+| Pint quantities           | WORKS      |
+|   Real = 100 [kilogram]   |            |
+| Tuples                     | PARTIAL    |
+|   (10, 20, 30)           | (parses)   |
+| Lists with #()           | NOT YET    |
+|   #("a", "b", "c")        |            |
++---------------------------+------------+
+
+Workarounds:
+1. Use structured types (parts) instead of tuples
+2. Use multiple single-value attributes
+3. Use Parts with named fields for complex data
+
+Recommended pattern:
+  part def Position2D {
+      attribute x : Real;
+      attribute y : Real;
+  }
+  
+  part origin : Position2D { x = 10; y = 20; }
+""")

sysmlpy/formatting.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 31 13:26:53 2023
+
+@author: christophercox
+"""
+
+from sysmlpy.grammar.classes import RootNamespace
+
+
+def remove_classes(model):
+    """An example docstring for a class definition."""
+    if type(model) == type(dict()):
+        output = {}
+        for element in model:
+            if not "_" in element[0] and not "parent" in element:
+                # Remove internal parsing elements
+                output[element] = remove_classes(model[element])
+    elif type(model) == type(list()):
+        # List of classes
+        output = []
+        for member in model:
+            output.append(remove_classes(member))
+    elif type(model) == type(None):
+        return None
+    elif type(model) == type(bool()) or type(model) == type(str()):
+        return model
+    else:
+        output = {"name": model.__class__.__name__}
+        model_out = remove_classes(model.__dict__)
+        output.update(model_out)
+
+    return output
+
+
+def reformat(model):
+    """An example docstring for a class definition."""
+    # Convert to dictionary format
+    model_out = {"name": model.__class__.__name__}
+    model_out.update(remove_classes(model.__dict__))
+
+    return model_out
+
+
+def classtree(model):
+    return RootNamespace(model)

sysmlpy/grammar/antlr4/README.md

@@ -0,0 +1,30 @@
+# SysML v2 — ANTLR4 Grammar
+
+ANTLR4 grammar for the [SysML v2](https://www.omg.org/spec/SysML/2.0) textual
+notation, automatically generated from the OMG specification grammar (KEBNF
+format).
+
+## Source
+
+- **Specification**: [Systems-Modeling/SysML-v2-Release](https://github.com/Systems-Modeling/SysML-v2-Release)
+- **Release tag**: `2026-03`
+- **Generator**: [daltskin/sysml-v2-grammar](https://github.com/daltskin/sysml-v2-grammar)
+
+## Grammar Structure
+
+| File | Description |
+|------|-------------|
+| `SysMLv2Lexer.g4` | Lexer grammar — keywords, operators, literals, whitespace |
+| `SysMLv2Parser.g4` | Parser grammar — full SysML v2 textual syntax |
+
+## Entry Point
+
+The start rule is `rootNamespace`.
+
+## License
+
+MIT — Copyright (c) 2026 J Dalton
+
+The SysML v2 specification grammar is owned by the Object Management Group
+(OMG).  This project provides a derived ANTLR4 translation of the official
+KEBNF grammar.