sysmlpy 0.64.0__tar.gz → 0.66.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.64.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.64.0 → sysmlpy-0.66.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.64.0"
+version = "0.66.0"
 description = ""
 authors = [{ name = "Jon R. Fox (mycr0ft)", email = "jon.fox@drfox.com" }]
 readme = "README.md"
@@ -19,14 +19,17 @@ 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-lsp = "sysmlpy.lsp.stdio:main"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=8.0,<9.0"

{sysmlpy-0.64.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.64.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.64.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.66.0/src/sysmlpy/lsp/__init__.py

@@ -0,0 +1,24 @@
+# LSP package (v0.65.0 — Adoption Roadmap Goal 5)
+#
+# A minimal Language Server Protocol (LSP 3.17) implementation exposing
+# sysmlpy's parse/analyze pipeline to editors:
+#
+#   textDocument/didOpen|didChange|didClose → publishDiagnostics
+#   textDocument/hover | /documentSymbol | /definition | /completion
+#
+# Layout:
+#   protocol.py — JSON-RPC Content-Length framing + LSP constants
+#   server.py   — transport-agnostic language server (dict in → dict out)
+#   stdio.py    — stdio transport; ``python -m sysmlpy.lsp`` entry point
+#
+# See docs/LSP.md for VS Code / Neovim wiring instructions.
+
+from sysmlpy.lsp.protocol import (
+    encode_message, read_message, ErrorCodes, SymbolKind,
+)
+from sysmlpy.lsp.server import Document, DocumentIndex, SysmlLanguageServer
+
+__all__ = [
+    "encode_message", "read_message", "ErrorCodes", "SymbolKind",
+    "Document", "DocumentIndex", "SysmlLanguageServer",
+]

sysmlpy-0.66.0/src/sysmlpy/lsp/__main__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+"""``python -m sysmlpy.lsp`` — run the language server over stdio."""
+
+import sys
+
+from sysmlpy.lsp.stdio import main
+
+if __name__ == "__main__":
+    sys.exit(main())

sysmlpy-0.66.0/src/sysmlpy/lsp/protocol.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""JSON-RPC / LSP protocol helpers (v0.65.0 — Adoption Roadmap Goal 5).
+
+Implements the ``Content-Length`` message framing used by the Language
+Server Protocol over byte streams, plus the small set of LSP constants
+the server needs.  Deliberately dependency-free so the server core can
+be tested in-process without a transport.
+
+Message framing (both sides):
+
+    Content-Length: <bytes>\\r\\n
+    [Content-Type: application/vscode-jsonrpc; charset=utf-8]\\r\\n
+    \\r\\n
+    <JSON payload>
+"""
+
+from __future__ import annotations
+
+import json
+from typing import BinaryIO, Dict, Any, Optional
+
+HEADER_ENCODING = "ascii"
+PAYLOAD_ENCODING = "utf-8"
+
+
+class ErrorCodes:
+    """JSON-RPC / LSP error codes used by the server."""
+
+    PARSE_ERROR = -32700
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INVALID_PARAMS = -32602
+    INTERNAL_ERROR = -32603
+    SERVER_NOT_INITIALIZED = -32002
+
+
+class SymbolKind:
+    """LSP SymbolKind values used in documentSymbol results."""
+
+    FILE = 1
+    MODULE = 2
+    NAMESPACE = 3
+    PACKAGE = 4
+    CLASS = 5
+    METHOD = 6
+    PROPERTY = 7
+    FIELD = 8
+    ENUM = 10
+    INTERFACE = 11
+    FUNCTION = 12
+    VARIABLE = 13
+    CONSTANT = 14
+    ENUM_MEMBER = 22
+    STRUCT = 23
+
+
+def encode_message(payload: Dict[str, Any]) -> bytes:
+    """Encode a JSON-RPC message dict with LSP ``Content-Length`` framing."""
+    body = json.dumps(payload, ensure_ascii=False).encode(PAYLOAD_ENCODING)
+    header = f"Content-Length: {len(body)}\r\n\r\n".encode(HEADER_ENCODING)
+    return header + body
+
+
+def read_message(stream: BinaryIO) -> Optional[Dict[str, Any]]:
+    """Read one framed JSON-RPC message from a binary stream.
+
+    Returns the decoded message dict, or ``None`` on clean EOF before any
+    header bytes.  Raises ``ValueError`` on malformed framing.
+
+    Tolerates ``\\n``-only header terminators in addition to the spec's
+    ``\\r\\n`` (some clients get this wrong; being lenient costs nothing).
+    """
+    # Read header lines until the blank separator.
+    content_length: Optional[int] = None
+    saw_header_bytes = False
+    while True:
+        line = stream.readline()
+        if not line:
+            if not saw_header_bytes:
+                return None  # clean EOF
+            raise ValueError("EOF while reading message header")
+        stripped = line.strip()
+        if not stripped:
+            if content_length is None and not saw_header_bytes:
+                continue  # tolerate stray blank lines between messages
+            break  # end of headers
+        saw_header_bytes = True
+        name, _, value = stripped.partition(b":")
+        if name.strip().lower() == b"content-length":
+            try:
+                content_length = int(value.strip())
+            except ValueError:
+                raise ValueError(
+                    f"Malformed Content-Length header: {value!r}"
+                ) from None
+
+    if content_length is None:
+        raise ValueError("Missing Content-Length header")
+
+    body = stream.read(content_length)
+    if len(body) < content_length:
+        raise ValueError(
+            f"EOF while reading message body "
+            f"({len(body)} of {content_length} bytes)"
+        )
+    return json.loads(body.decode(PAYLOAD_ENCODING))