fmu-manipulation-toolbox 2.1.dev0__tar.gz → 2.1.dev1__tar.gz

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/CHANGELOG.md

@@ -18,8 +18,35 @@ Not released yet. Changes since 2.0, with the same legend as 2.0.
   `source` outside the archive is refused. SSP 2.0 files are read; a component without `source` (SSP 2.0) is
   ignored with a warning, together with its connections.
 
+## AI agents
+
+- 🟢 **ADDED** **agent skills**: a Claude Code plugin (the repository is a marketplace:
+  `/plugin marketplace add grouperenault/fmutool`) with the skills `fmu-inspect`, `fmu-edit` and
+  `fmu-container`, which drive the MCP server, or `fmutool-agent` without it; `tools/build_skill_zips.py` builds
+  them for claude.ai. They need the toolbox 2.1.dev1 or later (`compatibility` field), and check it by the tools
+  available. See [Agent skills](docs/user-guide/agent-skills.md).
+- 🟢 **ADDED** `fmutool-agent`: the tools of the MCP server as a JSON command line (same arguments, same
+  results), for agents that only run commands. It needs neither `fastmcp` nor Pydantic; the assembly is kept
+  between calls in the file given by `--state`. `fmutool-agent list-tools` prints the version of the toolbox.
+- 🟢 **ADDED** MCP tool `describe_port`: everything declared about one port (every attribute, FMI 3 dimensions,
+  declared type and the attributes inherited from it, aliases, terminals).
+- 🟢 **ADDED** MCP filters `type` and `variability` on `list_fmu_ports`, `inspect_fmu_file` and
+  `apply_operation`; on an FMI 3 FMU, an FMI 2 type selects its family (`Real`: `Float32`, `Float64`).
+- 🔴 **BREAKING** MCP tool `rename_ports_from_csv` replaced by `rename_ports`, which takes a `mapping`
+  (`{"old": "new"}`) or the `csv`, and reports the names of the mapping absent from the FMU (`unknown`).
+- 🔵 **CHANGED** shorter descriptions of some MCP tools and container options, to make room for the new tools
+  in the context of small models.
+
 ## fmutool and the Python API
 
+- 🟢 **ADDED** `-only-type` and `-only-variability` options of `fmutool`, and the `types` and `variabilities`
+  arguments of `FMU.apply_operation`: an operation restricted to some types (an FMI 2 type selects its FMI 3
+  family) or variabilities (the default of the standard when a port declares none), combined with the
+  causality filters.
+- 🟢 **ADDED** `OperationRename`: renaming, or removal, from a mapping of names; `OperationRenameFromCSV` derives
+  from it.
+- 🟢 **ADDED** `ModelVariable.causality` and `ModelVariable.variability`, with the defaults of the standard, and
+  `ModelVariable.has_type`.
 - 🟢 **ADDED** `-debug` option of `fmutool` and `fmutool-gui` (at launch): the `DEBUG` lines are logged, in the log
   area for `fmutool-gui`, e.g. the command lines of the compiler and of the linker of `-compile-sources`.
 

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/MANIFEST.in

@@ -2,13 +2,15 @@
 # With setuptools-scm, every file tracked by git goes into the sdist by default. Keep the Python package and the C
 # sources of the native binaries (container/, remoting/, and the FMI headers in
 # fmu_manipulation_toolbox/resources/fmi/); leave out the test data, the documentation, the CI
-# configuration and the prebuilt binaries.
+# configuration, the Claude Code plugin and the prebuilt binaries.
 #
 # The wheel needs the prebuilt binaries: build it from the source tree, not from the sdist
 # (`python -m build --sdist --wheel`).
 prune tests/data
 prune docs
 prune .github
+prune plugins
+prune .claude-plugin
 recursive-exclude fmu_manipulation_toolbox/resources/win32 *
 recursive-exclude fmu_manipulation_toolbox/resources/win64 *
 recursive-exclude fmu_manipulation_toolbox/resources/linux32 *

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 2.1.dev0
+Version: 2.1.dev1
 Summary: FMU Manipulation Toolbox is a python package which helps to analyze, modify, validate, combine or split Functional Mock-up Units (FMUs) without recompilation, through a GUI, a CLI or a Python API.
 Author-email: Nicolas LAURENT <Nicolas.LAURENT@Renault.com>
 License-Expression: BSD-2-Clause
@@ -122,6 +122,13 @@ extra:
 pip install "fmu-manipulation-toolbox[mcp]"
 ```
 
+With Claude Code, the `fmutool` plugin adds skills to inspect FMUs, edit their interface and build containers
+([Agent skills](docs/user-guide/agent-skills.md)); they need version 2.1.dev1 or later of the toolbox:
+
+```
+/plugin install fmutool --marketplace grouperenault/fmutool
+```
+
 
 ### Supported platforms
 

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/README.md

@@ -72,6 +72,13 @@ extra:
 pip install "fmu-manipulation-toolbox[mcp]"
 ```
 
+With Claude Code, the `fmutool` plugin adds skills to inspect FMUs, edit their interface and build containers
+([Agent skills](docs/user-guide/agent-skills.md)); they need version 2.1.dev1 or later of the toolbox:
+
+```
+/plugin install fmutool --marketplace grouperenault/fmutool
+```
+
 
 ### Supported platforms
 

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.dev0'
-__version_tuple__ = version_tuple = (2, 1, 'dev0')
+__version__ = version = '2.1.dev1'
+__version_tuple__ = version_tuple = (2, 1, 'dev1')
 
-__commit_id__ = commit_id = 'g1144bc002'
+__commit_id__ = commit_id = 'g3d2800ab9'

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/assistant/fmutools.py

@@ -16,6 +16,7 @@ Two design points are worth stating, because they shape the whole module:
   the read-only tools here never call it.
 """
 
+import difflib
 import logging
 import re
 from contextlib import contextmanager
@@ -23,9 +24,11 @@ from pathlib import Path
 from typing import Any
 
 from ..checker import get_checkers
+from ..model_description import ModelDescription, ModelVariable, default_variability, matches_type
+from ..terminals import Terminals
 from ..operations import (
     FMU, OperationKeepOnlyRegexp, OperationMergeTopLevel, OperationRemoveRegexp,
-    OperationRemoveSources, OperationRenameFromCSV, OperationSaveNamesToCSV,
+    OperationRemoveSources, OperationRename, OperationRenameFromCSV, OperationSaveNamesToCSV,
     OperationStripTopLevel, OperationSummary, OperationTrimUntil,
 )
 
@@ -47,6 +50,51 @@ OPERATIONS = {
 #: Causalities an operation can be restricted to.
 CAUSALITIES = ("input", "output", "parameter", "local")
 
+#: Types a port filter accepts: the FMI 2.0 names (which also select their FMI 3.0 family) and the FMI 3.0 ones.
+TYPES = tuple(dict.fromkeys(ModelDescription.FMI2_VARIABLE_TYPES + ModelDescription.FMI3_VARIABLE_TYPES))
+
+#: Variabilities a port filter accepts.
+VARIABILITIES = ModelDescription.VARIABILITIES
+
+
+def check_port_filters(causality: list[str] | None = None, types: list[str] | None = None,
+                       variabilities: list[str] | None = None) -> None:
+    """Refuse the unknown values of the port filters, listing the accepted ones.
+
+    Raises:
+        ValueError: If a value is not one of :data:`CAUSALITIES`, :data:`TYPES`
+            or :data:`VARIABILITIES`.
+    """
+    for label, values, accepted in (("causality", causality, CAUSALITIES), ("type", types, TYPES),
+                                    ("variability", variabilities, VARIABILITIES)):
+        unknown = set(values or ()) - set(accepted)
+        if unknown:
+            raise ValueError(f"Unknown {label} {sorted(unknown)}. Available: {list(accepted)}.")
+
+
+def select_ports(ports: list[dict[str, Any]], fmi_version: int | None, causality: list[str] | None = None,
+                 types: list[str] | None = None, variabilities: list[str] | None = None) -> list[dict[str, Any]]:
+    """The ports of a description (`describe_fmu`, the bridges) that every filter set accepts.
+
+    Same rules as `FMU.apply_operation`: FMI 2.0 type names select their FMI
+    3.0 family, an undeclared variability is the default of the standard.
+    """
+    # Any causality can be listed (`independent`, `calculatedParameter`...): only the other filters are checked.
+    check_port_filters(None, types, variabilities)
+    version = fmi_version or 2
+    selected = []
+    for port in ports:
+        port_causality = port.get("causality") or "local"
+        if causality and port_causality not in causality:
+            continue
+        if types and not matches_type(version, port.get("type"), types):
+            continue
+        if variabilities and (port.get("variability")
+                              or default_variability(version, port_causality, port.get("type"))) not in variabilities:
+            continue
+        selected.append(port)
+    return selected
+
 
 @contextmanager
 def _captured_logs(level: int = logging.DEBUG):
@@ -124,6 +172,122 @@ def summarize_fmu(path: Path) -> dict[str, Any]:
     return summary
 
 
+#: Aliases listed by `describe_port`: an FMI 2.0 FMU may share one value reference between many variables.
+MAX_ALIASES = 20
+
+
+def describe_port(path: Path, port: str) -> dict[str, Any]:
+    """Describe one port of an FMU with everything its descriptor declares.
+
+    The port pages (`describe_fmu`) keep a few fields per port to stay small;
+    this is the full card of a single port.
+
+    Args:
+        path: Path to an existing ``.fmu`` file.
+        port: Name of the port.
+
+    Returns:
+        A mapping with ``fmu``, ``fmi_version``, ``name``, ``type``,
+        ``causality`` and ``variability`` (the defaults of the standard when not
+        declared), ``attributes`` (every attribute as declared, FMI 2.0
+        ``<ScalarVariable>`` and type element merged, and the ``<Start>`` values
+        of FMI 3.0 ``String`` and ``Binary`` variables under ``start``), and
+        when they apply: ``dimensions`` (FMI 3.0 arrays), ``declared_type``
+        (name, attributes and enumeration items of the type definition, and
+        ``inherited``: the attributes the port takes from it), ``aliases`` (the
+        first :data:`MAX_ALIASES`, with ``aliases_total`` beyond) and ``terminals``
+        (terminal name, kind and member name).
+
+    Raises:
+        ValueError: If the FMU has no such port; the message suggests close names.
+    """
+    with FMU(str(path)) as fmu:
+        md = fmu.model_description
+        variables = {element.get("name"): element for element in md.variables()}
+        element = variables.get(port)
+        if element is None:
+            close = difflib.get_close_matches(port, list(variables), n=5)
+            hint = f" Close names: {close}." if close else ""
+            raise ValueError(f"'{path.name}' has no port '{port}'.{hint}")
+        variable = ModelVariable(element, md.fmi_version)
+        terminals = Terminals(fmu.tmp_directory)
+
+    attributes: dict[str, str] = {}
+    for attrs in variable.attrs_list:
+        for key, value in attrs.items():
+            attributes.setdefault(key, value)
+
+    card: dict[str, Any] = {
+        "fmu": path.name,
+        "fmi_version": md.fmi_version,
+        "name": port,
+        "type": variable.fmi_type,
+        "causality": variable.causality,
+        "variability": variable.variability,
+        "attributes": attributes,
+    }
+    if variable.dimensions:
+        card["dimensions"] = [{key: value} for key, value in variable.dimensions]
+
+    declared = _declared_type(md, variable)
+    if declared:
+        declared["inherited"] = {key: value for key, value in declared["attributes"].items()
+                                 if key not in attributes}
+        card["declared_type"] = declared
+
+    aliases = _aliases(md, variable, variables)
+    if aliases:
+        card["aliases"] = aliases[:MAX_ALIASES]
+        if len(aliases) > MAX_ALIASES:
+            card["aliases_total"] = len(aliases)
+
+    # `Terminals` lists the sub-terminals at the top level too: one pass covers them all.
+    memberships = [{"terminal": terminal.name, "kind": terminal.kind, "member": member}
+                   for terminal in terminals
+                   for member, name in terminal.members.items() if name == port]
+    if memberships:
+        card["terminals"] = memberships
+    return card
+
+
+def _declared_type(md: ModelDescription, variable: ModelVariable) -> dict[str, Any] | None:
+    """The type definition named by `declaredType`, with its enumeration items."""
+    name = variable.get("declaredType")
+    definitions = md.root.find("TypeDefinitions")
+    if not name or definitions is None:
+        return None
+    for definition in definitions:
+        if definition.get("name") != name:
+            continue
+        # FMI-2: <SimpleType name="..."><Real unit="..."/></SimpleType>; FMI-3: <Float64Type name="..." unit="..."/>.
+        typed = definition[0] if md.fmi_version == 2 and len(definition) else definition
+        attributes = {key: value for key, value in definition.attrib.items() if key != "name"}
+        if typed is not definition:
+            attributes.update(typed.attrib)
+        declared: dict[str, Any] = {"name": name, "attributes": attributes}
+        items = [dict(item.attrib) for item in typed.findall("Item")]
+        if items:
+            declared["items"] = items
+        return declared
+    return {"name": name, "attributes": {}, "error": "no such type definition"}
+
+
+def _aliases(md: ModelDescription, variable: ModelVariable,
+             variables: dict[str, Any]) -> list[dict[str, str]]:
+    """FMI-3: the `<Alias>` elements. FMI-2: the variables sharing the value reference and the type."""
+    if md.fmi_version == 3:
+        return [dict(alias.attrib) for alias in variable.element.findall("Alias")]
+    vr = variable.element.get("valueReference")
+    aliases = []
+    for name, element in variables.items():
+        if element is variable.element or element.get("valueReference") != vr:
+            continue
+        other = ModelVariable(element, md.fmi_version)
+        if other.fmi_type == variable.fmi_type:
+            aliases.append({"name": name, "causality": other.causality})
+    return aliases
+
+
 #: Most groups of messages returned by `check_fmu` per list: an industrial FMU can produce thousands of errors,
 #: which would fill the context window of the model.
 MAX_MESSAGE_GROUPS = 50
@@ -202,7 +366,7 @@ def dump_ports_csv(fmu_path: Path, csv_path: Path) -> dict[str, Any]:
     The file has one row per port, with columns ``name``, ``newName``,
     ``valueReference``, ``causality``, ``variability``, ``scalarType`` and
     ``startValue``, separated by semicolons. Editing the ``newName`` column
-    and feeding it back to :func:`rename_ports_from_csv` is the intended
+    and feeding it back to :func:`rename_ports` is the intended
     round-trip.
 
     Args:
@@ -220,8 +384,13 @@ def dump_ports_csv(fmu_path: Path, csv_path: Path) -> dict[str, Any]:
     return {"fmu": fmu_path.name, "csv": str(csv_path), "ports": max(len(rows) - 1, 0)}
 
 
-def rename_ports_from_csv(fmu_path: Path, csv_path: Path, output_path: Path) -> dict[str, Any]:
-    """Rename (or drop) the ports of an FMU according to a CSV mapping.
+#: Names of a renaming mapping absent from the FMU listed in the report of `rename_ports`; the total is always given.
+MAX_UNKNOWN_NAMES = 20
+
+
+def rename_ports(fmu_path: Path, output_path: Path, mapping: dict[str, str] | None = None,
+                 csv_path: Path | None = None) -> dict[str, Any]:
+    """Rename (or drop) the ports of an FMU, from a mapping or from a CSV file.
 
     The CSV is the one produced by :func:`dump_ports_csv`: column 0 is the
     current name, column 1 the new one. **An empty new name removes the
@@ -230,32 +399,52 @@ def rename_ports_from_csv(fmu_path: Path, csv_path: Path, output_path: Path) ->
 
     Args:
         fmu_path: FMU to read.
-        csv_path: CSV mapping file.
         output_path: Destination FMU. The source is never modified.
+        mapping: Current name -> new name.
+        csv_path: CSV mapping file. Exactly one of `mapping` and `csv_path` is given.
 
     Returns:
-        A mapping with ``fmu``, ``output``, ``renamed`` and ``removed``.
+        A mapping with ``fmu``, ``output``, ``renamed`` and ``removed`` (ports
+        actually renamed or removed), and when some names of the mapping are not
+        ports of the FMU: ``unknown`` (the first of them) and ``unknown_total``.
+
+    Raises:
+        ValueError: If neither or both of `mapping` and `csv_path` are given.
     """
-    operation = OperationRenameFromCSV(str(csv_path))
-    # `OperationRenameFromCSV` reads every row, header included: the CSV
-    # produced by `dump_ports_csv` starts with `name;newName`, which would
-    # otherwise be counted as a rename.
-    translations = {old: new for old, new in operation.translations.items()
-                    if (old, new) != ("name", "newName")}
-    renamed = sum(1 for old, new in translations.items() if new and new != old)
-    removed = sum(1 for new in translations.values() if not new)
+    if (mapping is None) == (csv_path is None):
+        raise ValueError("Give either `mapping` or `csv`, not both.")
+    if csv_path is not None:
+        operation: OperationRename = OperationRenameFromCSV(str(csv_path))
+        # `OperationRenameFromCSV` reads every row, header included: the CSV
+        # produced by `dump_ports_csv` starts with `name;newName`, which must not
+        # be taken for a port.
+        if operation.translations.get("name") == "newName":
+            del operation.translations["name"]
+    else:
+        operation = OperationRename(mapping)
 
     with FMU(str(fmu_path)) as fmu:
         fmu.apply_operation(operation)
         fmu.repack(str(output_path))
 
-    return {"fmu": fmu_path.name, "output": str(output_path),
-            "renamed": renamed, "removed": removed}
+    translations = operation.translations
+    report: dict[str, Any] = {
+        "fmu": fmu_path.name, "output": str(output_path),
+        "renamed": sum(1 for old in operation.found if translations[old] and translations[old] != old),
+        "removed": sum(1 for old in operation.found if not translations[old]),
+    }
+    unknown = [old for old in translations if old not in operation.found]
+    if unknown:
+        report["unknown"] = unknown[:MAX_UNKNOWN_NAMES]
+        report["unknown_total"] = len(unknown)
+    return report
 
 
 def apply_operation(fmu_path: Path, output_path: Path, operation: str,
                     argument: str | None = None,
-                    causality: list[str] | None = None) -> dict[str, Any]:
+                    causality: list[str] | None = None,
+                    types: list[str] | None = None,
+                    variabilities: list[str] | None = None) -> dict[str, Any]:
     """Apply one descriptor operation to an FMU and write the result.
 
     Args:
@@ -265,6 +454,8 @@ def apply_operation(fmu_path: Path, output_path: Path, operation: str,
         argument: Required by the parameterised operations (``trim_until``,
             ``remove_regexp``, ``keep_only_regexp``), rejected by the others.
         causality: Restrict the operation to these causalities.
+        types: Restrict the operation to these types (see :func:`check_port_filters`).
+        variabilities: Restrict the operation to these variabilities.
 
     Returns:
         A mapping with ``fmu``, ``output`` and ``operation`` (what was done,
@@ -285,11 +476,7 @@ def apply_operation(fmu_path: Path, output_path: Path, operation: str,
     if argument and not needs_argument:
         raise ValueError(f"Operation '{operation}' does not take an `argument`.")
 
-    if causality:
-        unknown = set(causality) - set(CAUSALITIES)
-        if unknown:
-            raise ValueError(f"Unknown causality {sorted(unknown)}. "
-                             f"Available: {list(CAUSALITIES)}.")
+    check_port_filters(causality, types, variabilities)
 
     # A malformed regular expression surfaces here, as a plain `re.error`:
     # turn it into something the caller can act upon.
@@ -299,11 +486,9 @@ def apply_operation(fmu_path: Path, output_path: Path, operation: str,
         raise ValueError(f"Cannot apply '{operation}': {exc}") from None
 
     with FMU(str(fmu_path)) as fmu:
-        fmu.apply_operation(instance, causality or None)
+        fmu.apply_operation(instance, causality or None, types=types or None,
+                            variabilities=variabilities or None)
         fmu.repack(str(output_path))
 
     return {"fmu": fmu_path.name, "output": str(output_path),
             "operation": repr(instance)}
-
-
-

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/assistant/headless.py

@@ -45,6 +45,9 @@ DEFAULT_OPTIONS: dict[str, Any] = {
 #: Default name of the container being described.
 DEFAULT_CONTAINER_NAME = "container.fmu"
 
+#: Marker of the files written by `HeadlessAssemblyBridge.state` (the assembly state of `fmutool-agent`).
+STATE_FORMAT = "fmutool-agent-state/1"
+
 
 class _FmuDescriptor(OperationAbstract):
     """Reads an FMU descriptor and collects what the assistant needs.
@@ -165,6 +168,49 @@ class HeadlessAssemblyBridge:
         self._start_values: dict[tuple[str, str], str] = {}
         self._options: dict[str, Any] = dict(DEFAULT_OPTIONS)
 
+    # -- state -------------------------------------------------------------
+
+    def state(self) -> dict[str, Any]:
+        """What the client asked for, as JSON values: `from_state` rebuilds the same bridge.
+
+        This is not the assembly description (`save_as_json`): it keeps the
+        names given to the FMUs and nothing derived from them, so that a tool
+        called in another process (`fmutool-agent`) finds the assembly as left.
+        """
+        return {
+            "format": STATE_FORMAT,
+            "name": self._name,
+            "fmus": {name: str(path) for name, path in self._paths.items()},
+            "links": [list(link) for link in self._links],
+            "exposed_inputs": [list(item) for item in self._exposed_inputs],
+            "exposed_outputs": [list(item) for item in self._exposed_outputs],
+            "start_values": [[fmu, port, value] for (fmu, port), value in self._start_values.items()],
+            "options": dict(self._options),
+        }
+
+    @classmethod
+    def from_state(cls, state: dict[str, Any]) -> "HeadlessAssemblyBridge":
+        """The bridge saved by `state`. The FMUs are read again from their files.
+
+        Raises:
+            ValueError: If `state` was not produced by `state`.
+            FileNotFoundError: If an FMU of the assembly no longer exists.
+        """
+        if not isinstance(state, dict) or state.get("format") != STATE_FORMAT:
+            raise ValueError(f"Not an assembly state (expected \"format\": \"{STATE_FORMAT}\").")
+        bridge = cls(state.get("name", DEFAULT_CONTAINER_NAME))
+        for name, path in state.get("fmus", {}).items():
+            description = describe_fmu(Path(path))
+            description["fmu"] = name
+            bridge._paths[name] = Path(path)
+            bridge._descriptions[name] = description
+        bridge._links = [tuple(link) for link in state.get("links", [])]
+        bridge._exposed_inputs = [tuple(item) for item in state.get("exposed_inputs", [])]
+        bridge._exposed_outputs = [tuple(item) for item in state.get("exposed_outputs", [])]
+        bridge._start_values = {(fmu, port): value for fmu, port, value in state.get("start_values", [])}
+        bridge._options.update(state.get("options", {}))
+        return bridge
+
     # -- helpers -----------------------------------------------------------
 
     def _description(self, fmu: str) -> dict[str, Any]:

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/assistant/knowledge.py

@@ -84,10 +84,14 @@ Beyond assembling, single-FMU tools are also available. They read or rewrite
 **one** `.fmu` file and never touch the assembly:
 - `summarize_fmu(path)` — identity, capabilities, platforms, port counts.
 - `check_fmu(path)` — FMI schema conformity and registered checkers.
-- `dump_ports_csv(fmu, path)` / `rename_ports_from_csv(fmu, csv, output)` —
-  bulk renaming. An **empty** new name **removes** the port.
+- `describe_port(fmu, port)` — everything declared about one port: min, max,
+  nominal, declared type, aliases, terminals.
+- `rename_ports(fmu, output, mapping=...)` — renaming from a mapping, or from
+  a CSV written by `dump_ports_csv(fmu, path)` (bulk renaming). An **empty**
+  new name **removes** the port.
 - `apply_operation(fmu, output, operation, ...)` — prefix stripping, trimming
-  and regexp filtering of port names.
+  and regexp filtering of port names, restricted with `causality`, `type` and
+  `variability` if needed.
 
 These rewrite the FMU interface, so they produce a **new** file and leave the
 source untouched. Warn the user that anything already connected to the old

{fmu_manipulation_toolbox-2.1.dev0 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/assistant/models.py

@@ -13,21 +13,13 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field, SerializerFunctionWrapHandler, model_serializer
 
+# Shared with the command line, which runs without Pydantic: defined in `tools`, re-exported here.
+from .tools import DEFAULT_PORT_LIMIT, MAX_DESCRIPTION_LENGTH, MAX_PORT_LIMIT, format_start_value  # noqa: F401
+
 #: Value kinds accepted for a start value, before conversion to the FMI
 #: textual representation.
 StartValue = bool | int | float | str
 
-#: Maximum number of ports returned by a single call, to keep the answer
-#: readable and the context small on industrial FMUs.
-DEFAULT_PORT_LIMIT = 50
-
-#: Largest page of ports a client may ask for: about 31k characters (~9k tokens) of compact ports.
-MAX_PORT_LIMIT = 200
-
-#: Descriptions of the ports longer than this are cut (with `…`): they help to match ports by meaning, but some
-#: generators write whole paragraphs, which would fill the context window of the model.
-MAX_DESCRIPTION_LENGTH = 80
-
 
 class ContainerOptions(BaseModel):
     """Container options to change; the others keep their value."""
@@ -55,18 +47,16 @@ class ContainerOptions(BaseModel):
     )
     auto_link: bool | None = Field(
         default=None,
-        description="Connect the ports with the same name and type. Enabled by "
-                    "default: explicit links are for the other ports.",
+        description="Connect the ports with the same name and type (default: on); "
+                    "links are for the others.",
     )
     auto_input: bool | None = Field(
         default=None,
-        description="Automatically expose unconnected inputs as container "
-                    "inputs. Enabled by default.",
+        description="Expose the unconnected inputs (default: on).",
     )
     auto_output: bool | None = Field(
         default=None,
-        description="Automatically expose unconnected outputs as container "
-                    "outputs. Enabled by default.",
+        description="Expose the unconnected outputs (default: on).",
     )
     auto_parameter: bool | None = Field(
         default=None,
@@ -83,10 +73,8 @@ class ContainerOptions(BaseModel):
     )
     reset_ports: bool | None = Field(
         default=None,
-        description="Add a `container.reset` input to each embedded FMU: when "
-                    "true, the container resets the FMU and initializes it again "
-                    "at the current time. Wire it with a link, or expose it as "
-                    "`container.<fmu>.reset`.",
+        description="Add a `container.reset` input to each FMU: true resets and "
+                    "initializes it again. Link it, or expose it as `container.<fmu>.reset`.",
     )
 
     def changes(self) -> dict[str, Any]:
@@ -117,23 +105,6 @@ def option_reference() -> list[dict[str, Any]]:
     return reference
 
 
-def format_start_value(value: StartValue) -> str:
-    """Render ``value`` the way ``modelDescription.xml`` expects it.
-
-    Booleans are the trap here: ``str(True)`` yields ``"True"``, which FMI
-    does not accept.
-
-    Examples:
-        >>> format_start_value(True)
-        'true'
-        >>> format_start_value(0.01)
-        '0.01'
-    """
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    return str(value)
-
-
 # ---------------------------------------------------------------------------
 # FMU description
 # ---------------------------------------------------------------------------
@@ -165,14 +136,6 @@ class Port(BaseModel):
         """
         return {key: value for key, value in handler(self).items() if value is not None}
 
-    @classmethod
-    def from_description(cls, port: dict[str, Any]) -> "Port":
-        """A port of a bridge description, its description cut to `MAX_DESCRIPTION_LENGTH` characters."""
-        description = port.get("description")
-        if description and len(description) > MAX_DESCRIPTION_LENGTH:
-            port = {**port, "description": description[:MAX_DESCRIPTION_LENGTH - 1].rstrip() + "…"}
-        return cls(**port)
-
 
 class FmuPorts(BaseModel):
     """A page of ports, plus what it took to get there.