fmu-manipulation-toolbox 2.0b3__tar.gz → 2.1.dev1__tar.gz

{fmu_manipulation_toolbox-2.0b3 → fmu_manipulation_toolbox-2.1.dev1}/CHANGELOG.md

@@ -3,7 +3,66 @@ This package was formerly known as `fmutool`.
 
 # Upstream
 
-Not released yet. Changes since 1.9.4.2, by theme: 🟢 **ADDED** new feature, 🔵 **CHANGED** change of behaviour or
+Not released yet. Changes since 2.0, with the same legend as 2.0.
+
+## FMU Container
+
+- 🟢 **ADDED** **architecture wires** in SSP files: a connection annotated
+  `fmu_manipulation_toolbox.architecture-wire` describes a dependency between two components (directed,
+  bidirectional or undirected, with a Markdown description) before the exchanged variables are known. It is not a
+  link: it takes no part in the container and is not written in the JSON description; the Container Builder shows it
+  as a hint. See [Architecture wires](docs/user-guide/fmucontainer/container.md#architecture-wires).
+- 🔵 **CHANGED** SSP import: each component is embedded as `<component name>.fmu` (it was named after its FMU file,
+  `<file>-<n>.fmu` for the components sharing a source), and the FMUs are extracted keeping their path inside the
+  archive: two FMUs with the same file name in different directories no longer overwrite each other. A component
+  `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`.
+
+## Graphical User Interfaces
+
+- 🟢 **ADDED** `fmucontainer-gui <file>` opens an FMU container (`.fmu`) or imports an assembly file (`.json`,
+  `.csv`, `.ssp`) given on the command line.
+- 🟢 **ADDED** Container Builder: the nodes imported from an SSP file are placed after the geometry of their
+  components, and the [architecture wires](docs/user-guide/fmucontainer/gui-usage.md#architecture-wires) of the file
+  are shown as dashed wires until their links are defined, with their direction and description in the wire details.
+- 🟠 **FIXED** status bar of the GUIs: a long log record is elided (the whole line in the tooltip) instead
+  of widening the window.
+
+# Version 2.0
+
+Changes since 1.9.4.2, by theme: 🟢 **ADDED** new feature, 🔵 **CHANGED** change of behaviour or
 API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in scripts, custom operations or checkers.
 
 ## Installation and platforms
@@ -177,6 +236,9 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
 - 🟠 **FIXED** the runtime reads the lines of `container.txt` of any length: a line longer than 4095 characters
   (the start values of a large array, a string start value of more than 4095 characters) was cut and shifted the
   reading of the rest of the file, so that the container failed to instantiate.
+- 🟠 **FIXED** Windows: an embedded FMU, or an FMU run by the remoting server, whose DLL depends on other DLLs
+  shipped next to it in `binaries/win64` (or `win32`) failed to load. The dependencies of the DLL are now searched
+  first in its own directory.
 - 🔵 **CHANGED** the runtime checks the format version of `container.txt` and refuses, with an explicit error, a
   container whose `container.txt` does not come from the same version of the toolbox. See
   [Troubleshooting](docs/help/troubleshooting.md#fmu-container-fails-to-instantiate-format-version-of-containertxt).
@@ -302,9 +364,14 @@ API, 🟠 **FIXED** bug fix; 🔴 **BREAKING** marks what may require changes in
   search, **Save Logs…** and **Clear**. In `fmucontainer-gui`, the messages that were lost outside the progress
   dialog are now visible there, among them the `[AI] …` change journal and the token of the AI Assistant. See the
   [Container Builder GUI guide](docs/user-guide/fmucontainer/gui-usage.md#log).
-- 🔵 **CHANGED** `fmucontainer-gui`: **Verbose Mode** sets the level of the whole log (`DEBUG`) and copies it on the
-  standard output; without it, nothing is written on the standard output (the tree view and the AI Assistant used to
-  write their messages there in any case).
+- 🔵 **CHANGED** `fmucontainer-gui`: **Verbose Mode** sets the level of the log of its window (`DEBUG`) and copies
+  its messages on the standard output; without it, nothing is written on the standard output (the tree view and the
+  AI Assistant used to write their messages there in any case).
+- 🟠 **FIXED** `fmutoolbox`: the windows opened from the launcher shared one log. Each window now has its own: an
+  operation of an FMU Tool window, a build or a request of the AI Assistant of a Container Builder are only shown in
+  that window (log area, status bar, log window), **Clear** only forgets the messages of its window, and opening a
+  window no longer turns off the **Verbose Mode** of an open Container Builder. The few messages that do not come
+  from a window are shown in all of them. See the [Launcher guide](docs/user-guide/launcher.md).
 - 🟢 **ADDED** `fmucontainer-gui`: the `reset_ports` checkbox of a container (root included) adds a
   `<fmu>.reset` port per FMU, or sub-container, to the `configuration` node; a wire to it resets the FMU. Selecting
   the node lists its reset ports, to expose them as container inputs. See

{fmu_manipulation_toolbox-2.0b3 → 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.0b3 → fmu_manipulation_toolbox-2.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 2.0b3
+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
@@ -41,7 +41,7 @@ Requires-Dist: PySide6>=6.8.0; extra == "test"
 Requires-Dist: pytest>=9.0.3; extra == "test"
 Requires-Dist: pytest-qt>=4.4.0; extra == "test"
 Requires-Dist: pytest-cov>=7.0.0; extra == "test"
-Requires-Dist: coverage-badge>=1.1.2; extra == "test"
+Requires-Dist: anybadge>=1.16.0; extra == "test"
 Requires-Dist: fmpy>=0.3.20; extra == "test"
 Requires-Dist: numpy; extra == "test"
 Provides-Extra: all
@@ -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.0b3 → 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.0b3 → fmu_manipulation_toolbox-2.1.dev1}/container/library.c

@@ -5,6 +5,8 @@
 #ifdef _WIN32
 #   include <windows.h>
 #   include <imagehlp.h>
+#   include <stdio.h>
+#   include <string.h>
 #else
 #   include <dlfcn.h>
 #   include <unistd.h> 
@@ -54,7 +56,8 @@ static void library_load_error(const logger_t *logger, const char* library_filen
 library_t library_load(const logger_t *logger, const char* library_filename) {
     library_t handle;
 #ifdef _WIN32
-    handle = LoadLibraryA(library_filename);
+    /* Dependencies are searched first in the directory of the DLL */
+    handle = LoadLibraryExA(library_filename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 #else
     handle = dlopen(library_filename, RTLD_LAZY);	/* RTLD_LOCAL can lead to failure */
 #endif
@@ -118,14 +121,28 @@ static LPVOID GetPtrFromRVA(DWORD rva, PIMAGE_NT_HEADERS pNTHeader, PBYTE imageB
 }
 
 
+static const char *libray_last_separator(const char *filename) {
+    const char *backslash = strrchr(filename, '\\');
+    const char *slash = strrchr(filename, '/');
+
+    if (!backslash)
+        return slash;
+    if (!slash)
+        return backslash;
+    return (backslash > slash) ? backslash : slash;
+}
+
+
 static libray_status_t* libray_try_load(const char* filename) {
     libray_status_t* status = malloc(sizeof(*status));
+    /* A bare DLL name is searched with the standard search order: the flag requires a path */
+    const DWORD flags = libray_last_separator(filename) ? LOAD_WITH_ALTERED_SEARCH_PATH : 0;
 
     HINSTANCE handle = LoadLibraryExA(filename, NULL, DONT_RESOLVE_DLL_REFERENCES);
     if (handle) {
         FreeLibrary(handle);
 
-        handle = LoadLibraryA(filename);
+        handle = LoadLibraryExA(filename, NULL, flags);
         if (handle) {
             FreeLibrary(handle);
             *status = LIBRARY_DLL_OK;
@@ -156,7 +173,29 @@ static void libray_log_status(const logger_t *logger, const char* filename, libr
 }
 
 
+/*
+ * The dependencies of a DLL are searched first in its directory, as library_load() does:
+ * return the path of the dependency in this directory if it exists, its bare name otherwise.
+ */
+static const char *libray_dependency_path(char *path, size_t size, const char *filename, const char *dll_filename) {
+    const char *separator = libray_last_separator(filename);
+
+    if (separator) {
+        const int dir_len = (int)(separator - filename);
+        const int len = snprintf(path, size, "%.*s\\%s", dir_len, filename, dll_filename);
+        if (len > 0 && (size_t)len < size) {
+            const DWORD attributes = GetFileAttributesA(path);
+            if (attributes != INVALID_FILE_ATTRIBUTES && !(attributes & FILE_ATTRIBUTE_DIRECTORY))
+                return path;
+        }
+    }
+
+    return dll_filename;
+}
+
+
 static void libray_analyse_deeply(const logger_t *logger, hash_t* dll_db, const char* filename) {
+    char dependency_path[MAX_PATH];
     PLOADED_IMAGE image = ImageLoad(filename, NULL);
     if (!image) {
         LOGGER_ERROR("Cannot ImageLoad(%s)", filename);
@@ -172,7 +211,8 @@ static void libray_analyse_deeply(const logger_t *logger, hash_t* dll_db, const
                 if ((importDesc->TimeDateStamp == 0) && (importDesc->Name == 0))
                     break;
                 const char* dll_filename = GetPtrFromRVA(importDesc->Name, image->FileHeader, image->MappedAddress);
-                libray_analyse(logger, dll_db, dll_filename);
+                libray_analyse(logger, dll_db,
+                               libray_dependency_path(dependency_path, sizeof(dependency_path), filename, dll_filename));
                 importDesc++;
             }
         }

{fmu_manipulation_toolbox-2.0b3 → fmu_manipulation_toolbox-2.1.dev1}/container/logger.h

@@ -54,8 +54,11 @@ extern void logger_embedded_fmu3(void *fmu,
 /*
  * Logging macros: they use the variable `logger` (const logger_t *) of the calling scope, e.g.
  *     const logger_t *logger = &container->logger;
+ * LOGGER_DEBUG tests the debug flag inline: when it is off, neither logger_message() is called nor its arguments
+ * evaluated, which matters in the per-value paths (getters, setters, cache of the importer values).
  */
-#define LOGGER_DEBUG(...)       logger_message(logger, LOGGER_LEVEL_DEBUG, __VA_ARGS__)
+#define LOGGER_DEBUG(...)       do { if (logger && logger->debug) \
+                                         logger_message(logger, LOGGER_LEVEL_DEBUG, __VA_ARGS__); } while (0)
 #define LOGGER_WARNING(...)     logger_message(logger, LOGGER_LEVEL_WARNING, __VA_ARGS__)
 #define LOGGER_ERROR(...)       logger_message(logger, LOGGER_LEVEL_ERROR, __VA_ARGS__)
 

{fmu_manipulation_toolbox-2.0b3 → 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.0b3'
-__version_tuple__ = version_tuple = (2, 0, 'b3')
+__version__ = version = '2.1.dev1'
+__version_tuple__ = version_tuple = (2, 1, 'dev1')
 
-__commit_id__ = commit_id = 'g4ac7fcf20'
+__commit_id__ = commit_id = 'g3d2800ab9'

{fmu_manipulation_toolbox-2.0b3 → fmu_manipulation_toolbox-2.1.dev1}/fmu_manipulation_toolbox/assembly.py

@@ -4,7 +4,7 @@ import logging
 import os
 from collections.abc import Iterable
 from typing import Any
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 import uuid
 import xml.etree.ElementTree as ET
 import zipfile
@@ -180,6 +180,33 @@ class Connection:
         return f"{self.from_port} -> {self.to_port}"
 
 
+class ArchitectureWire:
+    """Dependency between two embedded FMUs, declared before the exchanged variables are known.
+
+    An architecture wire comes from an SSP connection carrying the `fmu_manipulation_toolbox.architecture-wire`
+    annotation. It is a hint for the user who defines the links: it is not a link, it takes no part in the
+    container build and it is not written in the JSON description.
+
+    Attributes:
+        start_fmu (str): Name of the embedded FMU at the start of the wire.
+        end_fmu (str): Name of the embedded FMU at the end of the wire.
+        orientation (str): `"directed"` (from start to end), `"bidirectional"` or `"undirected"`.
+        description (str | None): Free text (Markdown) attached to the wire.
+    """
+
+    ORIENTATIONS = ("directed", "bidirectional", "undirected")
+
+    def __init__(self, start_fmu: str, end_fmu: str, orientation: str, description: str | None = None):
+        self.start_fmu = start_fmu
+        self.end_fmu = end_fmu
+        self.orientation = orientation
+        self.description = description
+
+    def __str__(self):
+        arrow = {"directed": "->", "bidirectional": "<->"}.get(self.orientation, "-")
+        return f"{self.start_fmu} {arrow} {self.end_fmu}"
+
+
 class AssemblyNode:
     """Represents a node in the assembly tree, defining a container and its topology.
 
@@ -214,6 +241,11 @@ class AssemblyNode:
         start_values (dict[Port, str]): Mapping from port to its start value.
         drop_ports (list[Port]): List of output ports to explicitly ignore.
         links (list[Connection]): List of connections between embedded FMUs.
+        architecture_wires (list[ArchitectureWire]): Dependencies between embedded FMUs read from an SSP file,
+            kept as hints for the GUI; they are neither links nor part of the JSON description.
+        fmu_geometry (dict[str, tuple[float, float, float, float]]): Position of embedded FMUs read from an SSP
+            file: `(x1, y1, x2, y2)` of the `ElementGeometry` of their component (SSP coordinates, y upwards). A hint
+            for the GUI, not part of the JSON description.
     """
 
     def __init__(self, name: str, step_size: float = None, mt=False, profiling=False, sequential=False,
@@ -248,6 +280,8 @@ class AssemblyNode:
         self.start_values: dict[Port, str] = {}
         self.drop_ports: list[Port] = []
         self.links: list[Connection] = []
+        self.architecture_wires: list[ArchitectureWire] = []
+        self.fmu_geometry: dict[str, tuple[float, float, float, float]] = {}
 
     def add_sub_node(self, sub_node):
         """Add a child `AssemblyNode` to create a hierarchical (nested) container.
@@ -340,6 +374,17 @@ class AssemblyNode:
         self.links.append(Connection(Port(from_fmu_filename, from_port_name),
                           Port(to_fmu_filename, to_port_name)))
 
+    def add_architecture_wire(self, start_fmu: str, end_fmu: str, orientation: str, description: str | None = None):
+        """Declare a dependency between two embedded FMUs, without naming variables (see `ArchitectureWire`).
+
+        Args:
+            start_fmu (str): Name of the embedded FMU at the start of the wire.
+            end_fmu (str): Name of the embedded FMU at the end of the wire.
+            orientation (str): `"directed"` (from start to end), `"bidirectional"` or `"undirected"`.
+            description (str | None): Free text (Markdown) attached to the wire.
+        """
+        self.architecture_wires.append(ArchitectureWire(start_fmu, end_fmu, orientation, description))
+
     def add_start_value(self, fmu_filename: str, port_name: str, value: str):
         """Set a start value for a port of an embedded FMU.
 
@@ -936,8 +981,8 @@ class Assembly:
 
             for file in zin.filelist:
                 if file.filename.endswith(".fmu"):
-                    # FMU are all stored in extract_folder without hierarchy
-                    file.filename = str(Path(file.filename).name)
+                    # FMUs keep their path relative to the archive root: two FMUs with the same file name in
+                    # different directories do not overwrite each other.
                     zin.extract(file, path=extract_folder)
                     logger.debug(f"Extracted: {file.filename} (into {extract_folder})")
 
@@ -1008,7 +1053,7 @@ class Assembly:
 
 
 class SSDParser:
-    """Parser for SSD (System Structure Description) files of SSP 1.0 archives.
+    """Parser for SSD (System Structure Description) files of SSP archives (SSP 1.0 and 2.0 share one namespace).
 
     Parses the XML structure of an `.ssd` file and builds the corresponding
     [AssemblyNode][fmu_manipulation_toolbox.assembly.AssemblyNode] tree, including
@@ -1017,16 +1062,25 @@ class SSDParser:
     Elements are recognized by their namespace (`SSD_NAMESPACE`), whatever the
     prefix used in the file (`ssd:`, another one, or a default namespace).
 
+    Each component is embedded as `<component name>.fmu`, in the directory of its `source` file. A component
+    without `source` (SSP 2.0 component without implementation) is ignored, with the connections attached to it.
+
+    A connection carrying an annotation of type `ARCHITECTURE_WIRE_TYPE` is an architecture wire (see
+    `ArchitectureWire`), not a link.
+
     Attributes:
         node_stack (list[AssemblyNode]): Stack of nodes used during XML parsing
             for tracking hierarchy.
         root (AssemblyNode | None): Root node after parsing is complete.
         fmu_filenames (dict[str, str]): Mapping from SSD component names to
-            the names of the embedded FMUs: the FMU filename, or an instance
-            name when several components share one source (see `instance_name`).
+            the names of the embedded FMUs.
+        ignored_components (set[str]): Names of the components ignored because they have no `source`.
     """
 
     SSD_NAMESPACE = "http://ssp-standard.org/SSP1/SystemStructureDescription"
+    SSC_NAMESPACE = "http://ssp-standard.org/SSP1/SystemStructureCommon"
+    ARCHITECTURE_WIRE_TYPE = "fmu_manipulation_toolbox.architecture-wire"
+    ARCHITECTURE_WIRE_NAMESPACE = "urn:fmu_manipulation_toolbox:architecture-wire:1"
 
     def __init__(self, zin: zipfile.ZipFile, extract_folder_name: str, **kwargs):
         self.zin = zin
@@ -1034,9 +1088,17 @@ class SSDParser:
 
         self.node_stack: list[AssemblyNode] = []
         self.root = None
-        self.fmu_filenames: dict[str, str] = {}  # Component name => FMU filename
+        self.fmu_filenames: dict[str, str] = {}  # Component name => FMU name
+        self.ignored_components: set[str] = set()
         self.node_attrs = kwargs
 
+        # Name of the embedded FMU of the component being read, for its ElementGeometry.
+        self._component_fmu: str | None = None
+        # Connection being read: its attributes, and its orientation once an architecture wire annotation is found.
+        self._connection_attrs: dict[str, str] | None = None
+        self._in_architecture_annotation = False
+        self._wire_orientation: str | None = None
+
     def parse(self, ssd_filename: str) -> AssemblyNode:
         """Parse an SSD file and return the root assembly node.
 
@@ -1062,6 +1124,8 @@ class SSDParser:
                                                 f"root element is <{element.tag}>, expected "
                                                 f"<SystemStructureDescription> in namespace '{self.SSD_NAMESPACE}'")
                         root_checked = True
+                    if self._connection_attrs is not None:
+                        self._connection_child(event, element)
                     if not element.tag.startswith(prefix):
                         continue  # other SSP namespaces (ssc:, ssv:...) and vendor annotations
                     tag = element.tag[len(prefix):]
@@ -1082,20 +1146,10 @@ class SSDParser:
     def start_element(self, tag_name, attrs):
         """Handle the start of an SSD element (`tag_name` without namespace, e.g. `"Connection"`)."""
         if tag_name == 'Connection':
-            if 'startElement' in attrs:
-                if 'endElement' in attrs:
-                    fmu_start = self.fmu_filenames[attrs['startElement']]
-                    fmu_end = self.fmu_filenames[attrs['endElement']]
-                    self.node_stack[-1].add_link(fmu_start, attrs['startConnector'],
-                                                 fmu_end, attrs['endConnector'])
-                else:
-                    fmu_start = self.fmu_filenames[attrs['startElement']]
-                    self.node_stack[-1].add_output(fmu_start, attrs['startConnector'],
-                                                   attrs['endConnector'])
-            else:
-                fmu_end = self.fmu_filenames[attrs['endElement']]
-                self.node_stack[-1].add_input(attrs['startConnector'],
-                                              fmu_end, attrs['endConnector'])
+            # Decided on the end tag: an annotation (child element) may make it an architecture wire.
+            self._connection_attrs = dict(attrs)
+            self._in_architecture_annotation = False
+            self._wire_orientation = None
 
         elif tag_name == 'System':
             logger.info(f"SSP System: {attrs['name']}")
@@ -1110,14 +1164,95 @@ class SSDParser:
             self.node_stack.append(node)
 
         elif tag_name == 'Component':
-            filename = f"{self.extract_folder_name}/{str(Path(attrs['source']).name)}"
+            if 'source' not in attrs:
+                logger.warning(f"Component '{attrs['name']}' has no source FMU. It is ignored, "
+                               f"with its connections.")
+                self.ignored_components.add(attrs['name'])
+                return
+            source = self._source_path(attrs['source'])
+            filename = f"{self.extract_folder_name}/{source}"
             node = self.node_stack[-1]
-            fmu_name = instance_name(filename, node.fmu_names_list)  # components sharing a source: instances
+            name = f"{self.extract_folder_name}/{source.parent / attrs['name']}.fmu"
+            fmu_name = instance_name(name, node.fmu_names_list)
             self.fmu_filenames[attrs['name']] = fmu_name
             node.add_fmu(fmu_name, filename)
+            self._component_fmu = fmu_name
             logger.debug(f"Component {attrs['name']} => {fmu_name}")
 
+        elif tag_name == 'ElementGeometry' and self._component_fmu is not None:
+            try:
+                self.node_stack[-1].fmu_geometry[self._component_fmu] = \
+                    tuple(float(attrs[corner]) for corner in ('x1', 'y1', 'x2', 'y2'))
+            except ValueError:
+                logger.debug(f"Geometry of '{self._component_fmu}' ignored: invalid coordinates.")
+
     def end_element(self, tag_name):
         """Handle the end of an SSD element (`tag_name` without namespace)."""
         if tag_name == 'System':
             self.node_stack.pop()
+        elif tag_name == 'Component':
+            self._component_fmu = None
+        elif tag_name == 'Connection':
+            attrs = self._connection_attrs
+            self._connection_attrs = None
+            if self._wire_orientation is None:
+                self._add_connection(attrs)
+            else:
+                self._add_architecture_wire(attrs, self._wire_orientation)
+
+    def _connection_child(self, event: str, element: ET.Element):
+        """Look for the architecture wire annotation among the descendants of the connection being read."""
+        if element.tag == f"{{{self.SSC_NAMESPACE}}}Annotation":
+            self._in_architecture_annotation = (event == "start" and
+                                                element.get("type") == self.ARCHITECTURE_WIRE_TYPE)
+        elif (self._in_architecture_annotation and event == "start" and
+              element.tag == f"{{{self.ARCHITECTURE_WIRE_NAMESPACE}}}Wire"):
+            orientation = element.get("orientation", "undirected")
+            if orientation not in ArchitectureWire.ORIENTATIONS:
+                logger.warning(f"Architecture wire with unknown orientation '{orientation}'. "
+                               f"It is read as 'undirected'.")
+                orientation = "undirected"
+            self._wire_orientation = orientation
+
+    def _add_connection(self, attrs: dict[str, str]):
+        """Turn a connection into a link, an exposed input or an exposed output."""
+        if attrs.get('startElement') in self.ignored_components or attrs.get('endElement') in self.ignored_components:
+            logger.debug(f"Connection {attrs.get('startElement')}/{attrs['startConnector']} -> "
+                         f"{attrs.get('endElement')}/{attrs['endConnector']} ignored: it involves an ignored "
+                         f"component.")
+            return
+        if 'startElement' in attrs:
+            if 'endElement' in attrs:
+                fmu_start = self.fmu_filenames[attrs['startElement']]
+                fmu_end = self.fmu_filenames[attrs['endElement']]
+                self.node_stack[-1].add_link(fmu_start, attrs['startConnector'],
+                                             fmu_end, attrs['endConnector'])
+            else:
+                fmu_start = self.fmu_filenames[attrs['startElement']]
+                self.node_stack[-1].add_output(fmu_start, attrs['startConnector'],
+                                               attrs['endConnector'])
+        else:
+            fmu_end = self.fmu_filenames[attrs['endElement']]
+            self.node_stack[-1].add_input(attrs['startConnector'],
+                                          fmu_end, attrs['endConnector'])
+
+    def _add_architecture_wire(self, attrs: dict[str, str], orientation: str):
+        """Record an architecture wire between two components of the current system."""
+        start, end = attrs.get('startElement'), attrs.get('endElement')
+        if start is None or end is None:
+            logger.warning(f"Architecture wire on connector '{attrs['startConnector']}' -> "
+                           f"'{attrs['endConnector']}' is ignored: it must join two components.")
+            return
+        if start in self.ignored_components or end in self.ignored_components:
+            logger.debug(f"Architecture wire {start} -> {end} ignored: it involves an ignored component.")
+            return
+        self.node_stack[-1].add_architecture_wire(self.fmu_filenames[start], self.fmu_filenames[end],
+                                                  orientation, attrs.get('description'))
+
+    @staticmethod
+    def _source_path(source: str) -> PurePosixPath:
+        """Path of a component source inside the archive, refused if it leaves the archive."""
+        path = PurePosixPath(source)
+        if path.is_absolute() or ".." in path.parts:
+            raise AssemblyError(f"Component source '{source}' must be a relative path inside the SSP archive.")
+        return path