longeron 0.2.0__py3-none-any.whl

longeron-0.2.0.dist-info/METADATA

@@ -0,0 +1,449 @@
+Metadata-Version: 2.4
+Name: longeron
+Version: 0.2.0
+Summary: Define, execute, and replay SysML v2 models in Python: ANTLR-based parser, validator, interpreter, and diagram renderers
+Author: sanbales
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/sanbales/longeron
+Project-URL: Repository, https://github.com/sanbales/longeron
+Keywords: sysml,sysml2,kerml,mbse,systems-engineering,modeling
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: antlr4-python3-runtime==4.13.2
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: pyecore>=0.15; extra == "dev"
+Requires-Dist: nbformat>=5; extra == "dev"
+Requires-Dist: nbclient>=0.10; extra == "dev"
+Requires-Dist: ipykernel>=6; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: anywidget>=0.9; extra == "dev"
+Provides-Extra: ecore
+Requires-Dist: pyecore>=0.15; extra == "ecore"
+Provides-Extra: replay
+Requires-Dist: anywidget>=0.9; extra == "replay"
+Dynamic: license-file
+
+# Longeron
+
+*The spine of your system model* — a Python package that defines,
+exports, imports, and **executes** SysML v2 models (import name:
+`sysml2`). The parsers are generated with ANTLR 4 from combined grammars
+for SysML v2 and KerML, taken from
+[hivecore-dev/hcf-runtime](https://github.com/hivecore-dev/hcf-runtime)
+(`SysML.g4`, `KerML.g4`, with local patches — see
+[Grammar patches](#grammar-patches)).
+
+> SysML® is a registered trademark of the Object Management Group. This
+> project is not affiliated with or endorsed by OMG, and is not a
+> conformance-certified implementation.
+
+## Capabilities
+
+| Verb | What you get |
+|---|---|
+| **Define** | Parse SysML v2 textual notation into a fully-typed Python object model, import a model from its JSON export, or build models programmatically from dataclasses. Multi-file workspaces merge under one root; a content-addressed cache makes warm loads ~1000x faster. |
+| **Export** | Serialize any model to JSON, back to parseable SysML v2 text, project it onto KerML, or emit OMG Systems-Modeling-API JSON records. Parse → print → parse round-trips preserve the model; JSON → model → JSON is lossless. |
+| **Validate** | `sysml2.validate()` / `sysml2 lint`: dangling references, expression-name typos, duplicate names, specialization cycles, state-machine problems. Names resolve against the vendored standard library (a bare `Real` passes with no import; a typo like `Reall` warns), and plain definitions carry their *implied* specializations (`part def` → `Parts::Part`, `action def` → `Actions::Action`, which is how `start`/`done` resolve); opt out with `stdlib=False` / `--no-stdlib`. |
+| **Execute** | Evaluate expressions, run `calc` definitions, instantiate `part` definitions (against the bundled standard library if you opt in), check constraints and requirements, run `action` definitions with succession-driven control flow, and simulate hierarchical/parallel state machines with a clock. |
+| **Visualize** | `sysml2.diagrams`: interactive ELK diagrams in JupyterLab (structure, state machines, action flow) with click-selection that resolves back to model elements. |
+| **Full loop** | Read a model, execute it, snapshot the results back into the model as bound part usages, and save (`.sysml`, `.json`, or `.kerml`). |
+
+The builder covers the full grammar: every construct the SysML grammar
+accepts (interfaces, views, flows, allocations, metadata annotations,
+satisfy/verify/frame, filtered imports, ...) maps to a model class — there
+is no lossy fallback. KerML support is asymmetric by design:
+`parse_kerml_text` validates KerML sources syntactically, and `to_kerml`
+projects SysML models onto the kernel language.
+
+## Installation
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+make check        # ruff + mypy + 310 tests
+```
+
+Optional: `pip install -e ".[ecore]"` enables the OMG spec-metamodel
+projection and API JSON (pyecore); `pre-commit install` wires ruff+mypy
+into every commit.
+
+### With pixi (optional)
+
+The repo also carries `[tool.pixi]` config in `pyproject.toml` (dependency
+truth stays in `[project]`; pixi adds the locked toolchain on top):
+
+```bash
+pixi run check          # lint + mypy + tests in a locked environment
+pixi run -e py310 test  # any supported Python: py310 | py311 | py312 | py313
+pixi run parsers        # regenerate ANTLR parsers -- no manual Java setup:
+                        # conda-forge's antlr 4.13.2 ships the tool + JDK
+pixi run lab            # JupyterLab in notebooks/ (vendored ipyelk extension
+                        # pre-registered -- diagrams render interactively)
+pixi run stdlib | demo | coverage | format | notebooks
+```
+
+CI runs entirely on pixi (`prefix-dev/setup-pixi`, cached by `pixi.lock`):
+a `check` job (lint + mypy + coverage), a test matrix across the four
+Python environments, and a grammar-regen job that fails if the committed
+parsers drift from the `.g4` sources. The `parsers` task is
+input/output-cached locally and produces byte-identical output.
+
+The generated ANTLR parsers are committed under `src/sysml2/_gen/`, so no
+Java toolchain is needed to install or use the package. Java is only needed
+to regenerate the parsers after a grammar change:
+
+```bash
+# any Java 11+ works; for example: mamba create -n jdk openjdk
+python scripts/generate_parsers.py
+```
+
+## Quick start
+
+```python
+import sysml2
+
+model = sysml2.loads("""
+    package Demo {
+        part def Vehicle {
+            attribute mass : Real = 1200.0;
+            attribute maxMass : Real = 2000.0;
+            part wheels : Wheel[4];
+            assert constraint massLimit { mass <= maxMass }
+        }
+        part def Wheel { attribute diameter : Real = 0.66; }
+        calc def Double { in x : Real; return : Real = 2.0 * x; }
+    }
+""")
+
+# --- export -------------------------------------------------------------
+print(sysml2.to_sysml(model))   # regenerated textual notation
+print(sysml2.to_json(model))    # structured JSON
+
+# --- execute ------------------------------------------------------------
+interp = sysml2.Interpreter(model)
+
+interp.call("Demo::Double", 21.0)            # -> 42.0
+car = interp.instantiate("Demo::Vehicle")    # attributes evaluated
+car.get("wheels")                            # -> [Instance, ...] (4 wheels)
+interp.check(car)[0].passed                  # -> True (mass <= maxMass)
+interp.evaluate("(1, 2, 3)->select { in x; x > 1 }")  # -> [2, 3]
+```
+
+Actions and state machines:
+
+```python
+model = sysml2.loads("""
+    package Ops {
+        action def Plan {
+            in distance : Real;
+            out fuel : Real;
+            assign fuel := distance * 0.08;
+        }
+        state def Machine {
+            entry; then off;
+            state off;
+            transition first off accept start then on;
+            state on;
+        }
+    }
+""")
+interp = sysml2.Interpreter(model)
+interp.run_action("Ops::Plan", inputs={"distance": 100.0}).outputs
+# -> {'fuel': 8.0}
+interp.simulate("Ops::Machine", events=["start"]).final_state
+# -> 'on'
+```
+
+A complete walk-through lives in `examples/demo.py`, and five executable
+tutorials live in [`notebooks/`](notebooks/):
+
+| Notebook | Covers |
+|---|---|
+| `01_define_and_explore` | parsing, the object model, programmatic authoring, workspaces |
+| `02_export_and_interchange` | SysML/JSON round-trips, save/load, KerML, spec metamodel, API JSON |
+| `03_calculations_and_constraints` | expressions, calcs, instantiation, constraints, requirements, the full loop |
+| `04_actions_and_states` | action graphs, hierarchical/parallel state machines, time |
+| `05_stdlib_and_validation` | the vendored standard library, `sysml2 lint` |
+| `06_interactive_diagrams` | ipyelk structure/state/action diagrams, click-selection |
+
+The notebooks are executed by the test suite (`tests/test_notebooks.py`) and
+can be refreshed with `pixi run notebooks`.
+
+```bash
+python examples/demo.py
+```
+
+### The full loop: read → run → save
+
+```python
+model = sysml2.load("examples/drone.sysml")
+interp = sysml2.Interpreter(model)
+
+# run
+flown = interp.instantiate("Drone::QuadCopter", payloadMass=0.35)
+
+# write computed values back into the model as a bound part usage
+model.find("Drone").add(interp.snapshot(flown, name="asFlown"))
+
+# save in any format (inferred from the suffix)
+sysml2.save(model, "drone_with_results.sysml")
+sysml2.save(model, "drone_with_results.json")
+sysml2.save(model, "drone_with_results.kerml")
+
+# the JSON export is lossless: reload and keep executing
+again = sysml2.load("drone_with_results.json")
+sysml2.Interpreter(again).instantiate("Drone::QuadCopter")
+```
+
+SysML or KerML text can be generated from just the JSON definition:
+
+```python
+model = sysml2.from_json(json_text)   # or sysml2.from_dict(data)
+print(sysml2.to_sysml(model))
+print(sysml2.to_kerml(model))         # kernel-language projection
+```
+
+### Multi-file projects and caching
+
+`load()` accepts a single `.sysml` file, a `.json` export, or a directory:
+
+```python
+model = sysml2.load("models/")            # every *.sysml file, merged
+model = sysml2.load_many(["lib.sysml", "app.json"])   # explicit set
+```
+
+Directory loads merge all files under one root namespace, so cross-file
+imports (`private import Units::*;`) and qualified references resolve.
+Files load in sorted path order for determinism.
+
+Built models are cached (as JSON — the same lossless schema as `to_json`,
+never pickles) in `~/.cache/sysml2` (override with `$SYSML2_CACHE_DIR`),
+keyed by source content plus a fingerprint of the generated parser and
+builder code — edits, grammar regeneration, and package upgrades invalidate
+cleanly. Caching is on by default for directories, off for single files
+(`cache=` overrides; `sysml2.clear_cache()` wipes it). Warm directory loads
+are ~1000x faster than cold parses with the ANTLR Python runtime.
+
+## Command line
+
+```bash
+sysml2 parse examples/drone.sysml                      # syntax check (file or dir)
+sysml2 export examples/drone.sysml --format sysml      # json | sysml | kerml
+sysml2 export model.json --format sysml                # JSON in, SysML out
+sysml2 export models/ --format json                    # whole directory, merged
+sysml2 calc examples/drone.sysml Drone::HoverTime capacity=5200
+sysml2 check examples/drone.sysml Drone::QuadCopter payloadMass=0.9
+sysml2 run examples/drone.sysml Drone::PlanBattery distanceKm=20
+sysml2 simulate examples/drone.sysml Drone::FlightStates --events launch,airborne
+```
+
+Every model-consuming command accepts `.sysml`, `.json`, or a directory;
+`--no-cache` bypasses the model cache.
+
+## Project layout
+
+```
+grammars/                  SysML.g4 + KerML.g4 (upstream + local patches)
+scripts/generate_parsers.py  regenerate src/sysml2/_gen from the grammars
+src/sysml2/
+    _gen/                  generated ANTLR lexers/parsers (committed)
+    parser.py              text -> parse tree, error collection
+    builder.py             parse tree -> model (the SysML front-end)
+    model.py               model element dataclasses (Literal-typed vocabularies)
+    ast.py                 expression AST + precedence-aware printer
+    export.py              model -> JSON / SysML text, save()
+    importer.py            JSON -> model (lossless round-trip)
+    workspace.py           multi-file loading + content-addressed model cache
+    kerml.py               model -> KerML projection
+    validation.py          sysml2 lint / validate()
+    stdlib.py + _stdlib/   vendored OMG standard library (+ prebuilt pickle)
+    ecore.py + _spec/      projection onto the OMG spec metamodel (pyecore)
+    api.py                 OMG Systems Modeling API JSON interchange
+    diagrams.py            interactive ELK diagrams (ipyelk)
+    render.py + _js/       headless SVG/PNG export (vendored elkjs via node)
+vendor/ipyelk/             vendored ipyelk 2.1.1 + local fixes (editable)
+    interpreter.py         evaluation, instantiation, actions, states, snapshot
+    cli.py                 the `sysml2` console command
+examples/                  drone.sysml + kernel.kerml + demo.py
+tests/                     310 pytest tests (84% coverage)
+.github/workflows/ci.yml   pixi-based: check + test matrix (3.10-3.13)
+                           + grammar-regen drift check (antlr/JDK from lock)
+Makefile                   make check = ruff + mypy + pytest (venv/pip route)
+```
+
+### How a model flows through the package
+
+1. `parser.py` runs the generated ANTLR parser and collects syntax errors.
+2. `builder.py` walks the parse tree and produces `model.py` dataclasses.
+   Expressions become compact AST nodes (`ast.py`), not parse-tree references.
+3. `export.py` renders the model to JSON or textual notation; `importer.py`
+   reads the JSON back; `kerml.py` projects onto KerML.
+4. `interpreter.py` resolves qualified names (imports, aliases,
+   specialization) and executes the model; `snapshot` converts runtime
+   instances back into model elements.
+
+## Code quality
+
+- **Typing**: modern PEP 585/604 annotations throughout; closed string
+  vocabularies (`kind`, `direction`, `visibility`, operators, ...) are
+  `typing.Literal` aliases (`model.UsageKind`, `ast.BinaryOp`, ...).
+  `mypy` runs clean over `src/sysml2` (generated code excluded).
+- **Linting**: `ruff` with `E, W, F, I, UP, B, C4, RUF` rules.
+- `make check` runs ruff + mypy + the full test suite.
+
+## Execution semantics (and their limits)
+
+This is a modeling sandbox, not a full KerML semantic engine. What executes:
+
+- **Actions**: bodies without successions run in declaration order. Bodies
+  with explicit successions (`first start then a; first a then b;`) run as
+  a control-flow graph: unreachable steps do not execute, `decide` nodes
+  choose the first satisfied guard (with `else` fallback), guarded loops
+  back-edge, and `fork`/`join` branches run sequentially in declaration
+  order (no interleaving). `accept after d` / `accept at t` advance the
+  action's clock (`ActionResult.time`); `accept when c` raises on a false
+  condition (a would-be deadlock).
+- **State machines** are hierarchical: composite states enter through their
+  own `entry; then S;` transition, inner states get the first chance to
+  consume an event, and exits cascade innermost-first. `parallel` states
+  activate all child regions concurrently (`SimulationResult.active_states`).
+  Time triggers (`accept after`/`accept at`) fire when a plain number in the
+  event list advances the simulation clock; `accept when c` transitions fire
+  as soon as their condition holds.
+- Quantities evaluate to their magnitude: `10 [SI::m]` evaluates to `10`.
+- **Standard library**: a curated subset of the official model library ships
+  with the package (all 21 Systems Library files + core Quantities/Units +
+  a KerML-kernel shim; see `sysml2/_stdlib/README.md`). Opt in with
+  `sysml2.add_standard_library(model)` or `--stdlib` on the CLI: library
+  types resolve (`Parts::Part`, `ISQ::mass`, `SI::kg`), `public import`
+  re-exports and aliases follow, and `istype` checks work against library
+  definitions. A bundled prebuilt pickle makes loading instant; the KerML
+  Kernel Libraries themselves are not loaded (KerML is parse-only), so
+  inherited library defaults that need unimplemented kernel functions
+  degrade to `None` instead of failing. The prebuilt ships as plain JSON
+  (`_stdlib/prebuilt.json`) — inspectable text, no pickles anywhere.
+- Multiplicity expansion: exact bounds (`[4]`) expand fully; ranges
+  populate their lower bound (`[0..*]` gives an empty list), which keeps
+  the library's self-referential compositions finite.
+
+## Interactive diagrams
+
+`sysml2.diagrams` renders models as interactive ELK diagrams in JupyterLab
+(see `notebooks/06_interactive_diagrams.ipynb`):
+
+```python
+from sysml2 import diagrams
+
+diagrams.structure_diagram(model)                 # defs, compartments, edges
+diagrams.state_diagram(model.find("P::Machine"))  # hierarchical states
+diagrams.action_diagram(model.find("P::Flow"))    # the executed succession graph
+diagrams.diagram(element)                          # dispatch by kind
+
+diagrams.on_select(widget, model, callback)        # clicks -> model elements
+```
+
+Node ids are qualified names, so browser selections resolve straight back to
+model elements. Layout runs in the browser (elkjs), so diagrams also build
+headlessly (tests, nbclient).
+
+The same views export to images without a browser — `sysml2.render` runs
+the vendored elkjs (0.9.3, EPL-2.0, `sysml2/_js/`) in a node subprocess and
+draws styled SVG, with PNG via cairosvg (node + cairo ship in the pixi
+environments):
+
+```python
+from sysml2 import render
+
+render.to_svg(diagrams.state_diagram(machine), "machine.svg")
+render.to_png(model, "model.png")   # builds a view automatically
+```
+
+State-machine simulations replay over that same diagram: `sysml2.replay`
+records a simulation (the `Interpreter.simulate` event protocol -- names
+send events, numbers advance the clock) and animates it in the notebook
+with play/pause, speed, and scrubbing. Active states light up green and
+fired transitions pulse orange. Needs the `replay` extra
+(`pip install "longeron[replay]"`, anywidget):
+
+```python
+from sysml2 import replay
+
+replay.replay_widget(interp, "Machines::Player",
+                     events=["play", 3600.0, "play"])
+```
+
+ipyelk is **vendored** (`vendor/ipyelk`, BSD-3-Clause, tag v2.1.1) and
+installed editable (`pip install -e vendor/ipyelk`; pixi does this
+automatically) so it can be patched as needed. Current local fixes, all
+marked `LOCAL PATCH` and tracked by `git log -- vendor/ipyelk`:
+
+1. **Headless-safe scheduling** — `Pipe.schedule_run` raised
+   `RuntimeError: no running event loop` outside Jupyter (plain scripts,
+   pytest); it now no-ops cleanly when there is no frontend to lay out for.
+2. **Prebuilt labextension grafted** — the git tree only carries TypeScript
+   sources; the built JupyterLab extension from the 2.1.1 wheel is vendored
+   under `src/_d/` so the editable install renders without a node toolchain.
+
+## Spec-metamodel projection and API interchange
+
+With the `ecore` extra installed, models project onto the OMG abstract
+syntax (the pilot implementation's `SysML.ecore`, 175 metaclasses, vendored
+under `sysml2/_spec/`):
+
+```python
+from sysml2 import ecore, api
+
+spec = ecore.to_spec(model)      # reified memberships, FeatureTyping, ...
+spec.report                       # what was covered / skipped
+spec.save_xmi("model.xmi")       # EMF XMI
+
+api.to_api_json(model)            # OMG Systems Modeling API records
+api.from_api_json(text)           # records -> spec instances
+```
+
+Both are structural prototypes: names, flags, ownership, and
+specialization/typing relationships are mapped; expression trees are not
+(counted in `SpecReport`, never silently dropped).
+
+## Grammar patches
+
+Deviations from the upstream grammars, each marked with a ``LOCAL PATCH``
+comment in the `.g4` files:
+
+1. **`import` visibility (SysML.g4).** Upstream required a visibility
+   keyword before every `import`, which rejects the spec's own examples
+   (`import ScalarValues::*;`). Aligned with KerML.g4's optional prefix.
+2. **Entry transitions (SysML.g4).** Upstream required `entry; then then S;`
+   because `targetSuccession` already contains `then`. The patch accepts the
+   spec form `entry; then S;`.
+3. **Unary operator precedence (both grammars).** Upstream parsed `-3 + 1`
+   as `-(3 + 1)` because the unary alternative sat below the binary
+   alternatives with a non-rightmost recursion. The patch moves unary above
+   the binary operators, so `-3 + 1` is `(-3) + 1`.
+4. **`@` vs `at` (SysML.g4, four sites).** In SysML, `AT` is the keyword
+   `at` (trigger times) and the `@` symbol is `AT_SIGN`; upstream used `AT`
+   in the metadata and classification rules copied from KerML (where `AT`
+   itself is `'@'`). Upstream therefore required `at Safety` instead of
+   `@Safety`, and `x at T` instead of `x @ T`.
+5. **Flow ends (SysML.g4).** `flowEndSubsetting` dropped the spec's `'.'`
+   after `QualifiedName`, so `flow from a.out to b.in` could not parse.
+
+One known deviation from the OMG spec remains, inherited from upstream: the
+grammar groups `??`/`or`/`and`/`implies` at one precedence level and
+`|`/`&`/`xor` at another, and `**` is left-associative. Parenthesize when in
+doubt; the exporter always prints round-trip-safe parentheses.
+
+## Regenerating the parsers
+
+```bash
+python scripts/generate_parsers.py
+```
+
+The script finds Java via `JAVA_HOME`, `PATH`, or a conda/mamba env, and the
+ANTLR 4.13.2 jar via `ANTLR_JAR`, `~/.m2`, or Maven Central. Regenerate
+whenever a `.g4` file changes, then run `pytest`.

longeron-0.2.0.dist-info/RECORD

@@ -0,0 +1,80 @@
+longeron-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sysml2/__init__.py,sha256=Oeys_uj3h9wqtoKL1Pj3fdtM70mx-5sqcmC50Dmcfa8,2903
+sysml2/api.py,sha256=aV0jFTo9fdJ-ZG13mDbKK8lumzqWNvaABXbKVNMPwbo,5397
+sysml2/ast.py,sha256=r4PofNGYimw_q4tZJNe_IbqyFLehHBW5O9rXbp0ORR8,15208
+sysml2/builder.py,sha256=Cg2mrLlxgyBhAFGfy6p9oa_BuQ93UG2sVtSiNQAAKHU,98945
+sysml2/cli.py,sha256=EUgp_OMd3tG0NKTblF7ieUVvp0mGI8-2SI-KfEWypHw,7442
+sysml2/diagrams.py,sha256=O3ymnM_uDdZ__I6Z4cisAi5MHxnVy9Z0OD0fWNUFzIA,26370
+sysml2/ecore.py,sha256=_W_RQLnVDlU8CTh6wXyE0Q_VU0_on3diozFMTmjomuo,16577
+sysml2/errors.py,sha256=VloCcKgPsfo4oIyIPo5Eu6hlYeA5C4vbYvdBQ58oE9c,1251
+sysml2/export.py,sha256=5D2p9Afjd_IPufWBNKm62tL_i175TjXY1UMFuHqGHyc,28375
+sysml2/importer.py,sha256=ndo307D9O3ZAt2mUyeR-phxGaxi_8o25xrhy-GqJDHk,2612
+sysml2/interpreter.py,sha256=1w-2zbnfJhibEIciIV0dPk6reFa-yKmBLc317RhYTHM,88510
+sysml2/kerml.py,sha256=dE2czUo8lZC1fnSPhwmLwGNd85__vkZ9VMauH0HVYIQ,9533
+sysml2/model.py,sha256=LaL5BAt9omLGplBNd8jfpAiRHemcH1lCRYpbYFqq4o8,15765
+sysml2/parser.py,sha256=FNEgy9jTdi-top-giRAnZVs5qBWD_lLn26XmYr7cKiQ,3451
+sysml2/render.py,sha256=D9C5OxLCbyv7ZH5RFqRlOQXge2WprsNDUovpuziWbpw,19962
+sysml2/replay.py,sha256=kzdEB-HBaw2aqpR3yNb28inYWke1EDY2wv-RhikvPRg,18552
+sysml2/stdlib.py,sha256=uJQnJgIIYPd30H8UavKbS_owGFUyJeI4qRpUdJzOxlo,4087
+sysml2/validation.py,sha256=C4eI7sFZ-4GWp9LOfTNX5BymLUGwktBQzGpbyE0nUSE,14770
+sysml2/workspace.py,sha256=8s6SiK88h0Z-FB8CB3ocIhlwXZ3u7l19mMVQ9-WaAMw,6629
+sysml2/_gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sysml2/_gen/kerml/KerML.interp,sha256=311dnbltqNFByAZ3pAYy6EOd7uXSJX-Yoo-EH1qxtGg,88296
+sysml2/_gen/kerml/KerML.tokens,sha256=sWboUUa4Fiuvb-hCI0ZS777dObqxjtJtu-DhpX84tVY,3540
+sysml2/_gen/kerml/KerMLLexer.interp,sha256=5pE5hyI8mHI7m-mdWC2OQ8aTC-gXWaoFViFlqGrHqpY,48360
+sysml2/_gen/kerml/KerMLLexer.py,sha256=qZ2AgOI2rn7421K2cCQ22TXn1odC8GpHFID7AncoRWM,47683
+sysml2/_gen/kerml/KerMLLexer.tokens,sha256=sWboUUa4Fiuvb-hCI0ZS777dObqxjtJtu-DhpX84tVY,3540
+sysml2/_gen/kerml/KerMLParser.py,sha256=-E0Dqrzv7vpNNJSk_F7p4ExZBJmNmNAOtan1tCI7Wi4,665151
+sysml2/_gen/kerml/KerMLVisitor.py,sha256=asbiL6kCSkueJrt4SH-539mLmYamTP8ynA2rY_8JVAM,52862
+sysml2/_gen/kerml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sysml2/_gen/sysml/SysML.interp,sha256=4Sj2b19JAFOpoBnqscQQrmYser6SJO5Z8RunXuydXVY,140415
+sysml2/_gen/sysml/SysML.tokens,sha256=P5BMXwYuzLnU5wDQsrQ_PNYa9aR1s8_jJXJD3aUEbPQ,3965
+sysml2/_gen/sysml/SysMLLexer.interp,sha256=Mp28YhTZPvNNSl1XgZ-rpj8j3aZDKo6NKz8mg_J7Iiw,53702
+sysml2/_gen/sysml/SysMLLexer.py,sha256=u7XGBpj3KxOETDIXMxq65cIsouBzuRjMq6hW7OLdmrA,53000
+sysml2/_gen/sysml/SysMLLexer.tokens,sha256=P5BMXwYuzLnU5wDQsrQ_PNYa9aR1s8_jJXJD3aUEbPQ,3965
+sysml2/_gen/sysml/SysMLParser.py,sha256=j5zylGJV84zjMEIOKbKDvtl-uiw1vcd36Jn9qdZfwBU,1044082
+sysml2/_gen/sysml/SysMLVisitor.py,sha256=WdXf1tv_ifMwxruCH-WCIle8-3GCHaZIorKOiSoxGzM,84464
+sysml2/_gen/sysml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sysml2/_js/elk.bundled.js,sha256=sHRavX8jzZFpChWH43ftvhn9cjPHgzACkJNnIFRiFtQ,1606238
+sysml2/_spec/README.md,sha256=cP-IIVpQ6w1npvxBSW7PxmluWbQb1IIY8V89vqI3nYs,401
+sysml2/_spec/SysML.ecore,sha256=3Tlg4KADHQdK2wEWLZt-xlUbLnqh2Ssmtveg6kW0ZNY,624054
+sysml2/_stdlib/KernelShim.sysml,sha256=F8cxWkwoOrk6Jla227j1jdt-bsS-A7spMEbmE7_jbTM,2120
+sysml2/_stdlib/README.md,sha256=VcfpbIaVY_VaMBhDwk-e_1J7tBeHpSUEOfMGZQqR0Bw,682
+sysml2/_stdlib/prebuilt.json,sha256=khz4RMbuV6bbTwzR8I2DC3PprbSqHFv4oZC10Yu4NWs,889703
+sysml2/_stdlib/quantities/ISQ.sysml,sha256=ERSi81VudXZ2do0F3i-_ixgE_eWJLWjJduER24ERf9o,2096
+sysml2/_stdlib/quantities/ISQBase.sysml,sha256=zF3HMNKnFn6RRDGm8S0DGPeSpcbiogSjffmrM_XphDU,12219
+sysml2/_stdlib/quantities/MeasurementRefCalculations.sysml,sha256=UeFdOJ84Nt83gvh9ZFCh1qisCN_Zos_d7zOK5W3WiNw,1600
+sysml2/_stdlib/quantities/MeasurementReferences.sysml,sha256=MtJbE-lkh_dxspOrjpyoKjnM2NplU9lEkAujtQAyO7g,21401
+sysml2/_stdlib/quantities/Quantities.sysml,sha256=blllP-Q55yH3B-ALwl84Q7SXMYAZTq9dgmt-KDYAzUU,4580
+sysml2/_stdlib/quantities/QuantityCalculations.sysml,sha256=ZOUzyXjLc7KfAxXlE69J965IjBqjxxLL-UQ9ngfQCbQ,4218
+sysml2/_stdlib/quantities/SI.sysml,sha256=j6UzNQZWrEL5zj6aQGjsElHVTgdK8IEJza_EesCyQog,30924
+sysml2/_stdlib/quantities/SIPrefixes.sysml,sha256=kOYE_NpA-OySARSkVwl8sv7W2JjUIsgCd7TI6cPnBjg,3400
+sysml2/_stdlib/quantities/TensorCalculations.sysml,sha256=vVimg1hPpyUlbUaHyfbrUsCfoX6mXjDYTBMT3hd3uAw,2446
+sysml2/_stdlib/quantities/Time.sysml,sha256=HrAgM0Y8dA01cF0Dot19ZGhtiMEQ7Xow7wHgK9stykc,10429
+sysml2/_stdlib/quantities/VectorCalculations.sysml,sha256=HPAfTLyw0mtEPNnv2SdiJPNbjhjRjzdB27rOjNHyV74,3057
+sysml2/_stdlib/systems/Actions.sysml,sha256=r7F7R-oSKL70HveRuk_0JTxIpEWJ5_1JeLHXeT6k_3c,14971
+sysml2/_stdlib/systems/Allocations.sysml,sha256=CtkApMJdiOuW2j1X42X2w4zYcBm8qsWrke7pUjtfDtE,788
+sysml2/_stdlib/systems/AnalysisCases.sysml,sha256=K7iPYRePLO_VRBYA0tmA7R4aT_xct7PKkgft7lw1D4c,1038
+sysml2/_stdlib/systems/Attributes.sysml,sha256=D_mwrMPwp71o_v5rEQ6RNvGRHQxIN0GATDuMoH9fU40,626
+sysml2/_stdlib/systems/Calculations.sysml,sha256=GfXCrFU8CgNFUCkt5r-mAeaUj8gdWveBtZyUDu4uX3I,990
+sysml2/_stdlib/systems/Cases.sysml,sha256=LEwMuqpGb59yC6aa86AZUXygp3QaVh94gABrrpRr8k8,1619
+sysml2/_stdlib/systems/Connections.sysml,sha256=cwO2jUbuMRXibvvSLSCWQM0PgacbTA8PRvARARFTscY,2133
+sysml2/_stdlib/systems/Constraints.sysml,sha256=hN1lmEq9DDXDe3XvV2a_pjyDaqdaHHWp0-tfQjD6j90,1263
+sysml2/_stdlib/systems/Flows.sysml,sha256=GRp0EDbN_93vMQ2Ku_EM9iJyTKg30-M5U9-VZkiQ3kE,4766
+sysml2/_stdlib/systems/Interfaces.sysml,sha256=YrXDwrw5YOjSVjMjHDkzqB5CKzqQTclUG4eHET0HbGY,3467
+sysml2/_stdlib/systems/Items.sysml,sha256=WjssLS6zEEGGpeIAxAZH0deYaFpi2wMBzkyjYWUQFbc,4121
+sysml2/_stdlib/systems/Metadata.sysml,sha256=yGpoobf48z8ofYEngNJEYCGu77MoTyi5wQ3-KxoT3tY,884
+sysml2/_stdlib/systems/Parts.sysml,sha256=oiuSanu9zaIBSSAKYf1ByfHjkkyJKe99aNtSn7jnv1E,1882
+sysml2/_stdlib/systems/Ports.sysml,sha256=_r1mF8O7nQ-Tx3ciuYh02JtJc_e5PuiFCQl7LoC8aZU,1594
+sysml2/_stdlib/systems/Requirements.sysml,sha256=xDao_ilZs4DuPYrnwcIGMRqpwSFdE4ALIV-ZUuEhZjI,5466
+sysml2/_stdlib/systems/StandardViewDefinitions.sysml,sha256=spiCsCQOPMJyG2bGvJ_R0tJDGjToDhcM1GWRH_jYM6U,6115
+sysml2/_stdlib/systems/States.sysml,sha256=GoTijUGo12_xy86BMSJX2sl7R7zVRcMfijT3MJisE7w,3371
+sysml2/_stdlib/systems/SysML.sysml,sha256=lxLtauxZ4v8xyRXFjsjUIVjEFckwnpZTJib27l-PFZw,30789
+sysml2/_stdlib/systems/UseCases.sysml,sha256=JC5RlEwyAyIV12qf8f2WfYujbv_9nXjaHEI6WxAqLPY,1271
+sysml2/_stdlib/systems/VerificationCases.sysml,sha256=2-5yVeFt-cXPC97ZbEPLYLHlAmtpc8X7EXYxaQKsR7k,2488
+sysml2/_stdlib/systems/Views.sysml,sha256=C88Qr9Sd0JyMZIRNqX_EwBpKNf79TkoXmovAqKJhyKg,3973
+longeron-0.2.0.dist-info/METADATA,sha256=vvGodkPhAkONitCzUSQBTMUlsQsdkag79ScqZFkWWBU,20767
+longeron-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+longeron-0.2.0.dist-info/entry_points.txt,sha256=TMvZZip94OfJ_RCmNKDQops_Bo3qoQ6Tny5aI48H848,43
+longeron-0.2.0.dist-info/top_level.txt,sha256=pUscTQzOLxuSbXVM4hC4Ix-oSAScCfH3vlpUWwB9YEU,7
+longeron-0.2.0.dist-info/RECORD,,

longeron-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

longeron-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sysml2 = sysml2.cli:main