sysmlpy 0.65.0__tar.gz → 0.66.0__tar.gz

{sysmlpy-0.65.0 → sysmlpy-0.66.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.65.0
+Version: 0.66.0
 Summary: 
 License-File: LICENSE
 Author: Jon R. Fox (mycr0ft)
@@ -15,10 +15,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: graph
 Provides-Extra: kuzu
+Provides-Extra: xlsx
 Requires-Dist: antlr4-python3-runtime (>=4.13)
 Requires-Dist: arrow (>=1.4.0,<2.0.0)
 Requires-Dist: kuzu (>=0.7,<0.12) ; extra == "kuzu"
 Requires-Dist: networkx (>=3.0) ; extra == "graph"
+Requires-Dist: openpyxl (>=3.1) ; extra == "xlsx"
 Requires-Dist: pint (>=0.24)
 Requires-Dist: pyyaml (>=6.0)
 Description-Content-Type: text/markdown

{sysmlpy-0.65.0 → sysmlpy-0.66.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.65.0"
+version = "0.66.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"
@@ -19,11 +19,13 @@ pyyaml = ">=6.0"
 antlr4-python3-runtime = ">=4.13"
 networkx = { version = ">=3.0", optional = true }
 kuzu = { version = ">=0.7,<0.12", optional = true }
+openpyxl = { version = ">=3.1", optional = true }
 arrow = "^1.4.0"
 
 [tool.poetry.extras]
 graph = ["networkx"]
 kuzu = ["kuzu"]
+xlsx = ["openpyxl"]
 
 [tool.poetry.scripts]
 sysmlpy = "sysmlpy.__main__:main"

{sysmlpy-0.65.0 → sysmlpy-0.66.0}/src/sysmlpy/__init__.py

@@ -22,6 +22,9 @@ __all__ = [
     "to_interchange", "from_interchange", "interchange_to_json_text",
     "evaluate_expression", "evaluate_calculation", "collect_values",
     "check_constraints", "ConstraintReport", "ConstraintResult",
+    "tabular_view_to_csv", "data_value_tabular_to_csv",
+    "relationship_matrix_to_csv", "write_xlsx",
+    "import_values_csv", "import_values_xlsx", "parse_value_literal",
     "analyze", "AnalysisResult", "SemanticIssue", "SemanticAnalyzer",
     "SysMLSyntaxError", "PartialParseError",
     "loads_partial", "load_partial",
@@ -30,7 +33,7 @@ __all__ = [
     "render_state_transition_view_svg", "boxes_view",
 ]
 __author__ = "Jon Fox"
-__version__ = "0.65.0"
+__version__ = "0.66.0"
 
 from sysmlpy.usage import (
     Item, Attribute, Part, Port, Action, Reference, UseCase, Requirement, Interface, Message,
@@ -57,6 +60,11 @@ from sysmlpy.evaluator import (
     evaluate_expression, evaluate_calculation, collect_values,
     check_constraints, ConstraintReport, ConstraintResult,
 )
+from sysmlpy.spreadsheet import (
+    tabular_view_to_csv, data_value_tabular_to_csv,
+    relationship_matrix_to_csv, write_xlsx,
+    import_values_csv, import_values_xlsx, parse_value_literal,
+)
 
 
 class PartialParseError(Exception):

{sysmlpy-0.65.0 → sysmlpy-0.66.0}/src/sysmlpy/__main__.py

@@ -31,7 +31,7 @@ import sysmlpy
 from sysmlpy import loads
 
 # Subcommand table, also used to detect the legacy flat invocation form.
-SUBCOMMANDS = ("parse", "analyze", "view", "trace", "export", "import", "eval", "format", "fmt")
+SUBCOMMANDS = ("parse", "analyze", "view", "trace", "export", "import", "eval", "xlsx", "format", "fmt")
 
 
 # ---------------------------------------------------------------------------
@@ -433,6 +433,26 @@ def cmd_eval(args) -> int:
         name, _, raw = spec.partition("=")
         bindings[name.strip()] = _parse_eval_value(raw)
 
+    if getattr(args, "set_file", None):
+        from sysmlpy.spreadsheet import import_values_csv, import_values_xlsx
+        setfile = Path(args.set_file)
+        if not setfile.exists():
+            print(f"Error: --set-file '{setfile}' not found.", file=sys.stderr)
+            return 2
+        try:
+            if setfile.suffix.lower() == ".xlsx":
+                file_bindings = import_values_xlsx(setfile)
+            else:
+                # utf-8-sig tolerates Excel's BOM on CSV exports
+                file_bindings = import_values_csv(
+                    setfile.read_text(encoding="utf-8-sig")
+                )
+        except (ValueError, ImportError, OSError) as e:
+            print(f"Error: --set-file: {e}", file=sys.stderr)
+            return 1
+        # --set flags win over spreadsheet values
+        bindings = {**file_bindings, **bindings}
+
     if args.expr is not None:
         try:
             value = evaluate_expression(
@@ -478,6 +498,36 @@ def _format_value(value):
     return str(value)
 
 
+def cmd_xlsx(args) -> int:
+    """Export tabular views to an Excel workbook (v0.66.0, Goal 7)."""
+    from sysmlpy.spreadsheet import write_xlsx
+
+    paths = [Path(f) for f in args.files]
+    for p in _missing_files(paths):
+        print(f"Error: File '{p}' not found.", file=sys.stderr)
+        return 2
+
+    try:
+        model = sysmlpy.load_files(paths, library=args.library)
+    except Exception as e:
+        print(f"Parse error: {e}", file=sys.stderr)
+        return 2
+
+    include = tuple(s.strip() for s in args.sheets.split(",") if s.strip())
+    try:
+        out = write_xlsx(model, args.output, include=include,
+                         focus=args.focus)
+    except ImportError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: xlsx export failed: {type(e).__name__}: {e}",
+              file=sys.stderr)
+        return 1
+    print(f"Wrote {out}")
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # legacy flat invocation (kept for backward compatibility)
 # ---------------------------------------------------------------------------
@@ -642,8 +692,9 @@ def build_parser() -> argparse.ArgumentParser:
         help="Graph direction (graph views only)",
     )
     p_view.add_argument(
-        "--format", choices=("plantuml", "markdown", "html"),
-        help="Output format for tabular/datavalue/matrix views",
+        "--format", choices=("plantuml", "markdown", "html", "csv"),
+        help="Output format for tabular/datavalue/matrix views "
+             "(csv added in v0.66.0)",
     )
     p_view.add_argument(
         "-l", "--library",
@@ -757,6 +808,12 @@ def build_parser() -> argparse.ArgumentParser:
         help="Override a name for this evaluation (repeatable; values "
              "may be numbers, true/false, or unit strings like '80 km/h')",
     )
+    p_eval.add_argument(
+        "--set-file", metavar="FILE",
+        help="Load bindings from a CSV/XLSX values file "
+             "(v0.66.0; headers: Name,Value[,Unit] or "
+             "Element,Attribute,Value[,Unit])",
+    )
     p_eval.add_argument(
         "--element",
         help="Qualified element name whose scope to evaluate in",
@@ -775,6 +832,35 @@ def build_parser() -> argparse.ArgumentParser:
     )
     p_eval.set_defaults(func=cmd_eval)
 
+    # -- xlsx (v0.66.0, Goal 7) -------------------------------------------------
+    p_xlsx = sub.add_parser(
+        "xlsx",
+        help="Export tabular views to an Excel workbook",
+        description="Write the Tabular / DataValues / Matrix views into "
+                    "an .xlsx workbook (requires the 'openpyxl' extra: "
+                    "pip install 'sysmlpy[xlsx]'). Exit codes: 0 clean, "
+                    "1 error, 2 parse error.",
+    )
+    p_xlsx.add_argument("files", nargs="+", help="SysML v2 file(s)")
+    p_xlsx.add_argument(
+        "-o", "--output", required=True,
+        help="Output .xlsx file path",
+    )
+    p_xlsx.add_argument(
+        "--sheets", default="tabular,data_value,matrix",
+        help="Comma-separated sheet selection: tabular,data_value,matrix "
+             "(default: all)",
+    )
+    p_xlsx.add_argument(
+        "--focus",
+        help="Focus element for the tabular views",
+    )
+    p_xlsx.add_argument(
+        "-l", "--library",
+        help="Path to SysML v2 library files to use for parsing",
+    )
+    p_xlsx.set_defaults(func=cmd_xlsx)
+
     return parser
 
 

{sysmlpy-0.65.0 → sysmlpy-0.66.0}/src/sysmlpy/plantuml.py

@@ -3139,6 +3139,22 @@ def _format_table_rows_plantuml(header, rows):
     return lines
 
 
+def _format_table_rows_csv(header, rows):
+    """Format header + rows as CSV text (v0.66.0, Goal 7).
+
+    Uses the ``csv`` module for proper quoting/escaping.  Returns a
+    trailing-newline-free string with LF line endings.
+    """
+    import csv as _csv
+    import io as _io
+
+    buf = _io.StringIO()
+    writer = _csv.writer(buf, lineterminator="\n")
+    writer.writerow(header)
+    writer.writerows(rows)
+    return buf.getvalue().rstrip("\n")
+
+
 def _format_table_rows_markdown(header, rows, align=None):
     """Format a markdown table from header and rows."""
     if align is None:
@@ -3250,6 +3266,9 @@ def as_tabular_view(model, focus=None, style="bw", output_format="markdown",
                 row.append("")
         rows.append(row)
 
+    if output_format == "csv":
+        return _format_table_rows_csv(header, rows)
+
     if output_format == "markdown":
         align = []
         for col in columns:
@@ -3349,6 +3368,9 @@ def as_data_value_tabular_view(model, focus=None, style="bw",
         row = [parent_name, name, val_str, unit_str, typed_by]
         rows.append(row)
 
+    if output_format == "csv":
+        return _format_table_rows_csv(header, rows)
+
     if output_format == "markdown":
         align = [":---", ":---", ":--", ":--", ":---"]
         parts = _format_table_rows_markdown(header, rows, align=align)
@@ -3516,6 +3538,9 @@ def as_relationship_matrix_view(model, focus=None, style="bw",
                 row.append("")
         matrix_rows.append(row)
 
+    if output_format == "csv":
+        return _format_table_rows_csv(header, matrix_rows)
+
     if output_format == "markdown":
         parts = _format_table_rows_markdown(header, matrix_rows, align=None)
         if custom_style:

sysmlpy-0.66.0/src/sysmlpy/spreadsheet.py

@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+"""Spreadsheet bridge (v0.66.0 — Adoption Roadmap Goal 7).
+
+Two directions:
+
+**Export** — tabular views to CSV/XLSX workbooks:
+
+    from sysmlpy import loads, tabular_view_csv, write_xlsx
+    model = loads(sysml_text)
+    csv_text = tabular_view_to_csv(model)             # Name,Type,Kind,...
+    write_xlsx(model, "model.xlsx")                   # one sheet per view
+
+**Import** — attribute values from a spreadsheet into evaluator
+bindings (what-if runs, constraint gates):
+
+    from sysmlpy import import_values_csv, check_constraints
+    bindings = import_values_csv("values.csv")
+    report = check_constraints(model, bindings=bindings)
+
+Imported CSV/XLSX files accept either header set:
+
+    Name,Value[,Unit]                 e.g. mass,1200 kg
+    Element,Attribute,Value[,Unit]    qualified element + attribute name
+
+Values parse as int → float → boolean (`true`/`false`) → pint unit
+string (e.g. ``1200 kg``) → raw string.  Names may be bare
+(``mass``) or qualified (``VehicleSpec::Vehicle::mass``).
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+from typing import Any, Dict, List, Optional, Sequence
+
+__all__ = [
+    "tabular_view_to_csv", "data_value_tabular_to_csv",
+    "relationship_matrix_to_csv", "write_xlsx",
+    "import_values_csv", "import_values_xlsx", "parse_value_literal",
+]
+
+
+# ---------------------------------------------------------------------------
+# value parsing (shared by import + CLI --set)
+# ---------------------------------------------------------------------------
+
+
+def parse_value_literal(raw: str) -> Any:
+    """Parse a spreadsheet/CLI value literal into a Python value.
+
+    Order: bool → int → float → pint quantity → raw string.  Pint
+    strings like ``1200 kg`` or ``80 km/h`` become ``Quantity`` objects;
+    anything that parses nowhere is kept as a string (e.g. names).
+    """
+    from sysmlpy.usage import ureg
+
+    text = raw.strip() if isinstance(raw, str) else raw
+    low = str(text).strip().lower()
+    if low == "true":
+        return True
+    if low == "false":
+        return False
+    s = str(text)
+    try:
+        return int(s)
+    except ValueError:
+        pass
+    try:
+        return float(s)
+    except ValueError:
+        pass
+    try:
+        return ureg(s)
+    except Exception:
+        pass
+    return s
+
+
+# ---------------------------------------------------------------------------
+# CSV export of the tabular views
+# ---------------------------------------------------------------------------
+
+
+def tabular_view_to_csv(model, focus=None, columns=None) -> str:
+    """Tabular View (Name/Type/Kind/Parent/…) as CSV text."""
+    from sysmlpy.plantuml import as_tabular_view
+    return as_tabular_view(model, focus=focus, output_format="csv",
+                           columns=columns)
+
+
+def data_value_tabular_to_csv(model, focus=None, include_units=True) -> str:
+    """Data Value Tabular View (Element/Attribute/Value/Unit/…) as CSV."""
+    from sysmlpy.plantuml import as_data_value_tabular_view
+    return as_data_value_tabular_view(model, focus=focus,
+                                      output_format="csv",
+                                      include_units=include_units)
+
+
+def relationship_matrix_to_csv(model, focus=None, row_type=None,
+                               col_type=None, symmetric=True) -> str:
+    """Relationship Matrix View as CSV."""
+    from sysmlpy.plantuml import as_relationship_matrix_view
+    return as_relationship_matrix_view(model, focus=focus,
+                                       row_type=row_type, col_type=col_type,
+                                       symmetric=symmetric,
+                                       output_format="csv")
+
+
+# ---------------------------------------------------------------------------
+# XLSX export (openpyxl optional)
+# ---------------------------------------------------------------------------
+
+
+def _require_openpyxl():
+    try:
+        import openpyxl  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "XLSX export requires the 'openpyxl' package — "
+            "install with: pip install 'sysmlpy[xlsx]' (or pip install openpyxl)"
+        ) from None
+    import openpyxl
+    return openpyxl
+
+
+def write_xlsx(model, path, include=("tabular", "data_value", "matrix"),
+               focus=None) -> str:
+    """Write tabular views into an Excel workbook (one sheet per view).
+
+    *include* selects sheets: ``"tabular"``, ``"data_value"``,
+    ``"matrix"``.  Requires openpyxl (``pip install openpyxl``).
+    Returns the resolved output path.
+    """
+    from pathlib import Path
+
+    openpyxl = _require_openpyxl()
+
+    sheet_sources = {
+        "tabular": lambda: tabular_view_to_csv(model, focus=focus),
+        "data_value": lambda: data_value_tabular_to_csv(model, focus=focus),
+        "matrix": lambda: relationship_matrix_to_csv(model, focus=focus),
+    }
+    sheet_names = {
+        "tabular": "Tabular",
+        "data_value": "DataValues",
+        "matrix": "Matrix",
+    }
+
+    wb = openpyxl.Workbook()
+    wb.remove(wb.active)
+    wrote_any = False
+    for key in include:
+        if key not in sheet_sources:
+            raise ValueError(f"Unknown sheet kind: {key!r} — expected one "
+                             f"of {sorted(sheet_sources)}")
+        rows = list(csv.reader(io.StringIO(sheet_sources[key]())))
+        if not rows:
+            continue
+        ws = wb.create_sheet(sheet_names[key])
+        for row in rows:
+            ws.append(row)
+        # bold header row for readability
+        for cell in ws[1]:
+            cell.font = openpyxl.styles.Font(bold=True)
+        wrote_any = True
+
+    if not wrote_any:
+        # still produce a valid workbook with a note sheet
+        ws = wb.create_sheet("Empty")
+        ws.append(["(no tabular content in this model)"])
+
+    out = Path(path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    wb.save(out)
+    return str(out)
+
+
+# ---------------------------------------------------------------------------
+# Value import → evaluator bindings
+# ---------------------------------------------------------------------------
+
+_VALUE_HEADERS = ("value", "val")
+_NAME_HEADERS = ("name", "element", "qualified name", "qualified_name")
+_ATTRIBUTE_HEADERS = ("attribute", "feature", "attr")
+_UNIT_HEADERS = ("unit", "units")
+
+
+def _normalize_header(cell) -> str:
+    return str(cell).strip().lower() if cell is not None else ""
+
+
+def _rows_to_bindings(rows: List[List[Any]]) -> Dict[str, Any]:
+    """Turn spreadsheet rows into evaluator ``bindings``.
+
+    Accepted layouts (header row required, case-insensitive):
+      Name,Value[,Unit]            — Name may be bare or qualified
+      Element,Attribute,Value[,Unit]
+    """
+    if not rows:
+        return {}
+    header = [_normalize_header(c) for c in rows[0]]
+    col = {}
+    for idx, h in enumerate(header):
+        if h in _NAME_HEADERS and "name" not in col:
+            col["name"] = idx
+        elif h in _ATTRIBUTE_HEADERS and "attr" not in col:
+            col["attr"] = idx
+        elif h in _VALUE_HEADERS and "value" not in col:
+            col["value"] = idx
+        elif h in _UNIT_HEADERS and "unit" not in col:
+            col["unit"] = idx
+    if "value" not in col or ("name" not in col and "attr" not in col):
+        raise ValueError(
+            "Import CSV needs a header row with Name/Value (or "
+            "Element/Attribute/Value) columns — "
+            f"got header {rows[0]!r}"
+        )
+
+    bindings: Dict[str, Any] = {}
+    for lineno, row in enumerate(rows[1:], start=2):
+        if not row or all(c is None or str(c).strip() == ""
+                          for c in row):
+            continue  # blank row
+        raw_value = row[col["value"]] if col["value"] < len(row) else None
+        raw_value = str(raw_value).strip() if raw_value is not None else ""
+        if not raw_value:
+            raise ValueError(f"Row {lineno}: missing value for "
+                             f"{row[:2]!r}")
+        if "unit" in col and col["unit"] < len(row) and row[col["unit"]]:
+            raw_value = f"{raw_value} {str(row[col['unit']]).strip()}"
+        value = parse_value_literal(raw_value)
+        if "attr" in col:
+            attr = str(row[col["attr"]]).strip() \
+                if col["attr"] < len(row) else ""
+            base = str(row[col["name"]]).strip() \
+                if col["name"] < len(row) else ""
+            name = f"{base}::{attr}" if base and attr else (attr or base)
+        else:
+            name = str(row[col["name"]]).strip()
+        bindings[name] = value
+    return bindings
+
+
+def import_values_csv(text: str) -> Dict[str, Any]:
+    """Import attribute values from CSV text → evaluator bindings dict.
+
+    See the module docstring for the accepted layouts.
+    """
+    rows = list(csv.reader(io.StringIO(text)))
+    return _rows_to_bindings(rows)
+
+
+def import_values_xlsx(path) -> Dict[str, Any]:
+    """Import attribute values from the first sheet of an XLSX workbook."""
+    openpyxl = _require_openpyxl()
+    wb = openpyxl.load_workbook(path, data_only=True)
+    ws = wb.worksheets[0]
+    rows = [[cell.value for cell in row] for row in ws.iter_rows()]
+    return _rows_to_bindings(rows)