rfem-table-export 0.2.0__py3-none-any.whl

rfem_export/__init__.py

@@ -0,0 +1,19 @@
+"""RFEM 6 table extraction TUI.
+
+A terminal UI that attaches to a running RFEM 6 process, lets the user pick
+input and result tables from a tree, and exports them to a new Excel workbook
+(one sheet per table plus an info sheet).
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Installed distribution (wheel/sdist, including via uvx/pip).
+    __version__ = version("rfem-table-export")
+except PackageNotFoundError:  # pragma: no cover
+    try:
+        # Built from source: hatch-vcs writes this file at build time.
+        from ._version import __version__
+    except ImportError:
+        # Running from an unbuilt checkout with no tags reachable.
+        __version__ = "0.0.0+unknown"

rfem_export/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = None

rfem_export/app.py

@@ -0,0 +1,262 @@
+"""Textual TUI for exporting RFEM 6 tables to Excel.
+
+Flow:
+  1. Connect to the running RFEM process and read the active model.
+  2. Confirm the model in a banner (user verifies it's the right one).
+  3. Pick input/result tables from a tree.
+  4. Press 'e' to export -> a new timestamped workbook under results/.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Footer, Header, Label, RichLog, Static, Tree
+from textual.widgets.tree import TreeNode
+
+from . import catalog, connection, excel, extract
+
+
+class RfemExportApp(App):
+    CSS = """
+    #model_banner {
+        height: auto;
+        padding: 0 1;
+        background: $boost;
+        color: $text;
+        border: round $primary;
+    }
+    #body { height: 1fr; }
+    #tree_pane { width: 45%; border: round $secondary; }
+    #log_pane { width: 55%; border: round $secondary; }
+    #options { height: auto; padding: 0 1; color: $text-muted; }
+    """
+
+    BINDINGS = [
+        ("space", "toggle", "Toggle table"),
+        ("a", "select_all", "Select all"),
+        ("n", "select_none", "Clear"),
+        ("e", "export", "Export"),
+        ("r", "refresh", "Reconnect"),
+        ("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, api_key: str | None = None) -> None:
+        super().__init__()
+        self._api_key = api_key
+        self._app = None  # rfem.Application
+        self._model = connection.ModelInfo()
+        self._units = connection.UnitSummary()
+        self._selected: set[str] = set()
+        self._exporting = False
+
+    # -- layout ----------------------------------------------------------
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        yield Static("Connecting to RFEM…", id="model_banner")
+        with Horizontal(id="body"):
+            with Vertical(id="tree_pane"):
+                yield self._build_tree()
+            with Vertical(id="log_pane"):
+                yield RichLog(id="log", highlight=True, markup=True, wrap=True)
+        yield Label("", id="options")
+        yield Footer()
+
+    def _build_tree(self) -> Tree:
+        tree: Tree = Tree("Available Tables", id="tree")
+        tree.root.expand()
+        for group in catalog.TREE:
+            self._add_group(tree.root, group)
+        return tree
+
+    def _add_group(self, parent: TreeNode, group: catalog.Group) -> None:
+        node = parent.add(group.name, expand=True, data=None)
+        for table in group.tables:
+            node.add_leaf(self._leaf_label(table.key, table.name), data=table.key)
+        for sub in group.subgroups:
+            self._add_group(node, sub)
+
+    def _leaf_label(self, key: str, name: str) -> str:
+        mark = "☑" if key in self._selected else "☐"  # ☑ / ☐
+        return f"{mark} {name}"
+
+    # -- lifecycle -------------------------------------------------------
+    def on_mount(self) -> None:
+        self._refresh_options()
+        self.connect_rfem()
+
+    @work(thread=True)
+    def connect_rfem(self) -> None:
+        self._set_banner("Connecting to RFEM…")
+        try:
+            api_key = connection.resolve_api_key(self._api_key)
+            if not api_key:
+                self._log("[red]No API key found (config.ini / RFEM_API_KEY).[/red]")
+            self._app = connection.connect(api_key)
+            self._model = connection.get_model_info(self._app)
+            self._units = connection.get_unit_summary(self._app)
+            self._set_banner(self._banner_text())
+            self._log(
+                f"[green]Connected.[/green] Active model: [b]{self._model.name}[/b]"
+            )
+            self._log(f"  Path: {self._model.path}")
+            self._log("Verify this is the correct model before exporting.")
+        except Exception as exc:
+            self._set_banner("[red]Not connected — RFEM not reachable[/red]")
+            self._log(f"[red]Connection failed:[/red] {exc}")
+            self._log("Is RFEM running with a model open? Press 'r' to retry.")
+
+    def _banner_text(self) -> str:
+        return (
+            f"[b]Model:[/b] {self._model.name or '(unknown)'}    "
+            f"[b]Units:[/b] {self._units.system}    "
+            f"[dim]{self._model.path}[/dim]"
+        )
+
+    # -- actions ---------------------------------------------------------
+    def action_toggle(self) -> None:
+        tree = self.query_one("#tree", Tree)
+        node = tree.cursor_node
+        if node is None or node.data is None:
+            return
+        key = node.data
+        if key in self._selected:
+            self._selected.discard(key)
+        else:
+            self._selected.add(key)
+        node.set_label(self._leaf_label(key, catalog.get_table(key).name))
+        self._refresh_options()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        # Enter/click on a leaf toggles it too.
+        if event.node.data is not None:
+            self.action_toggle()
+
+    def action_select_all(self) -> None:
+        self._set_all(True)
+
+    def action_select_none(self) -> None:
+        self._set_all(False)
+
+    def _set_all(self, selected: bool) -> None:
+        tree = self.query_one("#tree", Tree)
+        self._walk_leaves(tree.root, selected)
+        self._refresh_options()
+
+    def _walk_leaves(self, node: TreeNode, selected: bool) -> None:
+        for child in node.children:
+            key = child.data
+            if key is None:
+                self._walk_leaves(child, selected)
+                continue
+            if selected:
+                self._selected.add(key)
+            else:
+                self._selected.discard(key)
+            child.set_label(self._leaf_label(key, catalog.get_table(key).name))
+
+    def action_refresh(self) -> None:
+        self.connect_rfem()
+
+    def action_export(self) -> None:
+        if self._exporting:
+            self._log("[yellow]Export already in progress…[/yellow]")
+            return
+        if self._app is None:
+            self._log("[red]Not connected to RFEM. Press 'r' to connect.[/red]")
+            return
+        if not self._selected:
+            self._log(
+                "[yellow]No tables selected. Use space / 'a' to pick tables.[/yellow]"
+            )
+            return
+        self.run_export()
+
+    @work(thread=True)
+    def run_export(self) -> None:
+        self._exporting = True
+        try:
+            keys = [t.key for t in catalog.iter_tables() if t.key in self._selected]
+            self._log(f"[b]Exporting {len(keys)} table(s)…[/b]")
+
+            sheets: list[tuple[str, object]] = []
+            reports: list[excel.SheetReport] = []
+            for key in keys:
+                table = catalog.get_table(key)
+                self._log(f"  • {table.name}…")
+                result = extract.extract(self._app, table)
+                for w in result.warnings:
+                    self._log(f"    [yellow]warn:[/yellow] {w}")
+                sheets.append((table.name, result.df))
+                reports.append(
+                    excel.SheetReport(
+                        table_name=table.name,
+                        sheet_name=table.name,  # final sheet name resolved in writer
+                        rows=result.rows,
+                        warnings=result.warnings,
+                    )
+                )
+                self._log(f"    {result.rows} row(s)")
+
+            path = excel.write_workbook(
+                model=self._model,
+                units=self._units,
+                scope="All elements",
+                sheets=sheets,
+                reports=reports,
+            )
+            self._log(f"[green]Export complete:[/green] {path}")
+        except Exception as exc:
+            self._log(f"[red]Export failed:[/red] {exc}")
+        finally:
+            self._exporting = False
+
+    # -- helpers ---------------------------------------------------------
+    def _refresh_options(self) -> None:
+        try:
+            label = self.query_one("#options", Label)
+        except Exception:
+            return
+        label.update(
+            f"Scope: All elements (v1)   |   "
+            f"Selected: {len(self._selected)} table(s)   |   "
+            f"space=toggle  a=all  n=none  e=export  r=reconnect  q=quit"
+        )
+
+    def _set_banner(self, text: str) -> None:
+        self.call_from_thread(self._set_banner_sync, text)
+
+    def _set_banner_sync(self, text: str) -> None:
+        self.query_one("#model_banner", Static).update(text)
+
+    def _log(self, text: str) -> None:
+        self.call_from_thread(self._log_sync, text)
+
+    def _log_sync(self, text: str) -> None:
+        self.query_one("#log", RichLog).write(text)
+
+    def on_unmount(self) -> None:
+        if self._app is not None:
+            try:
+                self._app.close_connection()
+            except Exception:
+                pass
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="RFEM 6 table export TUI")
+    parser.add_argument(
+        "--api-key",
+        dest="api_key",
+        default=None,
+        help="RFEM API key (defaults to RFEM_API_KEY then config.ini)",
+    )
+    args = parser.parse_args()
+    RfemExportApp(api_key=args.api_key).run()
+
+
+if __name__ == "__main__":
+    main()

rfem_export/catalog.py

@@ -0,0 +1,266 @@
+"""Curated catalog of exportable RFEM tables, organized as a nested tree that
+mirrors the RFEM 6 GUI navigators.
+
+Hierarchy (top-level navigator -> category -> table), e.g.:
+
+    Structure
+      Basic Objects
+        Materials, Cross-Sections, Nodes, Lines, Members, Surfaces
+      Types for Nodes
+        Nodal Supports
+      Types for Members
+        Member Hinges
+    Load Cases and Combinations
+        Load Cases, Load Combinations, Result Combinations
+    Loads
+        Nodal Loads, Member Loads, Surface Loads
+    Results
+      Nodes / Members / Lines / Surfaces -> their result tables
+
+Two kinds of tables:
+
+* ``input``  — model objects, extracted by enumerating object IDs of a given
+  ``ObjectType`` and reading each object.
+* ``result`` — analysis result tables, extracted per loading via
+  ``get_result_table``.
+
+Add ``TableDef`` entries to the ``TREE`` below to extend coverage — extraction
+and the TUI pick everything up automatically.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import dlubal.api.rfem as rfem
+import dlubal.api.rfem.results as rfem_results
+
+
+@dataclass(frozen=True)
+class TableDef:
+    key: str  # stable unique id
+    name: str  # display name (also seeds the sheet name; must stay unique)
+    kind: str  # "input" | "result"
+    # For inputs:
+    object_type: object | None = None  # rfem.ObjectType.* enum value
+    proto: object | None = None  # proto class, e.g. rfem.structure_core.Node
+    # For results:
+    result_table: object | None = None  # rfem_results.ResultTable.* enum value
+
+
+@dataclass(frozen=True)
+class Group:
+    """A navigator node: holds tables and/or nested subgroups."""
+
+    name: str
+    tables: tuple[TableDef, ...] = field(default_factory=tuple)
+    subgroups: tuple[Group, ...] = field(default_factory=tuple)
+
+
+def _inp(key, name, object_type, proto) -> TableDef:
+    return TableDef(
+        key=key, name=name, kind="input", object_type=object_type, proto=proto
+    )
+
+
+def _res(key, name, result_table) -> TableDef:
+    return TableDef(key=key, name=name, kind="result", result_table=result_table)
+
+
+_RT = rfem_results.ResultTable
+_OT = rfem.ObjectType
+
+
+# --------------------------------------------------------------------------
+# Tree definition — mirrors the RFEM 6 GUI navigators
+# --------------------------------------------------------------------------
+
+TREE: tuple[Group, ...] = (
+    Group(
+        "Structure",
+        subgroups=(
+            Group(
+                "Basic Objects",
+                tables=(
+                    _inp(
+                        "materials",
+                        "Materials",
+                        _OT.OBJECT_TYPE_MATERIAL,
+                        rfem.structure_core.Material,
+                    ),
+                    _inp(
+                        "cross_sections",
+                        "Cross-Sections",
+                        _OT.OBJECT_TYPE_CROSS_SECTION,
+                        rfem.structure_core.CrossSection,
+                    ),
+                    _inp(
+                        "nodes", "Nodes", _OT.OBJECT_TYPE_NODE, rfem.structure_core.Node
+                    ),
+                    _inp(
+                        "lines", "Lines", _OT.OBJECT_TYPE_LINE, rfem.structure_core.Line
+                    ),
+                    _inp(
+                        "members",
+                        "Members",
+                        _OT.OBJECT_TYPE_MEMBER,
+                        rfem.structure_core.Member,
+                    ),
+                    _inp(
+                        "surfaces",
+                        "Surfaces",
+                        _OT.OBJECT_TYPE_SURFACE,
+                        rfem.structure_core.Surface,
+                    ),
+                ),
+            ),
+            Group(
+                "Types for Nodes",
+                tables=(
+                    _inp(
+                        "nodal_supports",
+                        "Nodal Supports",
+                        _OT.OBJECT_TYPE_NODAL_SUPPORT,
+                        rfem.types_for_nodes.NodalSupport,
+                    ),
+                ),
+            ),
+            Group(
+                "Types for Members",
+                tables=(
+                    _inp(
+                        "member_hinges",
+                        "Member Hinges",
+                        _OT.OBJECT_TYPE_MEMBER_HINGE,
+                        rfem.types_for_members.MemberHinge,
+                    ),
+                ),
+            ),
+        ),
+    ),
+    Group(
+        "Load Cases and Combinations",
+        tables=(
+            _inp(
+                "load_cases",
+                "Load Cases",
+                _OT.OBJECT_TYPE_LOAD_CASE,
+                rfem.loading.LoadCase,
+            ),
+            _inp(
+                "load_combinations",
+                "Load Combinations",
+                _OT.OBJECT_TYPE_LOAD_COMBINATION,
+                rfem.loading.LoadCombination,
+            ),
+            _inp(
+                "result_combinations",
+                "Result Combinations",
+                _OT.OBJECT_TYPE_RESULT_COMBINATION,
+                rfem.loading.ResultCombination,
+            ),
+        ),
+    ),
+    Group(
+        "Loads",
+        tables=(
+            _inp(
+                "nodal_loads",
+                "Nodal Loads",
+                _OT.OBJECT_TYPE_NODAL_LOAD,
+                rfem.loads.NodalLoad,
+            ),
+            _inp(
+                "member_loads",
+                "Member Loads",
+                _OT.OBJECT_TYPE_MEMBER_LOAD,
+                rfem.loads.MemberLoad,
+            ),
+            _inp(
+                "surface_loads",
+                "Surface Loads",
+                _OT.OBJECT_TYPE_SURFACE_LOAD,
+                rfem.loads.SurfaceLoad,
+            ),
+        ),
+    ),
+    Group(
+        "Results",
+        subgroups=(
+            Group(
+                "Nodes",
+                tables=(
+                    _res(
+                        "res_node_support_forces",
+                        "Nodal Support Forces",
+                        _RT.STATIC_ANALYSIS_NODES_SUPPORT_FORCES_TABLE,
+                    ),
+                    _res(
+                        "res_node_deformations",
+                        "Nodal Deformations",
+                        _RT.STATIC_ANALYSIS_NODES_GLOBAL_DEFORMATIONS_TABLE,
+                    ),
+                ),
+            ),
+            Group(
+                "Members",
+                tables=(
+                    _res(
+                        "res_member_internal_forces",
+                        "Member Internal Forces",
+                        _RT.STATIC_ANALYSIS_MEMBERS_INTERNAL_FORCES_TABLE,
+                    ),
+                    _res(
+                        "res_member_global_def",
+                        "Member Global Deformations",
+                        _RT.STATIC_ANALYSIS_MEMBERS_GLOBAL_DEFORMATIONS_TABLE,
+                    ),
+                    _res(
+                        "res_member_local_def",
+                        "Member Local Deformations",
+                        _RT.STATIC_ANALYSIS_MEMBERS_LOCAL_DEFORMATIONS_TABLE,
+                    ),
+                ),
+            ),
+            Group(
+                "Lines",
+                tables=(
+                    _res(
+                        "res_line_support_forces",
+                        "Line Support Forces",
+                        _RT.STATIC_ANALYSIS_LINES_SUPPORT_FORCES_TABLE,
+                    ),
+                ),
+            ),
+            Group(
+                "Surfaces",
+                tables=(
+                    _res(
+                        "res_surface_internal_forces",
+                        "Surface Internal Forces",
+                        _RT.STATIC_ANALYSIS_SURFACES_BASIC_INTERNAL_FORCES_MESH_NODES_TABLE,
+                    ),
+                ),
+            ),
+        ),
+    ),
+)
+
+
+# --------------------------------------------------------------------------
+# Traversal helpers
+# --------------------------------------------------------------------------
+
+
+def iter_tables(groups: tuple[Group, ...] = TREE):
+    """Yield every TableDef in tree (display) order."""
+    for group in groups:
+        yield from group.tables
+        yield from iter_tables(group.subgroups)
+
+
+_BY_KEY: dict[str, TableDef] = {t.key: t for t in iter_tables()}
+
+
+def get_table(key: str) -> TableDef:
+    return _BY_KEY[key]

rfem_export/connection.py

@@ -0,0 +1,147 @@
+"""RFEM connection, model identification, and unit-summary helpers.
+
+This is the single source of truth for attaching to a running RFEM 6 process.
+The API key is resolved from (in order): explicit argument, the RFEM_API_KEY
+environment variable, then Dlubal's bundled ``config.ini``.
+"""
+
+from __future__ import annotations
+
+import configparser
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# --- Dlubal bundled Python path -------------------------------------------
+# When this app runs under an interpreter that doesn't already have the dlubal
+# package importable, inject Dlubal's site-packages. Harmless if already present.
+_DLUBAL_SITE_CANDIDATES = [
+    r"C:\Program Files\Dlubal\RFEM 6.14\bin\Lib\site-packages",
+    r"C:\Program Files\Dlubal\RFEM 6.13\bin\Lib\site-packages",
+]
+
+
+def _ensure_dlubal_on_path() -> None:
+    try:
+        import dlubal.api.rfem  # noqa: F401
+
+        return
+    except Exception:
+        pass
+    for candidate in _DLUBAL_SITE_CANDIDATES:
+        if os.path.isdir(candidate) and candidate not in sys.path:
+            sys.path.insert(0, candidate)
+
+
+_ensure_dlubal_on_path()
+
+import dlubal.api.rfem as rfem  # noqa: E402
+
+# config.ini lives next to the dlubal api package, regardless of RFEM version.
+_CONFIG_INI = Path(rfem.__file__).resolve().parent.parent / "config.ini"
+
+
+def _config_candidates() -> list[Path]:
+    """All config.ini locations to check, preferring the active package's."""
+    candidates = [_CONFIG_INI]
+    for site in _DLUBAL_SITE_CANDIDATES:
+        candidates.append(Path(site) / "dlubal" / "api" / "config.ini")
+    # de-dup, keep order
+    seen: set[Path] = set()
+    out: list[Path] = []
+    for c in candidates:
+        if c not in seen:
+            seen.add(c)
+            out.append(c)
+    return out
+
+
+def read_api_key_from_config(config_path: Path | None = None) -> str | None:
+    """Read the 'default' API key from Dlubal's config.ini.
+
+    If ``config_path`` is given, only that file is checked. Otherwise every
+    known Dlubal install's config.ini is scanned (the key is version-specific
+    and may live under a different RFEM version than the active package).
+    """
+    paths = [config_path] if config_path is not None else _config_candidates()
+    for path in paths:
+        cfg = configparser.ConfigParser()
+        cfg.read(path)
+        key = cfg.get("api_keys", "default", fallback=None)
+        if key:
+            return key
+    return None
+
+
+def resolve_api_key(explicit: str | None = None) -> str | None:
+    """Return API key from explicit arg, env var, or config.ini — in that order."""
+    if explicit:
+        return explicit
+    env = os.environ.get("RFEM_API_KEY")
+    if env:
+        return env
+    return read_api_key_from_config()
+
+
+@dataclass
+class ModelInfo:
+    name: str = ""
+    path: str = ""
+    guid: str = ""
+
+
+@dataclass
+class UnitSummary:
+    """A flat label->value view of the model's unit/format settings."""
+
+    system: str = "model"  # we always export in the model's configured units
+    details: dict[str, str] = field(default_factory=dict)
+
+
+def connect(api_key: str | None):
+    """Open a long-lived RFEM Application bound to the active model.
+
+    The caller owns the lifecycle; close it with ``app.close_connection()`` or
+    use it as a context manager. Raises on connection failure.
+    """
+    return rfem.Application(api_key_value=api_key)
+
+
+def get_model_info(app) -> ModelInfo:
+    """Return name/path/guid of the active model.
+
+    ``get_model_list().model_info`` has been observed both as a repeated field
+    (indexable) and as a singular message, so we handle both shapes.
+    """
+    models = app.get_model_list()
+    mi = models.model_info
+    # repeated/indexable shape
+    try:
+        first = mi[0]
+    except (TypeError, KeyError, IndexError):
+        first = mi  # singular message
+    return ModelInfo(
+        name=getattr(first, "name", "") or "",
+        path=getattr(first, "path", "") or "",
+        guid=getattr(first, "guid", "") or "",
+    )
+
+
+def get_unit_summary(app) -> UnitSummary:
+    """Describe the units regime for the info sheet.
+
+    v1 does not convert units — every value is written exactly as the RFEM API
+    returns it, i.e. in the model's own configured units. RFEM does not expose a
+    unit table via BaseData, so this is a descriptive label plus a couple of
+    informational settings when available.
+    """
+    summary = UnitSummary(system="Model units (no conversion applied)")
+    try:
+        gs = app.get_base_data().general_settings
+        accel = getattr(gs, "gravitational_acceleration", None)
+        if accel:
+            summary.details["gravitational_acceleration"] = str(accel)
+    except Exception:
+        pass
+    return summary

rfem_export/excel.py

@@ -0,0 +1,161 @@
+"""Workbook writer: one sheet per exported table plus an info sheet.
+
+Always writes a new timestamped file under ``results/``. Sheet formatting
+(frozen header, auto-sized columns, named Excel Table) generalizes the pattern
+from the original export_reactions.py proof-of-concept.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+import pandas as pd
+from openpyxl import Workbook
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.table import Table as XlTable
+from openpyxl.worksheet.table import TableStyleInfo
+
+from .connection import ModelInfo, UnitSummary
+
+OUTPUT_DIR = Path(__file__).resolve().parent.parent / "results"
+
+_INVALID_SHEET_CHARS = re.compile(r"[\[\]\:\*\?\/\\]")
+
+
+@dataclass
+class SheetReport:
+    table_name: str
+    sheet_name: str
+    rows: int
+    warnings: list[str]
+
+
+def _safe_filename(model_name: str) -> str:
+    cleaned = "".join(c if c.isalnum() or c in " ._-" else "_" for c in model_name)
+    return cleaned or "model"
+
+
+def _sheet_name(raw: str, used: set[str]) -> str:
+    """Sanitize to Excel's rules (<=31 chars, no special chars, unique)."""
+    name = _INVALID_SHEET_CHARS.sub(" ", raw).strip() or "Sheet"
+    name = name[:31]
+    base = name
+    i = 2
+    while name.lower() in used:
+        suffix = f" ({i})"
+        name = base[: 31 - len(suffix)] + suffix
+        i += 1
+    used.add(name.lower())
+    return name
+
+
+def _style_sheet(ws, table_display_name: str) -> None:
+    if ws.max_row < 1:
+        return
+    ws.freeze_panes = "A2"
+    for col_idx, col_cells in enumerate(ws.columns, start=1):
+        max_len = max(
+            (len(str(cell.value)) if cell.value is not None else 0)
+            for cell in col_cells
+        )
+        ws.column_dimensions[get_column_letter(col_idx)].width = min(max_len + 2, 40)
+
+    # Named Excel Table (only valid when there's at least a header + the table
+    # has columns). Display name must be unique and contain no spaces.
+    if ws.max_column >= 1 and ws.max_row >= 1:
+        ref = f"A1:{get_column_letter(ws.max_column)}{ws.max_row}"
+        disp = re.sub(r"\W", "_", table_display_name) or "Table"
+        disp = f"T_{disp}"[:255]
+        try:
+            xl = XlTable(displayName=disp, ref=ref)
+            xl.tableStyleInfo = TableStyleInfo(
+                name="TableStyleMedium9",
+                showRowStripes=True,
+            )
+            ws.add_table(xl)
+        except Exception:
+            pass  # styling is best-effort; data is what matters
+
+
+def _write_dataframe(ws, df: pd.DataFrame) -> None:
+    if df is None or df.empty:
+        ws.append(["(no data)"])
+        return
+    ws.append([str(c) for c in df.columns])
+    for row in df.itertuples(index=False, name=None):
+        ws.append([_cell(v) for v in row])
+
+
+def _cell(v):
+    if v is None:
+        return None
+    if isinstance(v, (int, float, str, bool)):
+        return v
+    return str(v)
+
+
+def write_workbook(
+    *,
+    model: ModelInfo,
+    units: UnitSummary,
+    scope: str,
+    sheets: list[tuple[str, pd.DataFrame]],
+    reports: list[SheetReport],
+    output_dir: Path = OUTPUT_DIR,
+) -> Path:
+    """Write all sheets + an info sheet to a new timestamped workbook."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = output_dir / f"rfem_export_{_safe_filename(model.name)}_{timestamp}.xlsx"
+
+    wb = Workbook()
+    # First sheet is the info sheet.
+    info_ws = wb.active
+    info_ws.title = "Export Info"
+    _write_info_sheet(info_ws, model, units, scope, reports, timestamp)
+
+    used = {"export info"}
+    for table_display_name, df in sheets:
+        ws = wb.create_sheet(title=_sheet_name(table_display_name, used))
+        _write_dataframe(ws, df)
+        _style_sheet(ws, table_display_name)
+
+    wb.save(filename)
+    return filename
+
+
+def _write_info_sheet(
+    ws,
+    model: ModelInfo,
+    units: UnitSummary,
+    scope: str,
+    reports: list[SheetReport],
+    timestamp: str,
+) -> None:
+    ws.append(["RFEM Table Export"])
+    ws.append([])
+    ws.append(["Model name", model.name])
+    ws.append(["Model path", model.path])
+    ws.append(["Model GUID", model.guid])
+    ws.append(["Exported at", timestamp])
+    ws.append(["Scope", scope])
+    ws.append(["Unit system", units.system])
+    if units.details:
+        ws.append([])
+        ws.append(["Unit settings"])
+        for k, v in units.details.items():
+            ws.append([k, v])
+
+    ws.append([])
+    ws.append(["Exported tables"])
+    ws.append(["Table", "Sheet", "Rows", "Warnings"])
+    for r in reports:
+        ws.append([r.table_name, r.sheet_name, r.rows, " | ".join(r.warnings)])
+
+    ws.column_dimensions["A"].width = 22
+    ws.column_dimensions["B"].width = 30
+    ws.column_dimensions["C"].width = 10
+    ws.column_dimensions["D"].width = 80

rfem_export/extract.py

@@ -0,0 +1,205 @@
+"""Extraction of input objects and result tables into pandas DataFrames.
+
+Every extractor returns an ``ExtractResult`` carrying the DataFrame plus a list
+of human-readable warnings, so a single problematic table can never abort the
+whole export.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import pandas as pd
+from google.protobuf.json_format import MessageToDict
+
+# Import order matters: importing ``connection`` injects Dlubal's bundled
+# site-packages onto sys.path, which must happen before ``dlubal.api.rfem`` is
+# imported. Do not let isort reorder these (see per-file-ignores in pyproject).
+from . import connection  # noqa: F401  (side effect: makes dlubal importable)
+import dlubal.api.rfem as rfem  # noqa: E402
+
+from .catalog import TableDef
+
+
+@dataclass
+class ExtractResult:
+    df: pd.DataFrame = field(default_factory=pd.DataFrame)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def rows(self) -> int:
+        return 0 if self.df is None else len(self.df)
+
+
+# --------------------------------------------------------------------------
+# Input objects
+# --------------------------------------------------------------------------
+
+
+def _object_ids(app, object_type) -> list[int]:
+    id_list = app.get_object_id_list(object_type=object_type)
+    return [oid.no for oid in id_list.object_id]
+
+
+# Some objects (notably loads) are children of another object and cannot be
+# read without naming that parent on the proto. Map the parent's ObjectType to
+# the proto field that addresses it.
+_PARENT_FIELD_BY_TYPE = {
+    rfem.ObjectType.OBJECT_TYPE_LOAD_CASE: "load_case",
+    rfem.ObjectType.OBJECT_TYPE_LOAD_COMBINATION: "load_combination",
+}
+
+
+def _object_id_entries(app, object_type) -> list:
+    """Return the full object_id messages (carry no + parent info)."""
+    id_list = app.get_object_id_list(object_type=object_type)
+    return list(id_list.object_id)
+
+
+def _build_proto(proto, oid):
+    """Construct a proto for get_object, setting any required parent field."""
+    kwargs = {"no": oid.no}
+    parent_no = getattr(oid, "parent_no", 0)
+    if parent_no:
+        field = _PARENT_FIELD_BY_TYPE.get(getattr(oid, "parent_object_type", None))
+        # Only set the parent field if the proto actually declares it.
+        if field and field in {f.name for f in proto.DESCRIPTOR.fields}:
+            kwargs[field] = parent_no
+    return proto(**kwargs)
+
+
+def _proto_to_row(msg) -> dict:
+    """Flatten a protobuf message to a single flat dict row."""
+    d = MessageToDict(
+        msg,
+        preserving_proto_field_name=True,
+        use_integers_for_enums=False,
+    )
+    return d
+
+
+def extract_input(app, table: TableDef) -> ExtractResult:
+    res = ExtractResult()
+    try:
+        entries = _object_id_entries(app, table.object_type)
+    except Exception as exc:
+        res.warnings.append(f"{table.name}: could not list object IDs — {exc}")
+        return res
+
+    if not entries:
+        res.warnings.append(f"{table.name}: no objects of this type in the model")
+        return res
+
+    rows: list[dict] = []
+    failures = 0
+    last_error = ""
+    for oid in entries:
+        try:
+            obj = app.get_object(_build_proto(table.proto, oid))
+            rows.append(_proto_to_row(obj))
+        except Exception as exc:
+            failures += 1
+            last_error = (
+                str(exc).splitlines()[0] if str(exc) else exc.__class__.__name__
+            )
+
+    if failures:
+        res.warnings.append(
+            f"{table.name}: {failures} of {len(entries)} object(s) could not be read"
+            + (f" — {last_error}" if last_error else "")
+        )
+
+    if not rows:
+        res.warnings.append(f"{table.name}: no readable objects")
+        return res
+
+    res.df = pd.json_normalize(rows)
+    return res
+
+
+# --------------------------------------------------------------------------
+# Result tables (iterated over every loading)
+# --------------------------------------------------------------------------
+
+_LOADING_SPECS = [
+    ("Load Case", rfem.ObjectType.OBJECT_TYPE_LOAD_CASE, rfem.loading.LoadCase),
+    (
+        "Load Combination",
+        rfem.ObjectType.OBJECT_TYPE_LOAD_COMBINATION,
+        rfem.loading.LoadCombination,
+    ),
+    (
+        "Result Combination",
+        rfem.ObjectType.OBJECT_TYPE_RESULT_COMBINATION,
+        rfem.loading.ResultCombination,
+    ),
+]
+
+
+def _list_loadings(app) -> list[tuple[str, int, str, object]]:
+    """Return (label, no, name, object_type) for every load case/combination."""
+    out: list[tuple[str, int, str, object]] = []
+    for label, obj_type, proto in _LOADING_SPECS:
+        try:
+            ids = _object_ids(app, obj_type)
+        except Exception:
+            continue
+        for no in ids:
+            try:
+                obj = app.get_object(proto(no=no))
+                name = getattr(obj, "name", "") or ""
+            except Exception:
+                name = ""
+            out.append((label, no, name, obj_type))
+    return out
+
+
+def extract_result(app, table: TableDef) -> ExtractResult:
+    res = ExtractResult()
+
+    try:
+        hr = app.has_results()
+        has = getattr(hr, "value", hr)  # has_results() returns a BoolValue wrapper
+        if not has:
+            res.warnings.append(f"{table.name}: model has no analysis results")
+            return res
+    except Exception as exc:
+        res.warnings.append(f"{table.name}: has_results() failed — {exc}")
+        return res
+
+    loadings = _list_loadings(app)
+    if not loadings:
+        res.warnings.append(f"{table.name}: no load cases or combinations found")
+        return res
+
+    frames: list[pd.DataFrame] = []
+    for loading_type, no, name, obj_type in loadings:
+        label = f"{loading_type} {no} ({name})"
+        try:
+            loading_id = rfem.ObjectId(no=no, object_type=obj_type)
+            result_table = app.get_result_table(table.result_table, loading_id)
+            data = getattr(result_table, "data", None)
+            if data is None or len(data) == 0:
+                continue
+            df = data.copy()
+            df.insert(0, "loading_type", loading_type)
+            df.insert(1, "loading_no", no)
+            df.insert(2, "loading_name", name)
+            frames.append(df)
+        except Exception as exc:
+            res.warnings.append(f"{table.name}: {label} skipped — {exc}")
+
+    if not frames:
+        res.warnings.append(f"{table.name}: no result rows across any loading")
+        return res
+
+    res.df = pd.concat(frames, ignore_index=True)
+    return res
+
+
+def extract(app, table: TableDef) -> ExtractResult:
+    if table.kind == "input":
+        return extract_input(app, table)
+    if table.kind == "result":
+        return extract_result(app, table)
+    return ExtractResult(warnings=[f"{table.name}: unknown table kind '{table.kind}'"])

rfem_table_export-0.2.0.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: rfem-table-export
+Version: 0.2.0
+Summary: Terminal UI for exporting RFEM 6 input and result tables to Excel
+Project-URL: Homepage, https://github.com/Mark-Milkis/rfem-table-export
+Project-URL: Repository, https://github.com/Mark-Milkis/rfem-table-export
+Project-URL: Issues, https://github.com/Mark-Milkis/rfem-table-export/issues
+Author-email: Mark Milkis <markmilkis@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: dlubal,engineering,excel,export,rfem,structural,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: dlubal-api==2.14.3
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pandas>=2.0
+Requires-Dist: textual>=0.80
+Description-Content-Type: text/markdown
+
+# rfem-table-export
+
+A terminal UI (TUI) for exporting [RFEM 6](https://www.dlubal.com/en/products/rfem-fea-software/what-is-rfem)
+tables — both model **inputs** and analysis **results** — to a formatted Excel
+workbook. It attaches to an already-running RFEM 6 process over the Dlubal gRPC
+API, lets you confirm the active model, pick tables from a tree that mirrors the
+RFEM GUI navigators, and writes a new timestamped `.xlsx` with one sheet per
+table plus an info sheet capturing export metadata and any warnings.
+
+The table-picker UX is modeled on SAP2000's "Export Tables to Excel" dialog.
+
+## Features
+
+- **Attach to a live model** — connects to the running RFEM 6 process and shows
+  the active model's name and path so you can verify you're exporting the right
+  one before you start.
+- **Navigator-style table tree** — tables are organized exactly like the RFEM
+  GUI (Structure → Basic Objects → Nodes, …; Load Cases and Combinations; Loads;
+  Results → Nodes/Members/Lines/Surfaces).
+- **Inputs and results** — model objects (nodes, members, surfaces, materials,
+  cross-sections, supports, hinges, load cases/combinations, loads) and static
+  result tables (support forces, internal forces, deformations) iterated across
+  every load case and combination.
+- **Model units, no surprises** — values are written exactly as the RFEM API
+  returns them (the model's own units); the info sheet records this.
+- **One workbook per export** — a new file is always written to `results/`;
+  nothing is overwritten.
+- **Resilient** — a single problematic table produces a warning on the info
+  sheet rather than aborting the whole export.
+
+## Requirements
+
+- Windows with **RFEM 6.14** installed and running, a model open, and the gRPC
+  web service / API enabled.
+- A valid Dlubal API key (see [Configuration](#configuration)).
+- Python 3.11+.
+
+> **Version pin:** the `dlubal-api` client version must match the RFEM server
+> version. This project pins `dlubal-api==2.14.3` for **RFEM 6.14**. If you run a
+> different RFEM version, change the pin to match — mismatched versions cause
+> object-type enum drift and silently wrong/empty exports.
+
+## Installation
+
+### Run without installing (recommended)
+
+With [uv](https://docs.astral.sh/uv/) you can run the latest published release
+directly — no clone, no virtualenv:
+
+```bash
+uvx rfem-table-export
+```
+
+Pin a specific version (handy for matching your RFEM/`dlubal-api` version):
+
+```bash
+uvx rfem-table-export@0.2.0
+```
+
+> The console command is also available as `rfem-export`; with `uvx` use the
+> distribution name (`rfem-table-export`) so version pinning works.
+
+### From a clone (for development)
+
+```bash
+uv sync
+```
+
+Or with pip:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+1. Start RFEM 6, open and (for result tables) solve your model.
+2. Launch the TUI:
+
+   ```bash
+   uv run rfem-export
+   # or
+   python -m rfem_export.app
+   ```
+
+3. Confirm the banner shows the correct active model.
+4. Navigate the tree and toggle the tables you want:
+
+   | Key     | Action            |
+   |---------|-------------------|
+   | `space` | Toggle table      |
+   | `a`     | Select all        |
+   | `n`     | Clear selection   |
+   | `e`     | Export            |
+   | `r`     | Reconnect to RFEM |
+   | `q`     | Quit              |
+
+5. Press `e`. The workbook is written to `results/rfem_export_<model>_<timestamp>.xlsx`.
+
+## Configuration
+
+The API key is resolved in this order:
+
+1. `--api-key` command-line argument
+2. `RFEM_API_KEY` environment variable
+3. Dlubal's bundled `config.ini` (`[api_keys] default = …`), scanned across
+   installed RFEM versions
+
+```bash
+uv run rfem-export --api-key YOUR_KEY
+```
+
+## Project layout
+
+```
+rfem_export/
+  __init__.py
+  connection.py   # API-key resolution, attach to RFEM, model info, unit summary
+  catalog.py      # curated navigator tree of exportable tables (TableDef / Group)
+  extract.py      # protobuf objects + result tables -> pandas DataFrames
+  excel.py        # workbook writer: one sheet per table + info sheet
+  app.py          # Textual TUI + console entry point
+examples/
+  export_reactions.py   # original single-table proof-of-concept
+```
+
+### Extending table coverage
+
+Add a `TableDef` to the `TREE` in [`rfem_export/catalog.py`](rfem_export/catalog.py).
+Both extraction and the TUI pick up new entries automatically — inputs are
+extracted by enumerating object IDs of an `ObjectType`; results via
+`get_result_table` across every loading.
+
+## Development
+
+Lint and format with [ruff](https://docs.astral.sh/ruff/) (the same checks CI
+runs):
+
+```bash
+uvx ruff check .          # lint
+uvx ruff format --check . # formatting
+uvx ruff format .         # auto-format
+```
+
+## Versioning & releases
+
+The package version is **derived automatically from git tags** via
+[`hatch-vcs`](https://github.com/ofek/hatch-vcs) — there is no hardcoded
+version to bump. Tag `vX.Y.Z` becomes version `X.Y.Z`.
+
+To cut a release:
+
+```bash
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+Pushing the tag triggers the **Release** workflow, which lints, builds the
+sdist/wheel, verifies the built version matches the tag, publishes to
+[PyPI](https://pypi.org/p/rfem-table-export), and creates a GitHub release.
+
+> **One-time PyPI setup:** publishing uses
+> [Trusted Publishing (OIDC)](https://docs.pypi.org/trusted-publishers/), so no
+> API token is stored. On PyPI, add a trusted publisher for this project with:
+> owner `Mark-Milkis`, repository `rfem-table-export`, workflow
+> `release.yml`, and environment `pypi`. (For the very first publish you may
+> need to use the "pending publisher" flow since the project doesn't exist on
+> PyPI yet.)
+
+## License
+
+[MIT](LICENSE)

rfem_table_export-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+rfem_export/__init__.py,sha256=WJpWLZl_t-PapyWMeoA48U5IhJX9tra33ZRaC4MblBE,715
+rfem_export/_version.py,sha256=s9U3X54Pdr-Jlh9GP6LBaa_VRos7qs_wtrVefUHHNIA,520
+rfem_export/app.py,sha256=1cXsU3SPhTY5NO5c6t8w_2kJGLgXEO9c6UXe4FDsN4E,9283
+rfem_export/catalog.py,sha256=iQepQBZ6ifmQrDwqHYcm-lhcvZ1EOdRerZ1dbfqCaBI,8379
+rfem_export/connection.py,sha256=9y60AU-5OLNDkK7rXlqlzPyj0JuNSwwtOMZUBIGvotQ,4759
+rfem_export/excel.py,sha256=IGidIH18Sgl1nYmJDW6uVZ4AVpDInS9P526dz0GfSaU,4893
+rfem_export/extract.py,sha256=ShqExN2WNNhpTPbAuScbdooJBHOu7u99NX1Lz5JmdYs,6846
+rfem_table_export-0.2.0.dist-info/METADATA,sha256=Gs_1DTMlrrWW_PtPhEDd8_aj8JRhpsqBp7V0LxLdYLw,6804
+rfem_table_export-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rfem_table_export-0.2.0.dist-info/entry_points.txt,sha256=av0dTvJqoTQkzCNQCD0O1K9tY-s913MwcE5b4rNtgX4,94
+rfem_table_export-0.2.0.dist-info/licenses/LICENSE,sha256=CQtzw8-Piq2t7Gl6mCWuVeg8fKoNOL57AeHyi6etPfY,1068
+rfem_table_export-0.2.0.dist-info/RECORD,,

rfem_table_export-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rfem_table_export-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+rfem-export = rfem_export.app:main
+rfem-table-export = rfem_export.app:main

rfem_table_export-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Milkis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.