sysmlpy 0.65.0__tar.gz → 0.67.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysmlpy
-Version: 0.65.0
+Version: 0.67.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.67.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sysmlpy"
-version = "0.65.0"
+version = "0.67.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.67.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.67.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.67.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.67.0}/src/sysmlpy/antlr_visitor.py

@@ -6550,6 +6550,55 @@ def _make_requirement_usage_dict(ctx, prefix=None):
 def _make_connection_usage_dict(ctx, prefix=None):
     """Create a ConnectionUsage dictionary."""
     name, shortname = _get_usage_identification(ctx)
+
+    # Parse the connector part (``connect X to Y``) so endpoints survive
+    # into the grammar object tree (v0.67.0 — fixes the "part": None stub)
+    # connectionUsage: occurrenceUsagePrefix ( CONNECTION usageDeclaration?
+    #     valuePart? ( CONNECT connectorPart )? | CONNECT connectorPart ) usageBody
+    # — the connectorPart sits directly on the connectionUsage ctx.
+    conn_part_dict = None
+    if ctx is not None:
+        cp = None
+        if hasattr(ctx, 'connectorPart') and ctx.connectorPart():
+            cp = ctx.connectorPart()
+            if isinstance(cp, list):
+                cp = cp[0] if cp else None
+            if cp:
+                end_members = []
+                if hasattr(cp, 'binaryConnectorPart') and cp.binaryConnectorPart():
+                    bcp = cp.binaryConnectorPart()
+                    if isinstance(bcp, list):
+                        bcp = bcp[0] if bcp else None
+                    if bcp and hasattr(bcp, 'connectorEndMember') and bcp.connectorEndMember():
+                        ems = bcp.connectorEndMember()
+                        if isinstance(ems, list):
+                            for em in ems:
+                                end = _visit_connector_end_member(em)
+                                if end:
+                                    end_members.append(end)
+                elif hasattr(cp, 'naryConnectorPart') and cp.naryConnectorPart():
+                    ncp = cp.naryConnectorPart()
+                    if isinstance(ncp, list):
+                        ncp = ncp[0] if ncp else None
+                    if ncp and hasattr(ncp, 'connectorEndMember') and ncp.connectorEndMember():
+                        ems = ncp.connectorEndMember()
+                        if isinstance(ems, list):
+                            for em in ems:
+                                end = _visit_connector_end_member(em)
+                                if end:
+                                    end_members.append(end)
+                if end_members:
+                    conn_part_dict = {
+                        "name": "ConnectorPart",
+                        "part": {
+                            "name": "BinaryConnectorPart",
+                            "ownedRelationship": end_members,
+                        },
+                    }
+                else:
+                    conn_part_dict = None
+    else:
+        conn_part_dict = None
     
     return {
         "name": "PackageMember",
@@ -6575,7 +6624,7 @@ def _make_connection_usage_dict(ctx, prefix=None):
                                 "specialization": None
                             }
                         },
-                        "part": None,
+                        "part": conn_part_dict,
                         "body": {
                             "name": "UsageBody",
                             "body": {

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

@@ -21,7 +21,10 @@ from sysmlpy.definition import Model, Package
 
 # ============================================================
 # Relationship Arrow Mappings
-# Based on the official org.omg.sysml.plantuml reference impl
+# Ground truth: the official org.omg.sysml.plantuml reference impl
+# (SysML2PlantUMLStyle.StyleRelDefaultSwitch, B&W default style) and
+# the OMG "Intro to the SysML v2 Language — Graphical Notation"
+# figures (v0.67.0 — Goal 6 notation fidelity).
 # ============================================================
 
 ARROW_STYLES = {
@@ -30,28 +33,46 @@ ARROW_STYLES = {
     "shared":         "o--",       # hollow diamond (isComposite=False)
     "owning":         "+--",       # plus sign (owning membership)
     "non_owning":     "+..",       # dotted plus (non-owning membership)
+    "variant":        "+---",      # variant membership (official: +---)
 
     # Typing / Specialization
     "typing":         "--:|>",     # colon + block arrow (feature typing)
     "specialization": "--|>",      # block arrow (general specialization)
-    "redefinition":   "--||>",     # double bar + block arrow
+    "redefinition":   "--||>",     # double bar + block arrow (distinct!)
 
     # Connections
-    "binding":        "-[thickness=4,#E74C3C]-",   # thick red line, no arrowhead
-    "connector":      "-[thickness=2,#3498DB]->",  # medium blue arrow
-    "flow":           "-->",       # dotted arrow
-    "succession":     "-->",       # dotted arrow
-    "allocation":     "-[thickness=3,dotted,#9B59B6]->",  # thick dotted purple
+    "binding":        "-[thickness=5]-",   # thick plain line: «bind»/=
+                                           # (both sides asserted equal)
+    "connector":      "-[thickness=3]-",   # thick plain line, no arrowhead
+                                           # (arrow only when it carries
+                                           # metadata — official convention)
+    "connector_directed": "-[thickness=3]->",
+    "flow":           "-->",       # solid thin arrow (item flow)
+    "succession":     "-->",       # solid thin arrow (succession)
+    "succession_flow": "..>",      # dotted arrow (SuccessionFlowUsage)
+    "allocation":     "-[thickness=5,dotted]->",  # thick dotted arrow
 
     # Dependencies
     "dependency":     "..>>",      # dotted double-arrow
-    "satisfy":        "-->",       # dotted arrow
-    "verify":         "-->",       # dotted arrow
-    "derive":         "*--",       # composite containment
+    "satisfy":        "-->",       # solid arrow (SatisfyRequirementUsage)
+    "verify":         "-->",       # solid arrow
+    "derive":         "..>",       # dashed line, «derive»/#derive label
+                                   # (spec figure; official pilot omits it)
     "refine":         "..>>",      # dotted double-arrow
+    "perform":        "-->",       # PerformActionUsage
+    "exhibit":        "-->",       # ExhibitStateUsage
+    "include_use_case": "-->",     # IncludeUseCaseUsage
+
+    # Actions (asynchronous messages)
+    "send_action":    "..>>",      # send action: dotted double-arrow out
+    "accept_action":  "<<..",      # accept action: reversed (arrives here)
+
+    # Requirements extras
+    "objective":      "-->>",      # objective membership (req objectives)
 
     # Comments / Annotations
     "comment":        "..",        # dotted line, no arrowhead
+    "metadata":       "..@",       # metadata annotation
     "import":         "..>",       # dotted arrow
 }
 
@@ -1384,10 +1405,11 @@ def as_interconnection_diagram(model, focus=None, elements=None, style="bw",
             "legend right",
             "  <b>Interconnection Legend</b>",
             "  Relationship: Notation",
-            "  Binding: -[thickness=4]-",
-            "  Connector: -[thickness=2]->",
+            "  Binding (==): -[thickness=5]-",
+            "  Connection: -[thickness=3]-",
             "  Flow Transfer: -->",
-            "  Allocation: -[dotted]->",
+            "  Succession Flow: ..>",
+            "  Allocation: -[thickness=5,dotted]->",
             "  Feature Typing: --:|> ",
             "  Composite (owns): *--",
             "  | Specialization | --|> |",
@@ -1662,7 +1684,9 @@ def as_action_flow_view(model, focus=None, elements=None, style="bw", direction=
             "  <b>Action Flow Legend</b>",
             "  Relationship: Notation",
             "  Flow Transfer: -->",
-            "  Binding: -[thickness=4]-",
+            "  Succession Flow: ..>",
+            "  Binding (==): -[thickness=5]-",
+            "  Connection: -[thickness=3]-",
             "  Composite (owns): *--",
             "  Feature Typing: --:|> ",
             "endlegend",
@@ -1805,6 +1829,79 @@ def _extract_flow_connections(model):
     return connections
 
 
+def _extract_connection_endpoints(conn_element):
+    """Extract (from_names, to_names) from a ConnectionUsage's grammar.
+
+    Navigates ConnectionUsage → ConnectorPart → BinaryConnectorPart →
+    ConnectorEndMember → ConnectorEnd → OwnedReferenceSubsetting to
+    recover the endpoint reference name paths (v0.67.0).
+
+    Returns (from_names, to_names) as lists of name segments, or
+    (None, None) when the grammar does not carry both ends.
+    """
+    g = getattr(conn_element, 'grammar', None)
+    if g is None:
+        return None, None
+    part = getattr(g, 'part', None)
+    binpart = getattr(part, 'part', None) if part is not None else None
+    if binpart is None or binpart.__class__.__name__ != 'BinaryConnectorPart':
+        return None, None
+    members = getattr(binpart, 'children', None) or []
+    ends = []
+    for member in members:
+        names = None
+        for end in (getattr(member, 'children', None) or []):
+            for sub in (getattr(end, 'children', None) or []):
+                if sub.__class__.__name__ == 'OwnedReferenceSubsetting':
+                    seg = []
+                    ref = getattr(sub, 'referencedFeature', None)
+                    if ref is not None and getattr(ref, 'names', None):
+                        seg.extend(ref.names)
+                    for chain in (getattr(sub, 'elements', None) or []):
+                        fc = getattr(chain, 'feature', None)
+                        for oc in (getattr(fc, 'children', None) or []):
+                            cf = getattr(oc, 'chainingFeature', None)
+                            if cf is not None and getattr(cf, 'names', None):
+                                seg.extend(cf.names)
+                    if seg:
+                        names = seg
+        ends.append(names)
+    if len(ends) >= 2 and ends[0] and ends[1]:
+        return ends[0], ends[1]
+    return None, None
+
+
+def _extract_connections(model):
+    """Scan the model for all connector usages (``connection`` elements).
+
+    Returns a list of ``(from_names, to_names, connection_name)``
+    tuples.  Connection edges render as a thick plain line
+    (``-[thickness=3]-``) per the official notation (v0.67.0).
+    """
+    connections = []
+    visited = set()
+
+    def _scan(element):
+        elem_id = id(element)
+        if elem_id in visited:
+            return
+        visited.add(elem_id)
+
+        if getattr(element, 'sysml_type', '') == 'connection':
+            from_names, to_names = _extract_connection_endpoints(element)
+            if from_names and to_names:
+                connections.append((from_names, to_names,
+                                    getattr(element, 'name', None)))
+
+        for child in getattr(element, 'children', []) or []:
+            _scan(child)
+
+    for child in getattr(model, 'children', []) or []:
+        _scan(child)
+
+    return connections
+
+
 def _find_state_in_children(element, state_name):
     """Find a child state element by name within a parent's children tree."""
     if state_name is None:
@@ -2040,18 +2137,58 @@ def as_state_transition_view(model, focus=None, elements=None, style="bw",
     terminal_states = []
     focus_name = getattr(focus, 'name', None) if focus else None
     
-    # Render state elements using PlantUML state keyword for proper state diagram support
+    # Render state elements using PlantUML state keyword for proper state
+    # diagram support; composite states nest their children via state blocks
+    # (official stv notation — v0.67.0)
+    type_by_alias = {}
+    name_by_alias = {}
     for alias, name, stereotype, elem, is_included in elements_list:
-        sysml_type = getattr(elem, 'sysml_type', '')
+        type_by_alias[alias] = getattr(elem, 'sysml_type', '')
+        name_by_alias[alias] = name
+
+    # State containment hierarchy (composite edges between states)
+    state_children = {}
+    for src, arrow, dst, label, is_external in relationships:
+        if (not is_external and arrow == ARROW_STYLES["composite"]
+                and type_by_alias.get(src) == 'state'
+                and type_by_alias.get(dst) == 'state'):
+            state_children.setdefault(src, []).append(dst)
+
+    nested_child_aliases = {c for kids in state_children.values()
+                            for c in kids}
+    emitted = set()
+
+    def _emit_state_block(alias, depth):
+        """Recursively emit a state and its nested child states."""
+        emitted.add(alias)
+        nonlocal first_state_alias
+        name = name_by_alias.get(alias, alias)
+        pad = "  " * depth
+        kids = state_children.get(alias, [])
+        if kids:
+            lines.append(f'{pad}state "{name}" as {alias} {{')
+            for kid in kids:
+                _emit_state_block(kid, depth + 1)
+            lines.append(f'{pad}}}')
+        else:
+            lines.append(f'{pad}state "{name}" as {alias}')
+        # Track terminal states for final marker
+        if name in ('Stopped', 'Error', 'Final'):
+            terminal_states.append(alias)
+        # Skip the focus element itself (parent container); find first
+        # child state for the initial marker
+        if (first_state_alias is None
+                and name not in ('Stopped', 'Error', 'Final')
+                and name != focus_name):
+            first_state_alias = alias
+
+    for alias, name, stereotype, elem, is_included in elements_list:
+        sysml_type = type_by_alias[alias]
         if sysml_type == 'state':
+            if alias in emitted or alias in nested_child_aliases:
+                continue
             # Use state keyword for proper state diagram support (initial/final markers)
-            lines.append(f'state "{name}" as {alias}')
-            # Skip the focus element itself (parent container), find first child state
-            if first_state_alias is None and name not in ('Stopped', 'Error', 'Final') and name != focus_name:
-                first_state_alias = alias
-            # Track terminal states for final marker
-            if name in ('Stopped', 'Error', 'Final'):
-                terminal_states.append(alias)
+            _emit_state_block(alias, 0)
         elif sysml_type in stv_types:
             lines.append(f'rectangle "{name}" as {alias}')
         else:
@@ -2064,8 +2201,11 @@ def as_state_transition_view(model, focus=None, elements=None, style="bw",
         lines.append("[*] --> " + first_state_alias)
         lines.append("")
 
-    # Render containment relationships using simple arrows
+    # Render non-containment relationships (state hierarchy is expressed by
+    # nesting above, not by transition arrows — v0.67.0)
     for src, arrow, dst, label, is_external in relationships:
+        if arrow == ARROW_STYLES["composite"]:
+            continue  # containment shown as nested state blocks
         if is_external and not show_external:
             continue
         if is_external:
@@ -2105,8 +2245,8 @@ def as_state_transition_view(model, focus=None, elements=None, style="bw",
         lines.extend([
             "legend right",
             "  <b>State Transition Legend</b>",
-            "  State Transition: thick green arrow",
-            "  Containment: simple arrow",
+            "  State Transition: -->",
+            "  Composite states: nested state blocks",
             "endlegend",
         ])
         lines.append("")
@@ -2492,7 +2632,8 @@ def as_textual_notation(model, focus=None, style="bw", custom_style=None):
 
 def as_general_view(model, focus=None, elements=None, style="bw", direction="TB",
                     include_legend=True, max_depth=None, show_external=False,
-                    custom_style=None, show_multiplicity=False):
+                    custom_style=None, show_multiplicity=False,
+                    auto_include_connections=False):
     """Generate a General View (GV) diagram.
 
     Corresponds to SysML v2 ``GeneralView`` (short name ``gv``).
@@ -2511,6 +2652,9 @@ def as_general_view(model, focus=None, elements=None, style="bw", direction="TB"
         show_external: Show relationships to elements outside selection
         custom_style: Optional PlantUML style lines to append
         show_multiplicity: Append multiplicity like [4] to element labels
+        auto_include_connections: Render connector edges (``-[thickness=3]-``
+            thick plain lines, official notation) between parts whose both
+            endpoints are already in the view (v0.67.0)
 
     Returns:
         str: PlantUML text
@@ -2754,6 +2898,30 @@ def as_general_view(model, focus=None, elements=None, style="bw", direction="TB"
 
     lines.append("")
 
+    # Render connector edges between parts already in the view
+    # (official: thick plain line, no arrowhead — ConnectionUsage)
+    if auto_include_connections:
+        for from_names, to_names, conn_name in _extract_connections(model):
+            from_elem = (_find_element_by_qualified_name(model, from_names)
+                         if from_names else None)
+            to_elem = (_find_element_by_qualified_name(model, to_names)
+                       if to_names else None)
+            # NOTE: grammar objects may be falsy (they define __len__ for
+            # children) — membership checks must use "is not None" (v0.67.0)
+            from_alias = (id_map.get(id(from_elem))
+                          if from_elem is not None else None)
+            to_alias = (id_map.get(id(to_elem))
+                        if to_elem is not None else None)
+            if from_alias and to_alias:
+                if conn_name:
+                    lines.append(
+                        f'{from_alias} {ARROW_STYLES["connector"]} '
+                        f'{to_alias} : {conn_name}')
+                else:
+                    lines.append(
+                        f'{from_alias} {ARROW_STYLES["connector"]} {to_alias}')
+        lines.append("")
+
     if include_legend:
         lines.extend([
             "legend right",
@@ -2765,11 +2933,16 @@ def as_general_view(model, focus=None, elements=None, style="bw", direction="TB"
             "  Feature Typing: --:|> ",
             "  | Specialization | --|> |",
             "  | Redefinition | --||> |",
-            "  Binding: -[thickness=4]-",
-            "  Connector: -[thickness=2]->",
+            "  Binding (==): -[thickness=5]-",
+            "  Connection: -[thickness=3]-",
             "  Flow Transfer: -->",
-            "  Allocation: -[dotted]->",
+            "  Succession Flow: ..>",
+            "  Allocation: -[thickness=5,dotted]->",
             "  Dependency: ..>>",
+            "  Send Action: ..>>",
+            "  Accept Action: <<..",
+            "  Variant: +---",
+            "  Metadata: ..@",
             "endlegend",
         ])
         lines.append("")
@@ -3139,6 +3312,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 +3439,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 +3541,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 +3711,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: