awcs-scripts 1.0.1__py3-none-any.whl

awcs_scripts/__init__.py

@@ -0,0 +1,3 @@
+"""Scripts for WCS maps and the ARMS API."""
+
+__version__ = "0.1.0"

awcs_scripts/api.py

@@ -0,0 +1,66 @@
+"""ARMS HTTP client. The API key is sent as X-Api-Key."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+_API_PREFIX = "/api/v1"
+
+
+class ApiError(Exception):
+    def __init__(self, status_code: int, body: str) -> None:
+        self.status_code = status_code
+        self.body = body
+        super().__init__(f"HTTP {status_code}")
+
+
+def origin_of(url: str) -> str:
+    """Return the site origin. A trailing /api/v1 is stripped so it is not doubled."""
+    value = url.strip().rstrip("/")
+    if value.endswith(_API_PREFIX):
+        value = value[: -len(_API_PREFIX)].rstrip("/")
+    return value
+
+
+class Client:
+    def __init__(
+        self,
+        url: str,
+        apikey: str,
+        *,
+        transport: httpx.BaseTransport | None = None,
+        timeout: float = 120,
+    ) -> None:
+        self.origin = origin_of(url)
+        self._client = httpx.Client(
+            base_url=self.origin + _API_PREFIX,
+            headers={"X-Api-Key": apikey},
+            transport=transport,
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        data: dict[str, Any] | None = None,
+        files: dict[str, Any] | None = None,
+    ) -> httpx.Response:
+        response = self._client.request(method, path, params=params, json=json, data=data, files=files)
+        if response.status_code >= 400:
+            raise ApiError(response.status_code, response.text)
+        return response

awcs_scripts/cli.py

@@ -0,0 +1,264 @@
+"""Single `awcs` command for map tools and a slice of the ARMS API."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from awcs_scripts.api import ApiError, Client, origin_of
+from awcs_scripts.config import ConfigError, load_profile, save_profile
+
+_TOOLS = Path(__file__).resolve().parent / "mrmap"
+
+
+def _load_tool(filename: str):
+    path = _TOOLS / filename
+    spec = importlib.util.spec_from_file_location(filename.removesuffix(".py").replace("-", "_"), path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"cannot load {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _fail(message: str) -> None:
+    print(message, file=sys.stderr)
+    raise SystemExit(1)
+
+
+def _emit(response: httpx.Response) -> None:
+    if not response.content:
+        return
+    print(json.dumps(response.json(), ensure_ascii=False, indent=2))
+
+
+def _open_client() -> Client:
+    try:
+        url, apikey = load_profile()
+    except ConfigError as exc:
+        _fail(str(exc))
+    return Client(url, apikey)
+
+
+def _params_object(raw: str | None) -> dict[str, Any] | None:
+    if raw is None:
+        return None
+    payload = json.loads(raw)
+    if not isinstance(payload, dict):
+        _fail("--params must be a JSON object")
+    return payload
+
+
+def _list_params(args: argparse.Namespace) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+    if args.page is not None:
+        params["page"] = args.page
+    if args.per_page is not None:
+        params["per_page"] = args.per_page
+    if args.filter is not None:
+        params["filter"] = args.filter
+    if args.sort_by is not None:
+        params["sort_by"] = args.sort_by
+    return params
+
+
+def _add_list_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--page", type=int)
+    parser.add_argument("--per_page", type=int)
+    parser.add_argument("--filter")
+    parser.add_argument("--sort_by")
+
+
+def _cmd_login(args: argparse.Namespace) -> None:
+    origin = origin_of(args.url)
+    with Client(origin, args.apikey) as client:
+        response = client.request("GET", "/users/me")
+    path = save_profile(origin, args.apikey)
+    _emit(response)
+    print(f"saved {path}", file=sys.stderr)
+
+
+def _cmd_users_list(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/users", params=_list_params(args)))
+
+
+def _cmd_users_me(_args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/users/me"))
+
+
+def _cmd_templates_list(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/mission_templates", params=_list_params(args)))
+
+
+def _cmd_templates_execute(args: argparse.Namespace) -> None:
+    body = _params_object(args.params)
+    if body is None:
+        body = {}
+    target = quote(args.id_or_code, safe="")
+    with _open_client() as client:
+        _emit(client.request("POST", f"/mission_templates/{target}/execute", json=body))
+
+
+def _cmd_robots_list(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/robots", params=_list_params(args)))
+
+
+def _cmd_missions_list(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/missions", params=_list_params(args)))
+
+
+def _cmd_missions_create(args: argparse.Namespace) -> None:
+    if args.template_id is not None:
+        body: dict[str, Any] = {"template_id": args.template_id}
+    else:
+        body = {"template_code": args.template_code}
+    params = _params_object(args.params)
+    if params is not None:
+        body["params"] = params
+    with _open_client() as client:
+        _emit(client.request("POST", "/missions", json=body))
+
+
+def _cmd_projects_list(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("GET", "/projects", params=_list_params(args)))
+
+
+def _cmd_projects_create(args: argparse.Namespace) -> None:
+    lif_path = args.lif_json.expanduser()
+    data = {"manufacturer": args.manufacturer, "project_version": args.project_version}
+    if args.description is not None:
+        data["description"] = args.description
+    params = {"synchronous": "true"} if args.synchronous else None
+    with _open_client() as client:
+        with lif_path.open("rb") as handle:
+            files = {"lif_json": (lif_path.name, handle, "application/json")}
+            _emit(client.request("POST", "/projects", params=params, data=data, files=files))
+
+
+def _cmd_projects_activate(args: argparse.Namespace) -> None:
+    with _open_client() as client:
+        _emit(client.request("POST", f"/projects/{args.id}/activate"))
+
+
+_TOOL_COMMANDS = {
+    "mrmap-to-raster": "mrmap-to-raster.py",
+    "mrmap-to-bg": "mrmap-to-bg.py",
+}
+
+
+def _add_tool(sub: argparse._SubParsersAction, name: str, help_text: str) -> None:
+    # The real argv is handled in main() before parse_args, so --help reaches the tool.
+    # The subparser exists so `awcs help` lists the command.
+    sub.add_parser(name, help=help_text)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="awcs", description="AWCS API client")
+    sub = parser.add_subparsers(dest="command")
+
+    help_parser = sub.add_parser("help", help="Show this help")
+    help_parser.set_defaults(func=lambda _args: parser.print_help())
+
+    _add_tool(sub, "mrmap-to-raster", "Rasterize a .mrmap to PNG, GeoTIFF, and JSON")
+    _add_tool(sub, "mrmap-to-bg", "Set a .mrmap raster as a LIF layout background")
+
+    login = sub.add_parser("login", help="Check an API key and save the profile")
+    login.add_argument("--url", required=True, help="ARMS origin, for example https://dev.wcs.automacon.ru")
+    login.add_argument("--apikey", required=True)
+    login.set_defaults(func=_cmd_login)
+
+    users = sub.add_parser("users", help="Users")
+    users_sub = users.add_subparsers(dest="users_command", required=True)
+    users_list = users_sub.add_parser("list", help="GET /users")
+    _add_list_flags(users_list)
+    users_list.set_defaults(func=_cmd_users_list)
+    users_me = users_sub.add_parser("me", help="GET /users/me")
+    users_me.set_defaults(func=_cmd_users_me)
+
+    templates = sub.add_parser("mission_templates", help="Mission templates")
+    templates_sub = templates.add_subparsers(dest="mission_templates_command", required=True)
+    templates_list = templates_sub.add_parser("list", help="GET /mission_templates")
+    _add_list_flags(templates_list)
+    templates_list.set_defaults(func=_cmd_templates_list)
+    templates_execute = templates_sub.add_parser("execute", help="POST /mission_templates/{id}/execute")
+    templates_execute.add_argument("id_or_code", help="Numeric id or template code")
+    templates_execute.add_argument("--params", help="JSON object sent as the request body")
+    templates_execute.set_defaults(func=_cmd_templates_execute)
+
+    robots = sub.add_parser("robots", help="Robots")
+    robots_sub = robots.add_subparsers(dest="robots_command", required=True)
+    robots_list = robots_sub.add_parser("list", help="GET /robots")
+    _add_list_flags(robots_list)
+    robots_list.set_defaults(func=_cmd_robots_list)
+
+    missions = sub.add_parser("missions", help="Missions")
+    missions_sub = missions.add_subparsers(dest="missions_command", required=True)
+    missions_list = missions_sub.add_parser("list", help="GET /missions")
+    _add_list_flags(missions_list)
+    missions_list.set_defaults(func=_cmd_missions_list)
+    missions_create = missions_sub.add_parser("create", help="POST /missions")
+    template = missions_create.add_mutually_exclusive_group(required=True)
+    template.add_argument("--template_id", type=int)
+    template.add_argument("--template_code")
+    missions_create.add_argument("--params", help="JSON object stored in params")
+    missions_create.set_defaults(func=_cmd_missions_create)
+
+    projects = sub.add_parser("projects", help="Navigation projects")
+    projects_sub = projects.add_subparsers(dest="projects_command", required=True)
+    projects_list = projects_sub.add_parser("list", help="GET /projects")
+    _add_list_flags(projects_list)
+    projects_list.set_defaults(func=_cmd_projects_list)
+    projects_create = projects_sub.add_parser("create", help="POST /projects with a LIF file")
+    projects_create.add_argument("--lif_json", type=Path, required=True, help="Path to a .lif file")
+    projects_create.add_argument("--manufacturer", "-m", required=True)
+    projects_create.add_argument("--project_version", "--version", "-v", required=True, dest="project_version")
+    projects_create.add_argument("--description", "--desc", dest="description")
+    projects_create.add_argument("--synchronous", "--sync", action="store_true", dest="synchronous")
+    projects_create.set_defaults(func=_cmd_projects_create)
+    projects_activate = projects_sub.add_parser("activate", help="POST /projects/{id}/activate")
+    projects_activate.add_argument("id", type=int)
+    projects_activate.set_defaults(func=_cmd_projects_activate)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    args_list = list(sys.argv[1:] if argv is None else argv)
+    if args_list and args_list[0] in _TOOL_COMMANDS:
+        _load_tool(_TOOL_COMMANDS[args_list[0]]).main(args_list[1:])
+        return
+    parser = build_parser()
+    args = parser.parse_args(args_list)
+    func = getattr(args, "func", None)
+    if func is None:
+        parser.print_help()
+        return
+    try:
+        func(args)
+    except ApiError as exc:
+        _fail(exc.body or f"HTTP {exc.status_code}")
+    except ConfigError as exc:
+        _fail(str(exc))
+    except json.JSONDecodeError as exc:
+        _fail(f"invalid JSON: {exc}")
+    except httpx.HTTPError as exc:
+        _fail(str(exc))
+    except OSError as exc:
+        _fail(str(exc))
+
+
+if __name__ == "__main__":
+    main()

awcs_scripts/config.py

@@ -0,0 +1,71 @@
+"""Profile with the ARMS origin and API key, stored outside the repository."""
+
+from __future__ import annotations
+
+import configparser
+import os
+import subprocess
+from pathlib import Path
+
+_SECTION = "default"
+
+
+class ConfigError(Exception):
+    pass
+
+
+def config_path() -> Path:
+    override = os.environ.get("AWCS_CONFIG")
+    if override:
+        return Path(override).expanduser()
+    if os.name == "nt":
+        appdata = os.environ.get("APPDATA")
+        if appdata:
+            return Path(appdata) / "awcs" / "config.ini"
+    return Path.home() / ".config" / "awcs" / "config.ini"
+
+
+def load_profile() -> tuple[str, str]:
+    path = config_path()
+    if not path.is_file():
+        raise ConfigError(f"no profile at {path}; run awcs login")
+    parser = configparser.ConfigParser()
+    parser.read(path, encoding="utf-8")
+    if not parser.has_section(_SECTION):
+        raise ConfigError(f"profile {path} has no [{_SECTION}] section")
+    url = parser.get(_SECTION, "url", fallback="").strip()
+    apikey = parser.get(_SECTION, "apikey", fallback="").strip()
+    if not url or not apikey:
+        raise ConfigError(f"profile {path} is missing url or apikey")
+    return url, apikey
+
+
+def save_profile(url: str, apikey: str) -> Path:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    parser = configparser.ConfigParser()
+    parser[_SECTION] = {"url": url, "apikey": apikey}
+    with path.open("w", encoding="utf-8", newline="\n") as handle:
+        parser.write(handle)
+    _user_only(path)
+    return path
+
+
+def _user_only(path: Path) -> None:
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+    if os.name != "nt":
+        return
+    user = os.environ.get("USERNAME")
+    if not user:
+        return
+    try:
+        subprocess.run(
+            ["icacls", str(path), "/inheritance:r", "/grant:r", f"{user}:F"],
+            check=False,
+            capture_output=True,
+        )
+    except OSError:
+        pass

awcs_scripts/mrmap/__init__.py

@@ -0,0 +1 @@
+"""MAIRUI map tools. Command modules use hyphenated filenames and are loaded by path."""

awcs_scripts/mrmap/mrmap-to-bg.py

@@ -0,0 +1,434 @@
+"""Put a MAIRUI .mrmap raster into one LIF layout's backgroundImage.
+
+Only the backgroundImage object of the chosen layout is rewritten. Every other
+byte of the .lif file stays as it was, including node coordinates.
+
+Usage:
+    awcs mrmap-to-bg MAP.mrmap MAP.lif --layout_id LAYOUT_ID [--resolution METERS] [--output OUT.lif]
+
+The raster uses resolution_2d from the .mrmap (override with --resolution).
+Without --output the .lif is overwritten. Node coordinates are not edited.
+
+    awcs mrmap-to-bg MM_before_BODY01_shift.mrmap map_5.0.69.lif --layout_id mapmain
+    awcs mrmap-to-bg MM_before_BODY01_shift.mrmap map_5.0.69.lif --layout_id mapmain --output map_with_bg.lif
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import importlib.util
+import io
+import json
+import os
+import zipfile
+from pathlib import Path
+
+from PIL import Image
+
+
+def _load_raster():
+    path = Path(__file__).with_name("mrmap-to-raster.py")
+    spec = importlib.util.spec_from_file_location("mrmap_to_raster", path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"cannot load {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+_raster = _load_raster()
+load_head = _raster.load_head
+rasterize = _raster.rasterize
+
+_WS = " \t\r\n"
+
+
+class LifEditError(ValueError):
+    pass
+
+
+def _skip_string(text: str, start: int) -> int:
+    """Return the index just after the closing quote. start points at the opening quote."""
+    i = start + 1
+    n = len(text)
+    while i < n:
+        quote = text.find('"', i)
+        if quote < 0:
+            raise LifEditError(f"unterminated string at {start}")
+        slashes = 0
+        j = quote - 1
+        while j >= start and text[j] == "\\":
+            slashes += 1
+            j -= 1
+        if slashes % 2 == 0:
+            return quote + 1
+        i = quote + 1
+    raise LifEditError(f"unterminated string at {start}")
+
+
+def _skip_number(text: str, start: int) -> int:
+    i = start + 1
+    n = len(text)
+    while i < n and text[i] in "0123456789eE+-.":
+        i += 1
+    return i
+
+
+def _value_done(stack: list[dict]) -> None:
+    if stack and stack[-1]["kind"] == "obj" and stack[-1].get("expect") == "value":
+        stack[-1]["expect"] = "comma"
+
+
+def find_layout_spans(text: str, layout_id: str) -> list[tuple[int, int]]:
+    """Return [start, end) brace spans of objects whose layoutId equals layout_id."""
+    spans: list[tuple[int, int]] = []
+    stack: list[dict] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        char = text[i]
+        if char in _WS:
+            i += 1
+            continue
+        if char == "{":
+            stack.append({"kind": "obj", "start": i, "expect": "key", "match": False})
+            i += 1
+            continue
+        if char == "[":
+            stack.append({"kind": "arr", "start": i})
+            i += 1
+            continue
+        if char == "}":
+            if not stack or stack[-1]["kind"] != "obj":
+                raise LifEditError(f"unexpected closing brace at {i}")
+            frame = stack.pop()
+            end = i + 1
+            if frame["match"]:
+                spans.append((frame["start"], end))
+            _value_done(stack)
+            i = end
+            continue
+        if char == "]":
+            if not stack or stack[-1]["kind"] != "arr":
+                raise LifEditError(f"unexpected closing bracket at {i}")
+            stack.pop()
+            _value_done(stack)
+            i += 1
+            continue
+        if char == ",":
+            if stack and stack[-1]["kind"] == "obj":
+                stack[-1]["expect"] = "key"
+            i += 1
+            continue
+        if char == ":":
+            if not stack or stack[-1]["kind"] != "obj" or stack[-1].get("expect") != "colon":
+                raise LifEditError(f"unexpected colon at {i}")
+            stack[-1]["expect"] = "value"
+            i += 1
+            continue
+        if char == '"':
+            end = _skip_string(text, i)
+            if stack and stack[-1]["kind"] == "obj":
+                expect = stack[-1].get("expect")
+                if expect == "key":
+                    stack[-1]["key"] = json.loads(text[i:end])
+                    stack[-1]["expect"] = "colon"
+                elif expect == "value":
+                    if stack[-1].get("key") == "layoutId" and json.loads(text[i:end]) == layout_id:
+                        stack[-1]["match"] = True
+                    _value_done(stack)
+                else:
+                    raise LifEditError(f"unexpected string at {i}")
+            i = end
+            continue
+        if char == "-" or char.isdigit():
+            end = _skip_number(text, i)
+            if stack and stack[-1]["kind"] == "obj" and stack[-1].get("expect") != "value":
+                raise LifEditError(f"unexpected number at {i}")
+            _value_done(stack)
+            i = end
+            continue
+        word = next((item for item in ("true", "false", "null") if text.startswith(item, i)), None)
+        if word is None:
+            raise LifEditError(f"unexpected character {char!r} at {i}")
+        if stack and stack[-1]["kind"] == "obj" and stack[-1].get("expect") != "value":
+            raise LifEditError(f"unexpected literal at {i}")
+        _value_done(stack)
+        i += len(word)
+    if stack:
+        raise LifEditError("unbalanced JSON")
+    return spans
+
+
+def _skip_container(text: str, start: int) -> int:
+    """Return the index just after the container that starts at start."""
+    opener = text[start]
+    closer = "}" if opener == "{" else "]"
+    if opener not in "{[":
+        raise LifEditError(f"expected container at {start}")
+    depth = 0
+    i = start
+    n = len(text)
+    while i < n:
+        char = text[i]
+        if char == '"':
+            i = _skip_string(text, i)
+            continue
+        if char == opener:
+            depth += 1
+        elif char == closer:
+            depth -= 1
+            if depth == 0:
+                return i + 1
+        i += 1
+    raise LifEditError(f"unbalanced container at {start}")
+
+
+def find_member(text: str, obj_start: int, obj_end: int, name: str) -> tuple[int, int, int] | None:
+    """Find a direct child of the object. Returns (key_quote, value_start, value_end)."""
+    i = obj_start + 1
+    depth = 1
+    expect = "key"
+    key = None
+    key_at = None
+    while i < obj_end and depth:
+        char = text[i]
+        if char in _WS:
+            i += 1
+            continue
+        if char == "{":
+            if depth == 1 and expect == "value" and key == name:
+                return key_at, i, _skip_container(text, i)
+            depth += 1
+            i += 1
+            continue
+        if char == "[":
+            if depth == 1 and expect == "value" and key == name:
+                return key_at, i, _skip_container(text, i)
+            depth += 1
+            i += 1
+            continue
+        if char in "}]":
+            depth -= 1
+            i += 1
+            if depth == 1:
+                expect = "comma"
+            continue
+        if char == ",":
+            if depth == 1:
+                expect = "key"
+            i += 1
+            continue
+        if char == ":":
+            if depth == 1:
+                expect = "value"
+            i += 1
+            continue
+        if char == '"':
+            end = _skip_string(text, i)
+            if depth == 1 and expect == "key":
+                key = json.loads(text[i:end])
+                key_at = i
+                expect = "colon"
+            elif depth == 1 and expect == "value":
+                if key == name:
+                    return key_at, i, end
+                expect = "comma"
+            i = end
+            continue
+        if char == "-" or char.isdigit():
+            end = _skip_number(text, i)
+            if depth == 1 and expect == "value" and key == name:
+                return key_at, i, end
+            if depth == 1 and expect == "value":
+                expect = "comma"
+            i = end
+            continue
+        word = next((item for item in ("true", "false", "null") if text.startswith(item, i)), None)
+        if word is None:
+            raise LifEditError(f"unexpected character {char!r} at {i}")
+        if depth == 1 and expect == "value" and key == name:
+            return key_at, i, i + len(word)
+        if depth == 1 and expect == "value":
+            expect = "comma"
+        i += len(word)
+    return None
+
+
+def _line_indent(text: str, index: int) -> str:
+    line_start = text.rfind("\n", 0, index) + 1
+    indent = text[line_start:index]
+    if indent.strip():
+        raise LifEditError(f"key at {index} is not at the start of its line")
+    return indent
+
+
+def format_background(meta: dict, png_bytes: bytes, key_indent: str, include_key_indent: bool) -> str:
+    field_indent = key_indent + "  "
+    uri = "data:image/png;base64," + base64.b64encode(png_bytes).decode("ascii")
+    first = '"backgroundImage": {'
+    if include_key_indent:
+        first = key_indent + first
+    lines = [
+        first,
+        f'{field_indent}"image": {json.dumps(uri)},',
+        f'{field_indent}"x": {json.dumps(meta["x"])},',
+        f'{field_indent}"y": {json.dumps(meta["y"])},',
+        f'{field_indent}"width": {json.dumps(meta["width"])},',
+        f'{field_indent}"height": {json.dumps(meta["height"])},',
+        f'{field_indent}"naturalWidth": {json.dumps(meta["naturalWidth"])},',
+        f'{field_indent}"naturalHeight": {json.dumps(meta["naturalHeight"])}',
+        f"{key_indent}}}",
+    ]
+    return "\n".join(lines)
+
+
+def replace_background(text: str, layout_id: str, meta: dict, png_bytes: bytes) -> tuple[str, tuple[int, int]]:
+    """Return new text and the [start, end) span in the original that was replaced.
+
+    The span covers only the edited region. Prefix and suffix are copied unchanged.
+    For an insert, the span is the whitespace immediately before the layout's closing brace.
+    """
+    spans = find_layout_spans(text, layout_id)
+    if not spans:
+        raise LifEditError(f"layoutId {layout_id!r} not found")
+    if len(spans) > 1:
+        raise LifEditError(f"layoutId {layout_id!r} is not unique ({len(spans)} matches)")
+    obj_start, obj_end = spans[0]
+    member = find_member(text, obj_start, obj_end, "backgroundImage")
+    if member is not None:
+        key_at, _value_start, value_end = member
+        key_indent = _line_indent(text, key_at)
+        block = format_background(meta, png_bytes, key_indent, include_key_indent=False)
+        new_text = text[:key_at] + block + text[value_end:]
+        return new_text, (key_at, value_end)
+
+    layout_id_member = find_member(text, obj_start, obj_end, "layoutId")
+    if layout_id_member is None:
+        raise LifEditError(f"layout object for {layout_id!r} has no layoutId key")
+    key_indent = _line_indent(text, layout_id_member[0])
+    block = format_background(meta, png_bytes, key_indent, include_key_indent=True)
+    closing_line = text.rfind("\n", obj_start, obj_end - 1) + 1
+    content_end = closing_line - 1
+    while content_end > obj_start and text[content_end] in " \t":
+        content_end -= 1
+    # content_end is the last newline before the closing brace, or the last content char.
+    if text[content_end] == "\n":
+        last = content_end - 1
+        while last > obj_start and text[last] in " \t":
+            last -= 1
+    else:
+        last = content_end
+    if text[last] == "{":
+        new_text = text[: last + 1] + "\n" + block + "\n" + text[closing_line:]
+        return new_text, (last + 1, closing_line)
+    new_text = text[: last + 1] + ",\n" + block + "\n" + text[closing_line:]
+    return new_text, (last + 1, closing_line)
+
+
+def render_png(mrmap_path: Path, resolution: float | None) -> tuple[bytes, dict]:
+    with zipfile.ZipFile(mrmap_path) as archive:
+        head = load_head(archive)
+        if head.get("magic") != "MAIRUI":
+            raise LifEditError(f"unexpected map magic: {head.get('magic')!r}")
+        if resolution is None:
+            resolution = float(head["resolution_2d"])
+        if resolution <= 0:
+            raise LifEditError(f"resolution must be positive, got {resolution}")
+        image, info = rasterize(archive, head, resolution)
+    buffer = io.BytesIO()
+    Image.fromarray(image, mode="L").save(buffer, format="PNG")
+    info["png"] = buffer.getvalue()
+    return info["png"], info
+
+
+def _check_background(data: dict, layout_id: str, meta: dict, png_bytes: bytes) -> None:
+    matches = [layout for layout in data["layouts"] if layout.get("layoutId") == layout_id]
+    if len(matches) != 1:
+        raise LifEditError(f"parsed layout count for {layout_id!r} is {len(matches)}")
+    background = matches[0].get("backgroundImage")
+    if not isinstance(background, dict):
+        raise LifEditError("backgroundImage missing after edit")
+    for key in ("x", "y", "width", "height", "naturalWidth", "naturalHeight"):
+        if background.get(key) != meta[key]:
+            raise LifEditError(f"{key} is {background.get(key)!r}, expected {meta[key]!r}")
+    prefix = "data:image/png;base64,"
+    image = background.get("image")
+    if not isinstance(image, str) or not image.startswith(prefix):
+        raise LifEditError("background image is not a png data uri")
+    decoded = base64.b64decode(image[len(prefix):], validate=True)
+    if decoded != png_bytes:
+        raise LifEditError("embedded png does not match the raster")
+    with Image.open(io.BytesIO(decoded)) as picture:
+        if picture.size != (meta["naturalWidth"], meta["naturalHeight"]):
+            raise LifEditError(f"png size {picture.size} does not match natural size")
+
+
+def apply_background(
+    mrmap_path: Path,
+    lif_path: Path,
+    layout_id: str,
+    output_path: Path | None,
+    resolution: float | None,
+) -> dict:
+    png_bytes, info = render_png(mrmap_path, resolution)
+    original = lif_path.read_bytes()
+    text = original.decode("utf-8")
+    new_text, (old_start, old_end) = replace_background(text, layout_id, info["meta"], png_bytes)
+    suffix_len = len(text) - old_end
+    if new_text[:old_start] != text[:old_start]:
+        raise LifEditError("edit touched text before backgroundImage")
+    if suffix_len and new_text[-suffix_len:] != text[old_end:]:
+        raise LifEditError("edit touched text after backgroundImage")
+    if suffix_len and len(new_text) < old_start + suffix_len:
+        raise LifEditError("edit overlapped the unchanged suffix")
+    parsed = json.loads(new_text)
+    _check_background(parsed, layout_id, info["meta"], png_bytes)
+    new_bytes = new_text.encode("utf-8")
+    destination = output_path or lif_path
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_suffix(destination.suffix + ".tmp")
+    temporary.write_bytes(new_bytes)
+    os.replace(temporary, destination)
+    info["output"] = destination
+    info["unchanged_prefix"] = old_start
+    info["unchanged_suffix"] = suffix_len
+    return info
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="awcs mrmap-to-bg",
+        description="Rasterize a .mrmap and set it as a LIF layout backgroundImage.",
+    )
+    parser.add_argument("mrmap", type=Path, help="path to a .mrmap file")
+    parser.add_argument("lif", type=Path, help="path to a .lif file")
+    parser.add_argument("--layout_id", required=True, help="layoutId whose backgroundImage is replaced")
+    parser.add_argument("--resolution", type=float, default=None, help="meters per pixel (default: resolution_2d)")
+    parser.add_argument("--output", type=Path, default=None, help="output .lif (default: overwrite the input)")
+    args = parser.parse_args(argv)
+    info = apply_background(
+        args.mrmap.expanduser().resolve(),
+        args.lif.expanduser().resolve(),
+        args.layout_id,
+        args.output.expanduser().resolve() if args.output else None,
+        args.resolution,
+    )
+    meta = info["meta"]
+    print(f"layout {args.layout_id}")
+    print(f"resolution_m {info['resolution']}")
+    print(f"pixels {meta['naturalWidth']} x {meta['naturalHeight']}")
+    print(f"x {meta['x']}")
+    print(f"y {meta['y']}")
+    print(f"width {meta['width']}")
+    print(f"height {meta['height']}")
+    print(f"points_kept {info['kept']}")
+    print(f"points_dropped {info['dropped']}")
+    print(f"unchanged_prefix {info['unchanged_prefix']}")
+    print(f"unchanged_suffix {info['unchanged_suffix']}")
+    print(f"output {info['output']}")
+
+
+if __name__ == "__main__":
+    main()

awcs_scripts/mrmap/mrmap-to-raster.py

@@ -0,0 +1,174 @@
+"""Rasterize a MAIRUI .mrmap point cloud into PNG, GeoTIFF, and placement JSON.
+
+World frame of each submap point (x, y), yaw in radians:
+
+    wx = origin_x + cos(yaw) * x - sin(yaw) * y
+    wy = origin_y + sin(yaw) * x + cos(yaw) * y
+
+The raster is anchored at bbox_min (lower-left). Pixel (0, 0) is the upper-left
+corner of the image, so world Y decreases as the row index increases.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import tifffile
+from PIL import Image
+
+_DATA_BINARY = b"DATA binary\n"
+_POINT_STRIDE = 16  # x, y, z, intensity as float32
+
+
+def pixel_count(span: float, resolution: float) -> int:
+    count = int(math.ceil(span / resolution))
+    if count > 0 and (count - 1) * resolution >= span:
+        count -= 1
+    return max(count, 1)
+
+
+def load_head(archive: zipfile.ZipFile) -> dict:
+    return json.loads(archive.read("map_head.json"))
+
+
+def iter_world_xy(archive: zipfile.ZipFile, submap: dict):
+    raw = archive.read(submap["pc_entry"])
+    start = raw.find(_DATA_BINARY)
+    if start < 0:
+        raise ValueError(f"{submap['pc_entry']}: expected 'DATA binary'")
+    payload = raw[start + len(_DATA_BINARY) :]
+    payload = payload[: len(payload) - (len(payload) % _POINT_STRIDE)]
+    if not payload:
+        return np.empty((0, 2), dtype=np.float64)
+    local = np.frombuffer(payload, dtype="<f4").reshape(-1, 4)
+    yaw = math.radians(float(submap["origin_yaw_deg"]))
+    cos_yaw = math.cos(yaw)
+    sin_yaw = math.sin(yaw)
+    origin_x = float(submap["origin_x"])
+    origin_y = float(submap["origin_y"])
+    lx = local[:, 0].astype(np.float64, copy=False)
+    ly = local[:, 1].astype(np.float64, copy=False)
+    world = np.empty((lx.shape[0], 2), dtype=np.float64)
+    world[:, 0] = origin_x + cos_yaw * lx - sin_yaw * ly
+    world[:, 1] = origin_y + sin_yaw * lx + cos_yaw * ly
+    return world
+
+
+def rasterize(archive: zipfile.ZipFile, head: dict, resolution: float) -> tuple[np.ndarray, dict]:
+    xmin, ymin = (float(v) for v in head["bbox_min_xy"])
+    xmax, ymax_bbox = (float(v) for v in head["bbox_max_xy"])
+    cols = pixel_count(xmax - xmin, resolution)
+    rows = pixel_count(ymax_bbox - ymin, resolution)
+    width = cols * resolution
+    height = rows * resolution
+    top = ymin + height
+    image = np.full((rows, cols), 255, dtype=np.uint8)
+    kept = 0
+    dropped = 0
+    for submap in head["submaps_meta"]:
+        world = iter_world_xy(archive, submap)
+        if world.size == 0:
+            continue
+        col = np.floor((world[:, 0] - xmin) / resolution).astype(np.int64)
+        row = np.floor((top - world[:, 1]) / resolution).astype(np.int64)
+        inside = (
+            (world[:, 0] >= xmin)
+            & (world[:, 0] <= xmin + width)
+            & (world[:, 1] >= ymin)
+            & (world[:, 1] <= top)
+        )
+        col = np.clip(col, 0, cols - 1)
+        row = np.clip(row, 0, rows - 1)
+        if np.any(inside):
+            image[row[inside], col[inside]] = 0
+        kept += int(np.count_nonzero(inside))
+        dropped += int(np.count_nonzero(~inside))
+    meta = {
+        "x": xmin,
+        "y": ymin,
+        "width": width,
+        "height": height,
+        "naturalWidth": cols,
+        "naturalHeight": rows,
+    }
+    return image, {"meta": meta, "resolution": resolution, "kept": kept, "dropped": dropped, "top": top}
+
+
+def write_geotiff(path: Path, image: np.ndarray, meta: dict, resolution: float) -> None:
+    """Upper-left corner of pixel (0, 0) is (x, y + height). Y decreases downward."""
+    top = meta["y"] + meta["height"]
+    geokeys = (
+        1, 1, 0, 2,
+        1024, 0, 1, 1,  # GTModelTypeGeoKey = ModelTypeProjected
+        1025, 0, 1, 1,  # GTRasterTypeGeoKey = RasterPixelIsArea
+    )
+    tifffile.imwrite(
+        path,
+        image,
+        photometric="minisblack",
+        extratags=[
+            (33550, "d", 3, (float(resolution), float(resolution), 0.0), True),
+            (33922, "d", 6, (0.0, 0.0, 0.0, float(meta["x"]), float(top), 0.0), True),
+            (34735, "H", len(geokeys), geokeys, True),
+        ],
+    )
+
+
+def convert(mrmap_path: Path, out_dir: Path, resolution: float | None) -> dict:
+    with zipfile.ZipFile(mrmap_path) as archive:
+        head = load_head(archive)
+        if head.get("magic") != "MAIRUI":
+            raise ValueError(f"unexpected map magic: {head.get('magic')!r}")
+        if resolution is None:
+            resolution = float(head["resolution_2d"])
+        if resolution <= 0:
+            raise ValueError(f"resolution must be positive, got {resolution}")
+        image, info = rasterize(archive, head, resolution)
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stem = mrmap_path.stem
+    png_path = out_dir / f"{stem}.png"
+    tif_path = out_dir / f"{stem}.tif"
+    json_path = out_dir / f"{stem}.json"
+    meta = info["meta"]
+
+    Image.fromarray(image, mode="L").save(png_path)
+    write_geotiff(tif_path, image, meta, info["resolution"])
+    json_path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
+
+    info["paths"] = {"png": png_path, "tif": tif_path, "json": json_path}
+    return info
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="awcs mrmap-to-raster",
+        description="Convert a MAIRUI .mrmap to PNG, GeoTIFF, and placement JSON.",
+    )
+    parser.add_argument("mrmap", type=Path, help="path to a .mrmap file")
+    parser.add_argument("--resolution", type=float, default=None, help="meters per pixel (default: resolution_2d)")
+    parser.add_argument("--out-dir", type=Path, default=None, help="output directory (default: next to the input)")
+    args = parser.parse_args(argv)
+    mrmap_path = args.mrmap.expanduser().resolve()
+    out_dir = (args.out_dir or mrmap_path.parent).expanduser().resolve()
+    info = convert(mrmap_path, out_dir, args.resolution)
+    meta = info["meta"]
+    print(f"resolution_m {info['resolution']}")
+    print(f"pixels {meta['naturalWidth']} x {meta['naturalHeight']}")
+    print(f"x {meta['x']}")
+    print(f"y {meta['y']}")
+    print(f"width {meta['width']}")
+    print(f"height {meta['height']}")
+    print(f"points_kept {info['kept']}")
+    print(f"points_dropped {info['dropped']}")
+    for kind, path in info["paths"].items():
+        print(f"{kind} {path}")
+
+
+if __name__ == "__main__":
+    main()

awcs_scripts-1.0.1.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.5
+Name: awcs-scripts
+Version: 1.0.1
+Summary: Command line scripts for WCS maps and the ARMS API
+Project-URL: Repository, https://gitlab.sprydev.ru/automacon/agv/wcs/awcs_scripts
+Author: AWCS
+License: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx
+Requires-Dist: numpy
+Requires-Dist: pillow
+Requires-Dist: tifffile
+Description-Content-Type: text/markdown
+
+# awcs-scripts
+
+Скрипты для карт WCS и части ARMS API. Пакет называется `awcs-scripts`, команда после установки — `awcs`.
+
+## Публикация в PyPI
+
+Выкладка происходит только по тегу `vX.Y.Z`. Обычный push и merge request пакет не публикуют: CI прогоняет тесты и собирает wheel. Версию берёт джоба `publish` из тега (`v0.1.0` → `0.1.0`), поле `version` в `pyproject.toml` на публикацию не влияет.
+
+Токен в репозиторий не входит. Его нужно завести один раз:
+
+1. На [pypi.org](https://pypi.org) создать API-токен с правом загрузки. Для первой выкладки имя `awcs-scripts` должно быть свободно: проект создаётся при первой успешной загрузке. До этого нужен токен уровня аккаунта, после первой публикации его можно ограничить этим проектом.
+2. В GitLab, в CI/CD-переменных этого репозитория, добавить `UV_PUBLISH_TOKEN` со значением токена и включить **Masked**. **Protected** включать только если теги `v*` тоже protected: иначе на теге переменная в джобу не попадёт и `uv publish` упадёт без токена.
+
+Тег и отправка:
+
+```
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+Репозиторий закрытый, а `uv publish` пишет на публичный PyPI. После зелёного пайплайна wheel доступен по имени пакета.
+
+## Установка
+
+```
+uv tool install awcs-scripts
+```
+
+До первого тега те же подкоманды запускаются из git. Репозиторий закрытый, доступ к GitLab уже должен быть настроен, токен в команду не подставляется:
+
+```
+uvx --from git+https://gitlab.sprydev.ru/automacon/agv/wcs/awcs_scripts.git awcs help
+```
+
+Из клона репозитория, без публикации:
+
+```
+uv tool install .
+```
+
+После этого команда `awcs` доступна в системе. Для разработки в том же клоне:
+
+```
+uv sync
+uv run awcs help
+uv build
+```
+
+## Удаление
+
+Снимает команду `awcs`, поставленную через `uv tool install` из клона или с PyPI:
+
+```
+uv tool uninstall awcs-scripts
+```
+
+Профиль с адресом и ключом эта команда не трогает. Его файл лежит по `AWCS_CONFIG`, иначе `%APPDATA%\awcs\config.ini` на Windows и `~/.config/awcs/config.ini` в остальных системах. Чтобы убрать и ключ, удалите этот файл.
+
+## Команды
+
+```
+awcs help
+awcs mrmap-to-raster path/to/map.mrmap --out-dir path/to/out
+awcs mrmap-to-bg path/to/map.mrmap path/to/layout.lif --layout_id layoutId --resolution 0.05 --output path/to/layout.out.lif
+awcs login --url https://dev.wcs.automacon.ru --apikey <apikey>
+awcs users list
+awcs users me
+awcs mission_templates list
+awcs robots list
+awcs missions list
+awcs missions create --template_code PickPallet --params "{\"zone\":\"A\"}"
+awcs mission_templates execute PickPallet --params "{\"zone\":\"A\"}"
+awcs projects list
+awcs projects create --lif_json path/to/layout.lif -m MAIRUI -v 1.0.0 --desc "line 1" --sync
+awcs projects activate 12
+```
+
+Разовый запуск после публикации:
+
+```
+uvx --from awcs-scripts awcs help
+uvx --from awcs-scripts awcs mrmap-to-raster path/to/map.mrmap --resolution 0.05 --out-dir path/to/out
+uvx --from awcs-scripts awcs users me
+```
+
+`awcs mrmap-to-raster` пишет PNG, GeoTIFF и JSON. `--resolution` задаёт метры на пиксель, по умолчанию берётся `resolution_2d` из карты. `awcs mrmap-to-bg` подставляет этот растр в `backgroundImage` одного layout. Без `--output` исходный `.lif` перезаписывается.
+
+`awcs login` проверяет ключ через `GET /users/me` и только после ответа 200 сохраняет origin и ключ. Профиль лежит вне репозитория: путь из `AWCS_CONFIG`, иначе `%APPDATA%\awcs\config.ini` на Windows и `~/.config/awcs/config.ini` в остальных системах. Ключ в вывод не печатается. Клиент сам дописывает `/api/v1` и шлёт заголовок `X-Api-Key`.
+
+У списков есть `--page`, `--per_page`, `--filter`, `--sort_by`. `awcs missions create` принимает `--template_id` или `--template_code` и необязательный `--params`. `awcs mission_templates execute` отправляет `--params` плоским JSON-объектом. `awcs projects create` загружает LIF как `multipart/form-data`: `-m` это `--manufacturer`, `-v` и `--version` это `--project_version`, `--desc` это `--description`, `--sync` это `--synchronous`.
+
+## Разработка
+
+Карта живёт в `src/awcs_scripts/mrmap/`. Имена файлов совпадают с подкомандами: `mrmap-to-raster.py` и `mrmap-to-bg.py`. Будущие shell-скрипты кладутся в `bash/` и тоже вызываются только через `awcs`.

awcs_scripts-1.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+awcs_scripts/__init__.py,sha256=qZwBaSA9sxWB32dGuygTwqLWo36eHDhPwoH1mi1aluw,68
+awcs_scripts/api.py,sha256=4z_OD2qxGKiPUYPi5yDu95f7AD2ZILfF9_eiJ-CnXvc,1743
+awcs_scripts/cli.py,sha256=qvwO0UBzL3NuGJa-JXBKScBVUvJ-ycXfsUAOxiU1tkw,10086
+awcs_scripts/config.py,sha256=hLft4fmTk3K97Qt51pfEgPltYnPhL09raPgjh0wP1tI,1978
+awcs_scripts/mrmap/__init__.py,sha256=2UI1KO_YhOO1HCOHV-Q9FJm5Fxup_jE5DI00IGHPDDQ,89
+awcs_scripts/mrmap/mrmap-to-bg.py,sha256=26H4oOyaF-FPELd_mLMIvJ8MG_XDZX7-8EKsERdHhwE,16508
+awcs_scripts/mrmap/mrmap-to-raster.py,sha256=VlCib6Z84CEiRoobQaNvZ16ebtJT3ZcTe9iE1KhEQiY,6383
+awcs_scripts-1.0.1.dist-info/METADATA,sha256=cqj8JvOTEYOrVWN7ExAEVhkNxKRTkT10WwexutljSUA,6100
+awcs_scripts-1.0.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+awcs_scripts-1.0.1.dist-info/entry_points.txt,sha256=dgDy55MUX47MYoo2R-ocEYevBZbFKqI468upVmAUiIs,47
+awcs_scripts-1.0.1.dist-info/licenses/LICENSE,sha256=AQ59EbGYZeqWXEy59FCXjUH5KbOoAFcGjqbGzkWJzHg,733
+awcs_scripts-1.0.1.dist-info/RECORD,,

awcs_scripts-1.0.1.dist-info/WHEEL

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

awcs_scripts-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awcs = awcs_scripts.cli:main

awcs_scripts-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 AWCS
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.