mapcan 0.23.1__tar.gz → 0.23.2__tar.gz

{mapcan-0.23.1 → mapcan-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapcan
-Version: 0.23.1
+Version: 0.23.2
 Summary: A YAML map of CAN signals as the single source of truth: validation, Excel/PDF/Markdown/HTML, DBC, C/Python code
 Project-URL: Homepage, https://github.com/ordu1453/mapcan
 Project-URL: Documentation, https://github.com/ordu1453/mapcan/blob/main/docs/format.md

{mapcan-0.23.1 → mapcan-0.23.2}/docs/format.md

@@ -180,7 +180,7 @@ CANopen ID computation:
 | `terminator` | `string`: the byte that ends a shorter text and fills the rest of the field: a number (`0x00`) or one character (`"*"`, as in J1939 text parameters). Without it the text fills the field and unused bytes are 0x00 |
 | `start_bit` + `bit_length` | Canonical position |
 | `byte` [+ `bit`] + `byte_length` \| `bit_length` | Shorthand position (see below) |
-| `byte_order` | `little_endian` (default) or `big_endian` |
+| `byte_order` | `little_endian` (default) or `big_endian`. CANopen and J1939 carry little-endian data, so the editors offer the field only on other buses (or when it is set), and validation warns about a big-endian signal there (`byte-order-protocol`) |
 | `representation` | How the raw value is read as a number: `unsigned` (default), `twos_complement` (the usual signed integer), `ones_complement` or `sign_magnitude`. Generated C and Python code packs and unpacks the value in this representation; the last two have a symmetric range (−127…127 for 8 bits). DBC stores two's complement only, so the export warns about the other two. Formerly `signed` + `signed_code` |
 | `values` | Value table: `{0: NO_DATA, 1: {name: OK, description: "normal"}}` |
 | `value_format` | `dec` \| `hex`: how values are shown in documents |
@@ -699,6 +699,7 @@ turned off with `--disable CODE` or `lint.disable`.
 | `dlc-missing` | error | Frame has no `length` (only CANopen service frames may omit it) |
 | `canopen-dlc` | warning | Length of a CANopen service frame does not match CiA 301 |
 | `frame-type-protocol` | warning | `canopen` set on a frame of a non-CANopen bus |
+| `byte-order-protocol` | warning | A big-endian signal spanning bytes on a CANopen or J1939 bus: both carry little-endian data (CiA 301, SAE J1939-71) |
 | `direction-deprecated` | warning | `direction` is set: it follows from the CANopen function and `sender`; a frame from outside the map goes to the frames of its bus. `mapcan migrate` does both |
 | `direction-mismatch` | warning | Direction conflicts with the frame's CANopen function |
 
@@ -712,7 +713,7 @@ turned off with `--disable CODE` or `lint.disable`.
 | `j1939-field-protocol` | warning | pgn/priority/destination/address/spn on a non-J1939 bus |
 | `j1939-spn-duplicate` | warning | The same SPN on several signals of the bus |
 | `j1939-tp` | info | A PGN longer than 8 bytes is sent with the J1939-21 transport protocol |
-| `canopen-od` | warning | Dictionary object on a signal outside a device's PDO, outside 0x2000..0x9FFF, or big-endian |
+| `canopen-od` | warning | Dictionary object on a signal outside a device's PDO, or outside 0x2000..0x9FFF |
 | `od-duplicate` | warning | The same dictionary object on several signals of a device |
 
 ### Sender and receivers

{mapcan-0.23.1 → mapcan-0.23.2}/docs/web.md

@@ -49,6 +49,8 @@ offers to save them before switching.
 
 The start screen also lists the bundled examples: pick one, choose where to save a copy, and it
 opens. The mapcan version is shown in the top bar next to the title and on the start screen.
+**File → Report an issue** (and the link on the start screen) opens a new GitHub issue with the
+versions of mapcan, the server's system and the browser filled in; the map itself is not sent.
 
 ### Security
 
@@ -117,7 +119,7 @@ The profile records who made which changes:
 | **Receives** | On a device page: the bus frames the device receives (its own RX frames and other devices' frames that list it as a receiver), with their senders. Below it, **Transmits frames of other devices** lists the frames it sends on behalf of other devices (`sender`). Both are computed from the frames; click a row to jump to the frame. On a frame page, **Receivers** are toggled on and off; renaming a device updates them and `sender`. ✕ in a row of another device's frame removes the device from its receivers. On an RX frame, **Frame of another device** picks a frame that is already described at its sender: the device is added to that frame's receivers and its own copy is removed (Ctrl+Z undoes it). The `rx-duplicate` message on such a frame has a button that does the same. |
 | **Values / Flags** | Enum and bit field tables: value (decimal or `0x…`), name, description. **+ Flag** adds a row without leaving the signal page. |
 | **Validation** (bottom) | The same rules as `mapcan validate`. Click a message to jump to the node (or, on the YAML tab, to the line). While the YAML tab holds text that is not applied yet (for example, with a syntax error), the panel lists the messages for that text and marks them **YAML text not applied**. |
-| **YAML** | Edit the whole file as text. The text is validated as you type: lines with problems are marked in the gutter (hover a line number to read the message), and the first syntax error is shown in the YAML toolbar; click it to jump to its line. Once the text parses, it is applied automatically after a short pause, so the tree and the editor follow your typing; a whole run of typing is one undo step. Switching to the editor applies what is left (it stays on the YAML tab if there is a syntax error). Renaming a device in the text also updates `sender` and `receivers` of the bus frames, as renaming in the form does. Tab and Shift+Tab indent and outdent the selected lines, Enter keeps the indentation (one level deeper after `key:`), Backspace after spaces goes back to the previous tab stop (2 spaces); press Esc first to move focus with Tab. Ctrl+Enter applies the edit at once. While you type a key, a list offers the fields allowed at that place that are not set yet (required ones first), with the field description from the format schema; after `key:` it offers the values of enumerations (`encoding`, `protocol`, `byte_order`, `true`/`false`…). The same works inside a one-line `{...}` mapping (after `{` and after `, `), and a new `- ` list item also offers `{ }` to write the item on one line. Arrows choose, Enter or Tab inserts (a list or object field also opens its first level), Esc closes, Ctrl+Space shows the list on an empty line. |
+| **YAML** | Edit the whole file as text. The text is validated as you type: lines with problems are marked in the gutter (hover a line number to read the message), and the first syntax error is shown in the YAML toolbar; click it to jump to its line. Once the text parses, it is applied automatically after a short pause, so the tree and the editor follow your typing; a whole run of typing is one undo step. Switching to the editor applies what is left (it stays on the YAML tab if there is a syntax error). Renaming a device in the text also updates `sender` and `receivers` of the bus frames, as renaming in the form does. Tab and Shift+Tab indent and outdent the selected lines, Enter keeps the indentation (one level deeper after `key:`), Backspace after spaces goes back to the previous tab stop (2 spaces); press Esc first to move focus with Tab. Ctrl+Enter applies the edit at once. While you type a key, a list offers the fields allowed at that place that are not set yet (required ones first), with the field description from the format schema; after `key:` it offers the values of enumerations (`encoding`, `protocol`, `byte_order`, `true`/`false`…). The same works inside a one-line `{...}` mapping (after `{` and after `, `), and a new `- ` list item also offers `{ }` to write the item on one line. Arrows choose, Enter or Tab inserts (a list or object field also opens its first level), Esc closes, Ctrl+Space shows the list on an empty line. A map with included files (`include`) shows one file at a time: a node selected in the tree opens the file it is written in (a device of `devices/node.yaml`, a frame where its sender describes it), with the node's lines highlighted, and the list in the YAML toolbar switches between the map and its files (• marks a file with unsaved edits). The text of an included file is edited and applied the same way and goes to that file; **Save** writes it. On the editor tab, **Open the YAML of …** in the note above a node of an included file opens it. |
 | **Export** | Documents (PDF, HTML, Markdown, Excel) and development formats (DBC, C, Python), generated from the current state, including unsaved changes. Clicking a document opens a preview; for PDF, the template is chosen there: `mapcan` or ESKD (see [templates.md](templates.md)). ↓ on the right downloads the file directly. The document language (English or Russian; the map's language by default) is chosen in the menu and in the preview. The ESKD template is always in Russian. |
 | **Layout and document details** | In the document properties: logo (file upload), designation, letter, organization, city, title block signatures, approval blocks. |
 | **Git → Compare versions…** | Diffs the current map against a git revision (HEAD, a tag or a commit) or an uploaded file: changes to frames, signals, values and flags. **Add to history** writes the changelog into `document.history` and bumps the version. |
@@ -179,8 +181,8 @@ available at `http://127.0.0.1:8765/api/docs`.
 | GET | `/api/state` | Text, data, computed layout and diagnostics |
 | POST | `/api/ops` | `{"ops": [...]}`: apply operations atomically |
 | POST | `/api/device_file` | `{"bus": ["buses", 0], "device": {...}, "file": "devices/node.yaml"}`: a new device in a new file, added to `include` |
-| POST | `/api/text` | Replace the YAML text |
-| POST | `/api/check` | `{"text": ...}`: validate text without applying it; returns `{diagnostics}` |
+| POST | `/api/text` | `{"text": ..., "file": null}`: replace the YAML text of the map, or of an included file (`file`, relative to the map) |
+| POST | `/api/check` | `{"text": ..., "file": null}`: validate text without applying it; returns `{diagnostics}` (a message about an included file has `part`: its file, line and column) |
 | POST | `/api/undo`, `/api/redo` | Edit history |
 | POST | `/api/save` | `{"force": false}`; `409` means the file changed on disk |
 | POST | `/api/reload` | Reload the file from disk |

{mapcan-0.23.1 → mapcan-0.23.2}/examples/minimal.yaml

@@ -66,12 +66,11 @@ buses:
                 offset: -20
                 unit: °C
 
-              - name: speed           # big-endian: byte 5 is the high byte, byte 6 the low byte
+              - name: speed           # two bytes, little-endian (CANopen): byte 5 is the low byte
                 description: Speed
                 encoding: scaled
                 byte: 5
                 byte_length: 2
-                byte_order: big_endian
                 unit: rpm
 
               - name: counter         # arbitrary position: bits 56..59

{mapcan-0.23.1 → mapcan-0.23.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapcan"
-version = "0.23.1"
+version = "0.23.2"
 description = "A YAML map of CAN signals as the single source of truth: validation, Excel/PDF/Markdown/HTML, DBC, C/Python code"
 # readme: built from README.md with absolute links for PyPI (see fancy-pypi-readme below)
 dynamic = ["readme"]

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/__init__.py

@@ -1,6 +1,6 @@
 """mapcan: a YAML signal map as the single source of truth."""
 
-__version__ = "0.23.1"
+__version__ = "0.23.2"
 
 from .loader import load, loads  # noqa: E402
 from .model import MapCan  # noqa: E402

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/launcher.py

@@ -252,7 +252,7 @@ def run(path: Path | None = None, *, window: bool = True, readonly: bool = False
 
     app = create_app(session, cwd=cwd.resolve(), readonly=readonly, check_updates=check_updates,
                      instance_token=token if single_instance else None, on_activate=on_activate,
-                     allowed_hosts=LOCAL_HOSTS)
+                     allowed_hosts=LOCAL_HOSTS, mode="app")
     server = ServerThread(app, host, port)
     try:
         server.start()

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/locale/ru.py

@@ -234,6 +234,8 @@ RU: dict[str, str] = {
         "direction кадра {name!r} противоречит его функции CANopen или отправителю: удалите его и укажите в sender "
         "устройство, которое передаёт кадр",
     "CANopen frame type on a non-CANopen bus": "Тип кадра CANopen на шине не CANopen",
+    "Big-endian signal on a CANopen or J1939 bus (they carry little-endian data)":
+        "Сигнал big-endian на шине CANopen или J1939 (они передают данные little-endian)",
     "sdo description on a frame that is not sdo_tx/sdo_rx": "Описание sdo у кадра не типа sdo_tx/sdo_rx",
     "Duplicate SDO exchange (command, index, subindex)": "Повтор SDO-обмена (команда, индекс, субиндекс)",
     "Name does not match the style rule (lint)": "Имя не соответствует правилу стиля (lint)",
@@ -480,7 +482,7 @@ RU: dict[str, str] = {
     "{name!r}: subindex without index": "{name!r}: subindex без index",
     "{name!r}: index {index:#06x} is outside the manufacturer and profile areas (0x2000..0x9FFF)":
         "{name!r}: индекс {index:#06x} вне областей производителя и профилей (0x2000..0x9FFF)",
-    "{name!r}: CANopen PDOs carry little-endian data": "{name!r}: PDO CANopen передаёт данные little-endian",
+    "{name!r}: {protocol} carries little-endian data": "{name!r}: {protocol} передаёт данные little-endian",
     "object {index:04X}:{sub:02X} is already mapped by {other}": "объект {index:04X}:{sub:02X} уже у сигнала {other}",
     "CANopen: index of the dictionary object mapped into the PDO.":
         "CANopen: индекс объекта словаря, отображённого в PDO.",

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/lsp/analysis.py

@@ -446,7 +446,8 @@ def device_label(d: dict, lang: str) -> str:
 
 
 def map_tree(a: Analysis) -> list[dict]:
-    """Nodes: kind, label, ident, description, dir (frames), from (received frames), range, selection, children.
+    """Nodes: kind, label, ident, description, dir (frames), from (received frames), to (frames the device sends,
+    described at their receiver), range, selection, children.
 
     Labels are as in the web editor's tree: titles in the document language, the identifier (``ident``)
     only if there is no title. Built from the raw YAML; computed IDs and bits come from the model if the map parses.
@@ -484,7 +485,7 @@ def map_tree(a: Analysis) -> list[dict]:
     def model(path: Path_):
         return _find(a.map, path) if a.map is not None else None
 
-    def frame_node(f: dict, path: Path_) -> dict | None:
+    def frame_node(f: dict, path: Path_, devices: list) -> dict | None:
         loc = rng(path)
         if loc is None:
             return None
@@ -494,7 +495,12 @@ def map_tree(a: Analysis) -> list[dict]:
             sub = f"PGN {_hexw(f['pgn'], 4)}"
         elif isinstance(rf, M.Frame) and rf.can_id is not None:
             sub = _hex(rf.can_id, rf.extended)
-        node = {"kind": "frame", "label": display_name(f, lang), "ident": name_of(f), "description": sub,
+        label = display_name(f, lang)
+        # A frame described at its receiver (sender: another device): the label names the sender, as a link does
+        if isinstance(rf, M.Frame) and rf.device is not None and rf.sender_name not in (None, rf.device.name):
+            sender = next((x for x in devices if x.get("name") == rf.sender_name), None)
+            label = f"{device_label(sender, lang) if sender else rf.sender_name} · {label}"
+        node = {"kind": "frame", "label": label, "ident": name_of(f), "description": sub,
                 "dir": rf.direction if isinstance(rf, M.Frame) and rf.device is not None else None,
                 "children": [], **loc}
         for si, s in enumerate(_items(f.get("signals"))):
@@ -533,10 +539,10 @@ def map_tree(a: Analysis) -> list[dict]:
         bnode = {"kind": "bus", "label": display_name(bus, lang), "ident": name_of(bus),
                  "description": bus_load_text(mbus) if is_bus else "",
                  "load_note": bus_load_note(mbus) if is_bus else "", "children": [], **bl}
+        devices = _items(bus.get("devices"))
         for fi, f in enumerate(_items(bus.get("frames"))):
-            if (fn := frame_node(f, bp + ("frames", fi))) is not None:
+            if (fn := frame_node(f, bp + ("frames", fi), devices)) is not None:
                 bnode["children"].append(fn)
-        devices = _items(bus.get("devices"))
         for di, d in enumerate(devices):
             dp = bp + ("devices", di)
             if (dl := rng(dp)) is None:
@@ -546,7 +552,7 @@ def map_tree(a: Analysis) -> list[dict]:
             dnode = {"kind": "device", "label": display_name(d, lang), "ident": name_of(d), "description": sub,
                      "children": [], **dl}
             for fi, f in enumerate(_items(d.get("frames"))):
-                if (fn := frame_node(f, dp + ("frames", fi))) is not None:
+                if (fn := frame_node(f, dp + ("frames", fi), devices)) is not None:
                     dnode["children"].append(fn)
             # Frames of other devices that the device receives: links after its own; the frame's title may
             # not tell whose it is, so the link's label names the sender
@@ -563,6 +569,20 @@ def map_tree(a: Analysis) -> list[dict]:
                     "ident": rf.name, "dir": "rx", "from": sender_label or rf.sender_name or "",
                     "description": _hex(rf.can_id, rf.extended) if rf.can_id is not None else "",
                     "children": [], **loc})
+            # Frames the device sends that are described at their receiver (sender: this device): links too, the
+            # label names the device they are described at
+            for rf in mbus.all_frames() if isinstance(mbus, M.Bus) else []:
+                if (rf.device is None or rf.device.name == d.get("name") or rf.sender_name != d.get("name")
+                        or (loc := rng(rf._path)) is None):
+                    continue
+                owner = next((x for x in devices if x.get("name") == rf.device.name), None)
+                owner_label = device_label(owner, lang) if owner else rf.device.name
+                frame = raw_at_path(raw, rf._path)
+                title = display_name(frame if isinstance(frame, dict) else {"name": rf.name}, lang)
+                dnode["children"].append({
+                    "kind": "frame", "label": f"{owner_label} · {title}", "ident": rf.name, "dir": "tx",
+                    "to": owner_label, "description": _hex(rf.can_id, rf.extended) if rf.can_id is not None else "",
+                    "children": [], **loc})
             bnode["children"].append(dnode)
         out.append(bnode)
     return out

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/lsp/edits.py

@@ -1245,6 +1245,8 @@ def set_field(a: Analysis, path: Path_, value) -> list[Edit]:
         return [minimal_edit(a.text, apply_ops(a, [op]))]
     if key == "canopen" and node_kind(path[:-1]) == "frame":
         return _set_frame_type(a, path, value)
+    if key == "sender" and node_kind(path[:-1]) == "frame":
+        return _set_sender(a, path, value)
     if not isinstance(raw_at(a, path[:-1]), dict):
         # A field of a nested mapping that does not exist yet (value.name of an SDO): the mapping is added with it
         parent = path[:-1]
@@ -1307,6 +1309,18 @@ def _set_frame_type(a: Analysis, path: Path_, value) -> list[Edit]:
     return edits
 
 
+def _set_sender(a: Analysis, path: Path_, value) -> list[Edit]:
+    """The sender of a frame; a device named as the sender does not receive the frame, so it leaves the receivers."""
+    receivers = raw_at(a, path[:-1] + ("receivers",))
+    if not value or not isinstance(receivers, list) or value not in receivers:
+        return _set_plain(a, path, value)
+    rest = [r for r in receivers if r != value]
+    ops = [{"op": "set", "path": list(path), "value": value},
+           {"op": "set", "path": list(path[:-1] + ("receivers",)), "value": rest} if rest
+           else {"op": "remove", "path": list(path[:-1] + ("receivers",))}]
+    return [minimal_edit(a.text, apply_ops(a, ops))]
+
+
 def _set_plain(a: Analysis, path: Path_, value) -> list[Edit]:
     """A scalar field without special rules: a new value, or ``None`` or "" to remove the key."""
     current = raw_at(a, path)

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/validate.py

@@ -107,6 +107,8 @@ RULES = {
     "direction-mismatch": ("warning", N_("Direction conflicts with the CANopen frame type")),
     "direction-deprecated": ("warning", N_("direction is set: it follows from the CANopen function and the sender")),
     "frame-type-protocol": ("warning", N_("CANopen frame type on a non-CANopen bus")),
+    "byte-order-protocol": ("warning", N_("Big-endian signal on a CANopen or J1939 bus (they carry little-endian "
+                                          "data)")),
     "sdo-frame-type": ("warning", N_("sdo description on a frame that is not sdo_tx/sdo_rx")),
     "sdo-duplicate": ("error", N_("Duplicate SDO exchange (command, index, subindex)")),
     "name-style": ("warning", N_("Name does not match the style rule (lint)")),
@@ -355,6 +357,7 @@ def _check_bus(ctx: _Ctx, bus) -> None:
             ctx.emit("can-id-range", _("CAN ID {can_id:#x} > 0x7FF", can_id=frame.can_id), p + ("id",))
     _check_spn(ctx, bus)
     _check_od(ctx, bus)
+    _check_byte_order(ctx, bus)
     _check_bus_load(ctx, bus)
 
 
@@ -374,9 +377,6 @@ def _check_od(ctx: _Ctx, bus) -> None:
             elif not 0x2000 <= s.index <= 0x9FFF:
                 ctx.emit("canopen-od", _("{name!r}: index {index:#06x} is outside the manufacturer and profile areas "
                                          "(0x2000..0x9FFF)", name=s.name, index=s.index), p)
-            elif s.byte_order == "big_endian":
-                ctx.emit("canopen-od", _("{name!r}: CANopen PDOs carry little-endian data", name=s.name),
-                         s._path + ("byte_order",))
     for dev in bus.devices:
         seen: dict[tuple[int, int], str] = {}
         for frame in dev.frames:
@@ -391,6 +391,24 @@ def _check_od(ctx: _Ctx, bus) -> None:
                     seen[key] = f"{frame.name}.{s.name}"
 
 
+def _check_byte_order(ctx: _Ctx, bus) -> None:
+    """CANopen (CiA 301) and J1939 (SAE J1939-71) carry little-endian data: a big-endian number spanning bytes is
+    a mistake there (within one byte the order changes nothing)."""
+    if bus.protocol not in ("canopen", "j1939"):
+        return
+    for frame in bus.all_frames():
+        for s in frame.signals:
+            if s.byte_order != "big_endian" or s.encoding in ("bytes", "string"):
+                continue
+            if len({b // 8 for b in B.occupied_bits(s.start_bit, s.bit_length, True)}) > 1:
+                ctx.emit("byte-order-protocol", _("{name!r}: {protocol} carries little-endian data",
+                                                  name=s.name, protocol=_PROTOCOL_NAMES[bus.protocol]),
+                         s._path + ("byte_order",))
+
+
+_PROTOCOL_NAMES = {"canopen": "CANopen", "j1939": "J1939"}
+
+
 def _check_spn(ctx: _Ctx, bus) -> None:
     seen: dict[int, str] = {}
     for frame in bus.all_frames():

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/web/app.py

@@ -9,6 +9,7 @@ import hmac
 import html
 import io
 import os
+import platform
 import re
 import shutil
 import string
@@ -66,6 +67,7 @@ class DeviceFileBody(BaseModel):
 class TextBody(BaseModel):
     text: str
     live: bool = False                 # applied while typing (see EditorSession.set_text)
+    file: str | None = None            # the text of an included file (relative to the map); None: of the map
 
 
 class SaveBody(BaseModel):
@@ -253,10 +255,11 @@ class TokenAuth:
 class Workspace:
     """The open map (there may be none), the workspace folder, the user settings."""
 
-    def __init__(self, session: EditorSession | None, cwd: Path, readonly: bool):
+    def __init__(self, session: EditorSession | None, cwd: Path, readonly: bool, mode: str = "serve"):
         self.session = session
         self.cwd = cwd
         self.readonly = readonly
+        self.mode = mode
         self.generation = 1 if session else 0
         self.config = UserConfig.load()
         if session:
@@ -305,6 +308,9 @@ class Workspace:
             "open": s is not None,
             "file": str(s.path) if s else None,
             "session_id": self.generation,
+            # For a bug report: how mapcan runs (the app window or mapcan serve) and on what
+            "mode": self.mode,
+            "system": f"{platform.system()} {platform.release()}, Python {platform.python_version()}",
         }
 
 
@@ -526,7 +532,8 @@ def create_app(session: EditorSession | None = None, poll_interval: float = 1.0,
                cwd: Path | None = None, readonly: bool | None = None, *,
                check_updates: bool = False, instance_token: str | None = None,
                on_activate: Callable[[], None] | None = None,
-               allowed_hosts: Collection[str] | None = None, auth_token: str | None = None) -> FastAPI:
+               allowed_hosts: Collection[str] | None = None, auth_token: str | None = None,
+               mode: str = "serve") -> FastAPI:
     """The editor application.
 
     ``allowed_hosts`` are the names allowed in the ``Host`` header (for a server on localhost),
@@ -534,13 +541,14 @@ def create_app(session: EditorSession | None = None, poll_interval: float = 1.0,
     ``auth_token``: every request needs this token (see :class:`TokenAuth`), for a server on the network;
     ``check_updates``: answer /api/update with information from GitHub Releases;
     ``instance_token`` allows /api/instance/activate (mapcan run again
-    passes the file to the running instance), ``on_activate`` brings the window to the front.
+    passes the file to the running instance), ``on_activate`` brings the window to the front;
+    ``mode``: "app" (the app window) or "serve" (for a bug report).
     """
     hub = Hub()
     lock = asyncio.Lock()
     root = cwd or (session.path.parent if session else Path.cwd())
     wsp = Workspace(session, root.resolve(),
-                    readonly if readonly is not None else bool(session and session.readonly))
+                    readonly if readonly is not None else bool(session and session.readonly), mode)
 
     @contextlib.asynccontextmanager
     async def lifespan(app: FastAPI):
@@ -775,13 +783,13 @@ def create_app(session: EditorSession | None = None, poll_interval: float = 1.0,
     @app.post("/api/text")
     async def post_text(body: TextBody) -> dict:
         async with lock:
-            await run_in_threadpool(wsp.require().set_text, body.text, body.live)
+            await run_in_threadpool(wsp.require().set_text, body.text, body.live, body.file)
             return await changed()
 
     @app.post("/api/check")
     async def post_check(body: TextBody) -> dict:
         s = wsp.require()
-        return {"diagnostics": await run_in_threadpool(s.check_text, body.text)}
+        return {"diagnostics": await run_in_threadpool(s.check_text, body.text, body.file)}
 
     @app.post("/api/undo")
     async def post_undo() -> dict:

{mapcan-0.23.1 → mapcan-0.23.2}/src/mapcan/web/session.py

@@ -107,7 +107,8 @@ class EditorSession:
         self.version = 0
         self.undo_stack: list[Snapshot] = []
         self.redo_stack: list[Snapshot] = []
-        self._live_base: str | None = None     # text before a series of edits in the YAML tab while typing
+        # The file (None: the map) and its text before a series of edits in the YAML tab while typing
+        self._live_base: tuple[str | None, str] | None = None
         self._result: LoadResult | None = None
         self._report = None
         self._last_check: tuple | None = None      # (text and included files, result, report) of check_text
@@ -131,11 +132,22 @@ class EditorSession:
                 return None
         return part.text
 
-    def _load(self, text: str) -> LoadResult:
-        return loads(text, str(self.path.name), self.path.parent, read=self._read_part)
+    def _load(self, text: str, override: tuple[str, str] | None = None) -> LoadResult:
+        """Load the map; ``override``: an included file (its key in parts) read with another text."""
+        def read(path: str) -> str | None:
+            return override[1] if override is not None and path == override[0] else self._read_part(path)
+        return loads(text, str(self.path.name), self.path.parent, read=read)
 
-    def _parts_key(self) -> tuple:
-        return tuple((p, part.text) for p, part in sorted(self.parts.items()))
+    def _parts_key(self, override: tuple[str, str] | None = None) -> tuple:
+        return tuple((p, override[1] if override is not None and p == override[0] else part.text)
+                     for p, part in sorted(self.parts.items()))
+
+    def part_key(self, file: str) -> str:
+        """An included file by its path relative to the map (as the state names it): its key in parts."""
+        for k, part in self.parts.items():
+            if part.text is not None and self._rel(part.path) == file:
+                return k
+        raise OpError(_("the included file {file} cannot be read", file=file))
 
     def _checked(self, text: str) -> tuple[LoadResult, Report]:
         """The load and validation of a text: those of the live validation of the same text (and the same
@@ -227,14 +239,29 @@ class EditorSession:
         self._result, self._report = self._checked(text)
         self.version += 1
 
-    def check_text(self, text: str) -> list[dict]:
-        """Validate a text without applying it (live validation in the YAML tab)."""
+    def check_text(self, text: str, file: str | None = None) -> list[dict]:
+        """Validate a text without applying it (live validation in the YAML tab). ``file``: the text is that of
+        an included file (relative to the map), with the map's current text."""
         text = text.replace("\r\n", "\n")
-        key = (text, self._parts_key())
-        result = self._load(text)
+        with self.lock:
+            override = (self.part_key(file), text) if file is not None else None
+            main = self.text if override is not None else text
+            key = (main, self._parts_key(override))
+            result = self._load(main, override)
         report = check(result)
         self._last_check = (key, result, report)
-        return [asdict(result.source.in_main_file(d)) for d in report.sorted()]
+        return self._diag_dicts(result, report)
+
+    def _diag_dicts(self, result: LoadResult, report: Report) -> list[dict]:
+        """Messages for the editor, on the include line in the map; one about an included file also has its place
+        in that file (``part``: the file relative to the map, line, column) for the YAML tab of that file."""
+        out = []
+        for d in report.sorted():
+            item = asdict(result.source.in_main_file(d))
+            if d.file is not None and d.file != result.source.file:
+                item["part"] = {"file": self._rel(d.file), "line": d.line, "column": d.column}
+            out.append(item)
+        return out
 
     def recheck(self) -> None:
         """Rebuild the validation messages (after the interface language changed)."""
@@ -378,8 +405,8 @@ class EditorSession:
             return text
         return merge_text(text, canon_old, dump(y, doc))
 
-    def set_text(self, text: str, live: bool = False) -> bool:
-        """Take the text of the YAML tab.
+    def set_text(self, text: str, live: bool = False, file: str | None = None) -> bool:
+        """Take the text of the YAML tab: of the map, or of the included file ``file`` (relative to the map).
 
         `live`: an intermediate application while typing; such edits in a row merge into one undo
         step until a normal application or another edit comes. Device renames are counted
@@ -387,21 +414,28 @@ class EditorSession:
         """
         with self.lock:
             self._check_writable()
-            base = self._live_base
+            key = self.part_key(file) if file is not None else None
+            current = self.text if key is None else self.parts[key].text
+            live_base = self._live_base
             self._live_base = None
-            text = self._carry_renames(self.text if base is None else base, text.replace("\r\n", "\n"))
+            # A series goes on only in the same file
+            base = live_base[1] if live_base is not None and live_base[0] == key else None
+            text = self._carry_renames(current if base is None else base, text.replace("\r\n", "\n"))
             if base is None:
-                changed = self._commit(text)
+                changed = self._commit(text) if key is None else self._commit(self.text, {key: text})
                 if live and changed:
-                    self._live_base = self.undo_stack[-1][0]
+                    self._live_base = (key, current)
                 return changed
             if text == base:                     # the series brought the text back: no undo step needed
                 self.undo_stack.pop()
             elif live:
-                self._live_base = base
-            if text == self.text:
+                self._live_base = (key, base)
+            if text == current:
                 return False
             self.redo_stack.clear()
+            if key is not None:
+                self.parts[key].text = text
+                text = self.text
             self._set_text(text)
             return True
 
@@ -432,10 +466,17 @@ class EditorSession:
         and the nodes they added, with the file's path relative to the map."""
         merged = self._result.merged if self._result else None
         if not isinstance(merged, dict) or not isinstance(merged.get("buses"), list):
-            return {"included_buses": None, "included": []}
-        roots = self._result.source.included_roots()
+            return {"included_buses": None, "included": [], "parts": {}}
+        src = self._result.source
+        roots = src.included_roots()
+        files = dict.fromkeys(str(Path(f).resolve()) for _i, f in src.includes)
         return {"included_buses": merged["buses"],
-                "included": [{"path": list(p), "file": self._rel(f)} for p, f in sorted(roots, key=lambda r: r[0])]}
+                # local: the node's path in its file (the second device of a bus may be the first of the file)
+                "included": [{"path": list(p), "file": self._rel(f), "local": list(src.origin(p)[1])}
+                             for p, f in sorted(roots, key=lambda r: r[0])],
+                # Texts of the included files (relative to the map), for the YAML tab
+                "parts": {self._rel(self.parts[k].path): self.parts[k].text for k in files
+                          if k in self.parts and self.parts[k].text is not None}}
 
     def _rel(self, f: str | Path) -> str:
         try:
@@ -467,7 +508,7 @@ class EditorSession:
                 "data": upgrade_tree(plain(self.doc)) if self.doc is not None else None,
                 "resolved": resolved_view(self.map) if self.map else None,
                 **self._included(),
-                "diagnostics": [asdict(self._result.source.in_main_file(d)) for d in self._report.sorted()],
+                "diagnostics": self._diag_dicts(self._result, self._report),
                 "palette": PALETTE,
                 "units": UNITS,
             }