makea-cli 0.2.28__py3-none-any.whl → 0.2.30__py3-none-any.whl

makea_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.28"
+__version__ = "0.2.30"

makea_cli/commands/files/cmd.py

@@ -1,6 +1,6 @@
 """``makea-cli <persona> get file PATH``: read a file a brand sent, locally.
 
-Pattern DXF/RUL, Illustrator, EPS, Photoshop, embroidery (PES/DST/EMB), ZIP,
+Pattern DXF/RUL/PLT, Illustrator, EPS, Photoshop, embroidery (PES/DST/EMB), ZIP,
 AVIF/TIFF/SVG. No API call: the file never leaves the machine. Pictures of what
 the file draws are saved next to it so the caller can look at them (an agent
 reads them with its image tool).
@@ -21,7 +21,7 @@ from makea_cli.registry import command
 console = Console()
 
 _HELP = (
-    "Read a pattern (DXF/RUL), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or "
+    "Read a pattern (DXF/RUL/PLT), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or "
     "AVIF/TIFF file on this machine: what it states plus PNG pictures of what it draws."
 )
 

makea_cli/file_reader.py

@@ -33,6 +33,26 @@ _MAX_MEMBERS = 40
 _MAX_PICTURES = 8
 _PICTURE_SIDE = 1800
 
+# Never decode an image bigger than this. A decoded image costs w x h x 4
+# bytes whatever the file size, and this runs in web workers (previews) as
+# well as Celery: a 410 MB decode killed one and 502'd the site (TECH-145).
+# Same bound as garmentby_service/common/image_limits.MAX_DECODE_PIXELS.
+MAX_DECODE_PIXELS = 120_000_000
+_MAX_PIECES_DRAWN = 40
+
+
+def _open_bounded(data: bytes):
+    """Open an image and decode it only when it fits MAX_DECODE_PIXELS; JPEGs
+    are decoded at reduced scale. Raises ValueError when it is too big."""
+    Image = _pil()
+    im = Image.open(io.BytesIO(data))
+    if im.width * im.height > MAX_DECODE_PIXELS:
+        raise ValueError(f"{im.width} x {im.height} px is too large to draw here")
+    if im.format == "JPEG":
+        im.draft("RGB", (_PICTURE_SIDE, _PICTURE_SIDE))
+    im.load()
+    return im
+
 
 @dataclass
 class Picture:
@@ -109,20 +129,24 @@ def _pil():
             Image,
         )  # noqa: PLC0415 - optional at import time, required to draw
 
-        Image.MAX_IMAGE_PIXELS = 400_000_000
         return Image
     except ImportError:  # pragma: no cover - Pillow is a dependency
         return None
 
 
 def _png(im) -> bytes:
+    """Shrink first, then flatten: every conversion of the full-size image is
+    another full-size copy in memory."""
     Image = _pil()
+    if max(im.size) > _PICTURE_SIDE:
+        if im.mode in ("P", "PA", "1"):
+            im = im.convert("RGBA")  # palette images cannot be resampled
+        im.thumbnail((_PICTURE_SIDE, _PICTURE_SIDE))
     if im.mode not in ("RGB", "L"):
         rgba = im.convert("RGBA")
         bg = Image.new("RGB", rgba.size, "white")
         bg.paste(rgba, mask=rgba.split()[-1])
         im = bg
-    im.thumbnail((_PICTURE_SIDE, _PICTURE_SIDE))
     buf = io.BytesIO()
     im.save(buf, "PNG", optimize=True)
     return buf.getvalue()
@@ -499,8 +523,7 @@ def _read_eps(data: bytes, name: str, depth: int) -> Reading:
         Image = _pil()
         if tif_len and Image:
             try:
-                im = Image.open(io.BytesIO(_fix_preview_tiff(data[tif_off : tif_off + tif_len])))
-                im.load()
+                im = _open_bounded(_fix_preview_tiff(data[tif_off : tif_off + tif_len]))
                 pictures.append(Picture("preview", _png(im)))
             except Exception:  # noqa: BLE001 - no preview is still a reading
                 pass
@@ -574,8 +597,11 @@ def _read_psd(data: bytes, name: str, depth: int) -> Reading:
             layers = [layer[0] for layer in (getattr(im, "layers", None) or []) if layer[0]]
             if layers:
                 lines.append(f"{len(layers)} layer(s): " + "; ".join(layers[:30]) + ".")
-            im.load()
-            pictures.append(Picture("flattened image", _png(im)))
+            if width * height > MAX_DECODE_PIXELS:
+                lines.append("Too large to draw here.")
+            else:
+                im.load()
+                pictures.append(Picture("flattened image", _png(im)))
         except Exception:  # noqa: BLE001
             lines.append("The flattened image could not be decoded.")
     return Reading("psd", "PSD", " ".join(lines), pictures, readable=bool(pictures))
@@ -711,8 +737,7 @@ def _read_wilcom(data: bytes, name: str, depth: int) -> Reading:
         if Image and ole.exists(stream):
             raw = ole.openstream(stream).read()
             try:
-                im = Image.open(io.BytesIO(zlib.decompress(raw[4:])))
-                im.load()
+                im = _open_bounded(zlib.decompress(raw[4:]))
                 pictures.append(Picture("stitch-out preview", _png(im)))
                 break
             except Exception:  # noqa: BLE001
@@ -974,10 +999,12 @@ def _seam_allowance(b: _Block, cut: Tuple[float, float, float, float]) -> str:
 
 
 def _draw_dxf(items: List[Tuple[str, _Block]]) -> List[Picture]:
-    """One sheet with every piece of the base size, numbered."""
+    """One sheet with every piece of the base size, numbered (the first
+    _MAX_PIECES_DRAWN, so the sheet stays a bounded size)."""
     Image = _pil()
     if not Image or not items:
         return []
+    items = items[:_MAX_PIECES_DRAWN]
     from PIL import ImageDraw  # noqa: PLC0415
 
     shapes = []
@@ -1044,6 +1071,261 @@ def _read_rul(data: bytes, name: str, depth: int) -> Reading:
     return Reading("grade-rules", "RUL", " ".join(lines) + "\n\n```\n" + text[:6000] + "\n```")
 
 
+# ── Pattern: HPGL plot files (.plt) ──────────────────────────────────────
+#
+# What a pattern CAD sends to a cutting or marker plotter: pen-up / pen-down
+# moves in plotter units (40 to the mm), with piece names and sizes as LB text.
+# A plot has no pieces, only strokes, so it says what it draws and how big; the
+# piece table comes from the DXF.
+
+_HPGL_EXTS = (".plt", ".hpgl", ".hpg", ".hgl")
+_HPGL_UNITS_PER_MM = 40.0
+# A full marker is millions of moves; past this the drawing is cut short (and
+# says so) so a read stays bounded in time and memory.
+_HPGL_MAX_POINTS = 2_000_000
+_HPGL_CMD = re.compile(rb"[A-Za-z]{2}")
+_HPGL_NUM = re.compile(rb"[-+]?(?:\d+\.?\d*|\.\d+)")
+# PCL / PJL wrapping around HP-GL/2: "ESC%-12345X@PJL ...", "ESC%1B", "ESCE".
+_PCL_ESCAPE = re.compile(rb"\x1b(?:%-12345X|%-?\d*[AB]|E|\*[a-z]\d*[A-Z])|@PJL[^\n]*\n?")
+
+
+def _is_hpgl(head: bytes, ext: str) -> bool:
+    if ext in _HPGL_EXTS:
+        return True
+    h = _PCL_ESCAPE.sub(b"", head).lstrip(b"\x00\r\n\t ;")
+    return bool(re.match(rb"(?:IN|DF)\s*;\s*(?:[A-Z]{2}[^;]*;\s*){0,6}(?:SP|PU|PD|PA)", h))
+
+
+@dataclass
+class _Plot:
+    strokes: List[Tuple[int, List[Tuple[float, float]]]] = field(
+        default_factory=list
+    )  # (pen, points)
+    labels: List[str] = field(default_factory=list)
+    raw_labels: List[bytes] = field(default_factory=list)
+    points: int = 0
+    truncated: bool = False
+    scaled: bool = False
+    pens: List[int] = field(default_factory=list)
+
+
+_HPGL_ABS_POINTS = (b"EA", b"RA")
+_HPGL_REL_POINTS = (b"PR", b"ER", b"RR", b"AR")
+
+
+def _hpgl_to_plotter(cmd: bytes, params: List[float], absolute: bool, t) -> List[float]:
+    """A command's coordinates from user units (after SC) to plotter units."""
+    fx, fy, ox, oy = t
+    if cmd == b"CI":
+        return [params[0] * fx] + params[1:] if params else params
+    if cmd in (b"AA", b"AR"):
+        # Centre then sweep angle (degrees) and chord tolerance: only the
+        # centre is a coordinate.
+        head = _hpgl_to_plotter(b"PA" if cmd == b"AA" else b"PR", params[:2], True, t)
+        return head + params[2:]
+    is_abs = cmd == b"PA" or cmd in _HPGL_ABS_POINTS or (cmd in (b"PU", b"PD") and absolute)
+    if not is_abs and cmd not in _HPGL_REL_POINTS + (b"PU", b"PD"):
+        return params
+    if is_abs:
+        return [(ox + v * fx) if k % 2 == 0 else (oy + v * fy) for k, v in enumerate(params)]
+    return [v * (fx if k % 2 == 0 else fy) for k, v in enumerate(params)]
+
+
+def _parse_hpgl(data: bytes) -> _Plot:
+    """A small HP-GL / HP-GL/2 interpreter: PU PD PA PR, SP, LB (and DT),
+    IP + SC scaling, CI and the rectangles. Anything else is skipped; arcs are
+    joined as chords. Everything is kept in plotter units (40 to the mm)."""
+    data = _PCL_ESCAPE.sub(b"", data)
+    plot = _Plot()
+    x = y = 0.0
+    # User units -> plotter units: X = ox + x * fx. Identity until SC maps the
+    # IP points (some CADs plot in 1/1000 inch: IP0,0,1016,1016;SC0,1000,0,1000).
+    ip: Optional[Tuple[float, float, float, float]] = None
+    fx = fy = 1.0
+    ox = oy = 0.0
+    absolute, pen_down, pen = True, False, 1
+    cur: Optional[List[Tuple[float, float]]] = None
+    label_end = b"\x03"
+    n = len(data)
+    i = 0
+
+    def start():
+        nonlocal cur
+        cur = [(x, y)]
+        plot.strokes.append((pen, cur))
+
+    def move(nx: float, ny: float):
+        nonlocal x, y, cur
+        if plot.points >= _HPGL_MAX_POINTS:
+            plot.truncated = True
+            x, y = nx, ny
+            return
+        if pen_down:
+            if cur is None:
+                start()
+            cur.append((nx, ny))
+            plot.points += 1
+        else:
+            cur = None
+        x, y = nx, ny
+
+    while i < n:
+        m = _HPGL_CMD.search(data, i)
+        if not m:
+            break
+        cmd = m.group().upper()
+        i = m.end()
+        if cmd == b"LB":
+            end = data.find(label_end, i)
+            end = n if end < 0 else end
+            plot.raw_labels.append(data[i:end])
+            i = end + len(label_end)
+            continue
+        if cmd == b"DT":
+            j = i
+            while j < n and data[j : j + 1] in (b" ", b"\t"):
+                j += 1
+            if j < n and data[j : j + 1] not in (b";",):
+                label_end = data[j : j + 1]
+                i = j + 1
+            continue
+        # Parameters run to the next command letter or ';'.
+        j = i
+        while j < n and not (data[j : j + 1].isalpha() or data[j : j + 1] == b";"):
+            j += 1
+        params = [float(v) for v in _HPGL_NUM.findall(data[i:j])]
+        i = j + 1 if j < n and data[j : j + 1] == b";" else j
+        if (fx, fy, ox, oy) != (1.0, 1.0, 0.0, 0.0):
+            params = _hpgl_to_plotter(cmd, params, absolute, (fx, fy, ox, oy))
+        if cmd in (b"PU", b"PD", b"PA", b"PR"):
+            if cmd == b"PU":
+                pen_down = False
+                cur = None
+            elif cmd == b"PD":
+                pen_down = True
+            elif cmd == b"PA":
+                absolute = True
+            else:
+                absolute = False
+            for k in range(0, len(params) - 1, 2):
+                nx, ny = params[k], params[k + 1]
+                move(nx, ny) if absolute else move(x + nx, y + ny)
+        elif cmd == b"SP":
+            pen = int(params[0]) if params else 0
+            cur = None
+            if pen and pen not in plot.pens:
+                plot.pens.append(pen)
+        elif cmd == b"CI" and params:
+            r = params[0]
+            cx, cy = x, y
+            ring = [
+                (cx + r * math.cos(t / 24 * 2 * math.pi), cy + r * math.sin(t / 24 * 2 * math.pi))
+                for t in range(25)
+            ]
+            plot.strokes.append((pen, ring))
+            plot.points += len(ring)
+        elif cmd in (b"EA", b"ER", b"RA", b"RR") and len(params) >= 2:
+            x1, y1 = (
+                (params[0], params[1]) if cmd in (b"EA", b"RA") else (x + params[0], y + params[1])
+            )
+            plot.strokes.append((pen, [(x, y), (x1, y), (x1, y1), (x, y1), (x, y)]))
+            plot.points += 5
+        elif cmd in (b"AA", b"AR") and len(params) >= 3:
+            cx, cy = (params[0], params[1]) if cmd == b"AA" else (x + params[0], y + params[1])
+            r = math.hypot(x - cx, y - cy)
+            a0 = math.atan2(y - cy, x - cx)
+            sweep = math.radians(params[2])
+            steps = max(2, int(abs(params[2]) / 10))
+            for k in range(1, steps + 1):
+                a = a0 + sweep * k / steps
+                move(cx + r * math.cos(a), cy + r * math.sin(a))
+        elif cmd == b"IP":
+            ip = tuple(params[:4]) if len(params) >= 4 else None
+        elif cmd == b"SC":
+            if len(params) >= 4 and ip and params[1] != params[0] and params[3] != params[2]:
+                fx = (ip[2] - ip[0]) / (params[1] - params[0])
+                fy = (ip[3] - ip[1]) / (params[3] - params[2])
+                ox, oy = ip[0] - params[0] * fx, ip[1] - params[2] * fy
+            elif len(params) >= 4:
+                plot.scaled = True  # scaled against the plotter's own P1/P2: size unknown
+            else:
+                fx = fy = 1.0
+                ox = oy = 0.0
+        elif cmd == b"IN":
+            absolute, pen_down, cur = True, False, None
+            ip, fx, fy, ox, oy = None, 1.0, 1.0, 0.0, 0.0
+    plot.strokes = [(p, pts) for p, pts in plot.strokes if len(pts) > 1]
+    # One encoding for every label, decided on all of them together: a
+    # one-character GBK piece name (领, 前) is no evidence on its own and
+    # reads as Latin or as valid UTF-8 nonsense.
+    joined = _decode_text(b"\x00".join(plot.raw_labels))
+    plot.labels = [t.replace("\r", " ").replace("\n", " ").strip() for t in joined.split("\x00")]
+    plot.labels = [t for t in plot.labels if t]
+    return plot
+
+
+def _read_hpgl(data: bytes, name: str, depth: int) -> Reading:
+    ext = os.path.splitext(name.lower())[1]
+    plot = _parse_hpgl(data)
+    if not plot.strokes:
+        return Reading(
+            "pattern",
+            _format_label(ext),
+            f"{_format_label(ext)} file with no HP-GL drawing in it; it may be a plot file in "
+            "another plotter language. To have it read, send an AAMA/ASTM DXF + RUL export "
+            "of the pattern, or a PDF of the pieces.",
+            readable=False,
+        )
+    pts = [p for _pen, s in plot.strokes for p in s]
+    x0, y0, x1, y1 = _bbox(pts)
+    labels = list(dict.fromkeys(plot.labels))
+    head = ["HP-GL plot file: a pattern or marker as sent to a cutting plotter."]
+    if plot.scaled:
+        head.append(
+            f"It sets its own drawing scale, so its size is in its own units: "
+            f"{_fmt(x1 - x0)} x {_fmt(y1 - y0)}."
+        )
+    else:
+        w_cm = (x1 - x0) / _HPGL_UNITS_PER_MM / 10
+        h_cm = (y1 - y0) / _HPGL_UNITS_PER_MM / 10
+        head.append(f"It draws {_fmt(w_cm)} x {_fmt(h_cm)} cm (40 plotter units to the mm).")
+    head.append(
+        f"{len(plot.strokes)} line(s), {plot.points} point(s), pen(s) {', '.join(map(str, plot.pens)) or '1'}."
+    )
+    if plot.truncated:
+        head.append(f"Only the first {_HPGL_MAX_POINTS} points were read.")
+    body = " ".join(head)
+    if labels:
+        shown = labels[:80]
+        body += "\n\nText in the plot (piece names, sizes and notes, in plot order):\n" + "\n".join(
+            f"- {t}" for t in shown
+        )
+        if len(labels) > len(shown):
+            body += f"\n- … and {len(labels) - len(shown)} more"
+    body += (
+        "\n\nA plot file has no pattern pieces, only strokes, so piece sizes, seam "
+        "allowance and grading are not stated; those come from the DXF + RUL."
+    )
+    return Reading("pattern", _format_label(ext), body, _draw_hpgl(plot, (x0, y0, x1, y1)))
+
+
+def _draw_hpgl(plot: _Plot, bb: Tuple[float, float, float, float]) -> List[Picture]:
+    Image = _pil()
+    if not Image:
+        return []
+    from PIL import ImageDraw  # noqa: PLC0415
+
+    w, h = max(bb[2] - bb[0], 1e-6), max(bb[3] - bb[1], 1e-6)
+    scale = (_PICTURE_SIDE - 40) / max(w, h)
+    im = Image.new("RGB", (max(1, int(w * scale) + 40), max(1, int(h * scale) + 40)), "white")
+    draw = ImageDraw.Draw(im)
+    colours = ["#111111", "#d0021b", "#4a90e2", "#2e7d32", "#9b9b9b", "#5a12c4", "#e68a00"]
+    for pen, pts in plot.strokes:
+        xy = [(20 + (px - bb[0]) * scale, 20 + (bb[3] - py) * scale) for px, py in pts]
+        draw.line(xy, fill=colours[(max(pen, 1) - 1) % len(colours)], width=2)
+    return [Picture("plot (each pen in its own colour)", _png(im))]
+
+
 # ── Archives ─────────────────────────────────────────────────────────────
 
 
@@ -1171,8 +1453,17 @@ def _read_image(data: bytes, name: str, depth: int) -> Reading:
     ext = os.path.splitext(name.lower())[1]
     im = Image.open(io.BytesIO(data))
     frames = getattr(im, "n_frames", 1)
-    im.load()
     text = f"{im.format or _format_label(ext)} image, {im.width} x {im.height} px"
+    if im.width * im.height > MAX_DECODE_PIXELS:
+        return Reading(
+            "image",
+            im.format or _format_label(ext),
+            text + ". Too large to draw here.",
+            readable=False,
+        )
+    if im.format == "JPEG":
+        im.draft("RGB", (_PICTURE_SIDE, _PICTURE_SIDE))
+    im.load()
     dpi = im.info.get("dpi")
     if dpi and dpi[0]:
         text += f", {dpi[0]:.0f} dpi ({im.width / dpi[0] * 25.4:.0f} x {im.height / dpi[1] * 25.4:.0f} mm)"
@@ -1230,7 +1521,83 @@ _READERS: List[Tuple[Callable[[bytes, str], bool], Callable[[bytes, str, int], R
     (_is_stitch, _read_stitch),
     (_is_rul, _read_rul),
     (_is_dxf, _read_dxf),
+    (_is_hpgl, _read_hpgl),
     (_is_zip, _read_zip),
     (_is_svg, _read_svg),
     (_is_image, _read_image),
 ]
+
+
+# ── Run in a child process ───────────────────────────────────────────────
+#
+# A long-lived worker never gives decoded-image memory back to the system, so
+# the backend reads through `python -m makea_cli.file_reader <name>` (file on
+# stdin, JSON on stdout): whatever the read costs is returned when the child
+# exits (TECH-145).
+
+
+def to_json(reading: Reading) -> dict:
+    import base64  # noqa: PLC0415
+
+    return {
+        "kind": reading.kind,
+        "format": reading.format,
+        "text": reading.text,
+        "readable": reading.readable,
+        "pictures": [
+            {"label": p.label, "png": base64.b64encode(p.png).decode("ascii")}
+            for p in reading.pictures
+        ],
+        "members": [[name, to_json(sub)] for name, sub in reading.members],
+        "raw": base64.b64encode(reading.raw).decode("ascii") if reading.raw is not None else None,
+    }
+
+
+def from_json(data: dict) -> Reading:
+    import base64  # noqa: PLC0415
+
+    return Reading(
+        kind=data["kind"],
+        format=data["format"],
+        text=data["text"],
+        readable=data["readable"],
+        pictures=[Picture(p["label"], base64.b64decode(p["png"])) for p in data["pictures"]],
+        members=[(name, from_json(sub)) for name, sub in data["members"]],
+        raw=base64.b64decode(data["raw"]) if data.get("raw") is not None else None,
+    )
+
+
+def read_in_child(data: bytes, name: str, *, timeout: float = 90.0) -> Reading:
+    """read_bytes in a child Python process; a failure or a timeout is a
+    reading that says so, never an exception."""
+    import json  # noqa: PLC0415
+    import subprocess  # noqa: PLC0415
+    import sys  # noqa: PLC0415
+
+    try:
+        done = subprocess.run(
+            [sys.executable, "-m", "makea_cli.file_reader", name],
+            input=data,
+            capture_output=True,
+            timeout=timeout,
+            check=True,
+        )
+        return from_json(json.loads(done.stdout))
+    except Exception as e:  # noqa: BLE001 - the file stays uploaded either way
+        detail = (
+            "it took too long" if isinstance(e, subprocess.TimeoutExpired) else type(e).__name__
+        )
+        ext = os.path.splitext(name.lower())[1]
+        return Reading(
+            "unknown",
+            _format_label(ext),
+            f"{_format_label(ext)} file; it could not be read here ({detail}).",
+            readable=False,
+        )
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+
+    sys.stdout.write(json.dumps(to_json(read_bytes(sys.stdin.buffer.read(), sys.argv[1]))))

{makea_cli-0.2.28.dist-info → makea_cli-0.2.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: makea-cli
-Version: 0.2.28
+Version: 0.2.30
 Summary: Makea admin CLI (browser login + Makea admin HTTP API)
 Requires-Python: >=3.10
 Requires-Dist: click<9,>=8.1
@@ -122,7 +122,7 @@ exit code：`0` 成功 · `2` 用法错 · `3` 未登录或身份与 persona 不
 | `makea-cli admin get about` | read | `GET /admin/about/{target}` | one account's About you (`--user`: a supplier account's person gets their factory's page; `--supplier`): facts, removed, unknown, paused, topic keys. | — |
 | `makea-cli admin get active-users` | read | `POST /admin/analytics/query` | Distinct active users per day over the last N days (DAU series). | `analytics-active-users` |
 | `makea-cli admin get analytics-query` | read | `POST /admin/analytics/query` | Run an arbitrary HogQL query (escape hatch). Example: analytics-query "SELECT count() FROM events" | `analytics-query` |
-| `makea-cli admin get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
+| `makea-cli admin get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL/PLT), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
 | `makea-cli admin get currency-conversion` | read | `GET /admin/fx/rates` | the platform's own exchange rates and rounding (rate table for several --from; one --from with --amount converts it). | `convert-currency` |
 | `makea-cli admin get feature-usage` | read | `POST /admin/analytics/query` | How many distinct users used a feature recently, plus event volume. Matches $pageview path and feature_time_spent eve… | `analytics-feature-usage` |
 | `makea-cli admin get growth-snapshot` | read | `GET /admin/growth/snapshots/{id}` | one reconciled Growth Analysis snapshot (default `latest`); `--block` prints one block (headline, gates, review_items, …). | — |
@@ -207,7 +207,7 @@ exit code：`0` 成功 · `2` 用法错 · `3` 未登录或身份与 persona 不
 | `makea-cli designer delete sampling-order` | write（never） | `DELETE /designer/sampling_orders/{sampling_order_id}` | delete a DRAFT sample order. The backend refuses any other status. Graded `never`. | — |
 | `makea-cli designer delete shipping-order` | write（never） | `POST /designer/shipping_orders/{shipping_order_id}/cancel` | the endpoint is called cancel but it unlinks every production order and removes the shipment, so it is a delete here.… | — |
 | `makea-cli designer download document` | read | `GET /designer/document/download` | save bytes for user_id + document_id (designer-authenticated; same query contract as admin document download). | `designer-download-document` |
-| `makea-cli designer get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
+| `makea-cli designer get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL/PLT), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
 | `makea-cli designer get collection` | read | `GET /designer/collections/{collection_id}/overview` | one collection with its products, orders and lifecycle in a single read. | — |
 | `makea-cli designer get lifecycle` | read | `GET /designer/product_orders/{product_order_id}/lifecycle` | which stage this product is in. | — |
 | `makea-cli designer get product` | read | `GET /designer/get_product` | one product: status, documents, prices, links. | — |
@@ -251,7 +251,7 @@ exit code：`0` 成功 · `2` 用法错 · `3` 未登录或身份与 persona 不
 |---|---|---|---|---|
 | `makea-cli supplier create note` | write（ask） | `POST /supplier/products/{id}/channels/{key}/notes` | post a message into a product channel you are part of. | — |
 | `makea-cli supplier download document` | read | `GET /supplier/document/download` | save a document you are allowed to read. | — |
-| `makea-cli supplier get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
+| `makea-cli supplier get file` | read | local (makea_cli.file_reader) | read a pattern (DXF/RUL/PLT), artwork (AI/EPS/PSD/SVG), embroidery (PES/DST/EMB), ZIP or AVIF/TIFF file on this machine; saves PNG pictures of what it draws next to it. No API call. | — |
 | `makea-cli supplier get pack` | read | `GET /supplier/quote_requests/{id}/technical-specifications` | the tech pack for an RFQ, as the factory is allowed to see it (`--readable`: labels, values and blank essentials only). | — |
 | `makea-cli supplier get pack-changes` | read | `GET /supplier/products/{product_id}/specification-change-history` | what changed in the pack since you quoted, field by field. | — |
 | `makea-cli supplier get profile` | read | `GET /supplier/profile` | your own supplier profile. | — |

{makea_cli-0.2.28.dist-info → makea_cli-0.2.30.dist-info}/RECORD

@@ -1,4 +1,4 @@
-makea_cli/__init__.py,sha256=KP-rlT7kt2ra8vABrHAwk3sAxXx9YgGE14_P5mGaLL4,23
+makea_cli/__init__.py,sha256=R75QzgJ-X9Ixa6UnK5Wm3Jn0Wd9dnVdrtup0aqecq6U,23
 makea_cli/__main__.py,sha256=AkQjxWfKE3w9iD1d6I-2Zqvv2t9cct0oYyFF0UiA-Z0,144
 makea_cli/api_client.py,sha256=jQX6ogn9kt5rHXSmWst0J-1esLb0BYXzDTpPEboEN7Q,80996
 makea_cli/auth_pkce.py,sha256=iXSyJ7DM3qVuj-3FwPiqM25CxXz9ebFs9FNthZdw3ws,7315
@@ -6,7 +6,7 @@ makea_cli/broker.py,sha256=5O650nAdRuF-u9E1MuVM2jVv796iBdxJGIaJasxHij0,3019
 makea_cli/companion.py,sha256=lEEMRDbS-5-CWPawlkPDeCij08pAYW8MsXLVSG3_8V0,10116
 makea_cli/config.py,sha256=hz8MnJSkhxcIEZkcpHR005JrDceo1Xmi8qwIUq50cMU,3003
 makea_cli/errors.py,sha256=_2qKjvkU8YWeBcUd04Yn62lKkZoqQY52kH8klNMyxhM,2780
-makea_cli/file_reader.py,sha256=NQamUyEdNtSw4e1dX_ysHKaocRkcMw6T5P7vlKJhMDU,46625
+makea_cli/file_reader.py,sha256=UUpFCIklCzSGEp1pcg6Z2xlp3WuYnVA53ZpDmgUNgOU,61489
 makea_cli/identity.py,sha256=pfYT-asaY1ZTzoAzfqI-v4Eyz1RtxqR2YgvxRGx_lxg,2758
 makea_cli/main.py,sha256=oU7cMXiZwCnT8gZS1vvuZYgtpDnyqTtb0dlkKIULZzo,9445
 makea_cli/output.py,sha256=6xOJFjoIBphc10nz53xKCyQiz06an7oGtFJ0bap1G-Y,6739
@@ -33,7 +33,7 @@ makea_cli/commands/email/cmd.py,sha256=s22JQjJ7bPdpgBaL7Tmr8hx80ki_JN_iGQtUekXmm
 makea_cli/commands/factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 makea_cli/commands/factory/cmd.py,sha256=k_UGkqpzxxZhN9WjKt1rb95KOTGHMpMJRpfNHTGZ_nA,18691
 makea_cli/commands/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-makea_cli/commands/files/cmd.py,sha256=Tu_m-0xyaSztkJIaDVFK5jKc2R5kSyr4_aKyDxda3TI,2612
+makea_cli/commands/files/cmd.py,sha256=Z1LWYmCUf0C8nHCd5LPwdb1sylG5rNA1X4mUWyxZgT4,2620
 makea_cli/commands/flags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 makea_cli/commands/flags/cmd.py,sha256=BC9Vu2h9HKid5S2SNNUqtgQaqTWRx2Ne529gzGmqrKM,5613
 makea_cli/commands/library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,7 +55,7 @@ makea_cli/commands/supplier/__init__.py,sha256=qfQDeQdQ-B7I_uwFVfcp1vXFUTL4fAcNL
 makea_cli/commands/supplier/cmd.py,sha256=3M7OYhBd-uQk5naoM2I87vJ6IA_P-gdrsbIX2vbyDns,63763
 makea_cli/commands/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 makea_cli/commands/tasks/cmd.py,sha256=72MrVigmjjQCpDVF2a3aJn_gclw2iBbJdFmyd87mXec,8549
-makea_cli-0.2.28.dist-info/METADATA,sha256=Og-CWSQOx383bH_VOY3ETP-JFtPjqQuz195eHrjyhn4,44527
-makea_cli-0.2.28.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-makea_cli-0.2.28.dist-info/entry_points.txt,sha256=4x-lbVa1jBbNlkNq7L-rYyfRh2spZmc3BLIzP-Dl-Qk,50
-makea_cli-0.2.28.dist-info/RECORD,,
+makea_cli-0.2.30.dist-info/METADATA,sha256=XTw-VoX0stheFedgcCuM-P5Hn6jxWGUv5mzP-2CT5-I,44539
+makea_cli-0.2.30.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+makea_cli-0.2.30.dist-info/entry_points.txt,sha256=4x-lbVa1jBbNlkNq7L-rYyfRh2spZmc3BLIzP-Dl-Qk,50
+makea_cli-0.2.30.dist-info/RECORD,,