studio-psd-extract 0.2.0__py3-none-any.whl

studio_psd_extract/__init__.py

@@ -0,0 +1,152 @@
+"""Extracción de PSD -> contrato JSON v1. `extract` es PURA (sin red ni DAM)."""
+from __future__ import annotations
+
+import io
+import math
+from importlib.metadata import PackageNotFoundError, version as _version
+
+from .guard import GuardError, check_header
+
+try:
+    EXTRACTOR_VERSION = _version("studio-psd-extract")
+except PackageNotFoundError:  # árbol de fuentes sin instalar
+    EXTRACTOR_VERSION = "0+unknown"
+
+
+def _preorder(layers):
+    """Capas en el mismo orden pre-orden que usa `layers.walk` para numerar ids."""
+    for l in layers:
+        yield l
+        if l.is_group():
+            yield from _preorder(list(l))
+
+
+def _flatten(nodes):
+    for n in nodes:
+        yield n
+        yield from _flatten(n["children"])
+
+
+def _ppi(psd) -> int:
+    """ppi desde RESOLUTION_INFO: `horizontal` es fixed-point 16.16; unit 2 = px/cm."""
+    from psd_tools.constants import Resource
+    info = psd.image_resources.get_data(Resource.RESOLUTION_INFO)
+    raw = getattr(info, "horizontal", None)
+    if not raw:
+        return 72
+    try:
+        value = float(raw) / 65536.0
+        if getattr(info, "horizontal_unit", 1) == 2:  # px/cm -> px/in
+            value *= 2.54
+        ppi = int(round(value))
+    except (TypeError, ValueError):
+        return 72
+    return ppi if 1 <= ppi <= 2000 else 72
+
+
+def _transform_scale(layer) -> tuple[float, bool]:
+    """Escala efectiva del `TypeLayer.transform` (xx, xy, yx, yy, tx, ty) -> (escala, es_compleja).
+
+    Escala uniforme geométrica = sqrt(|det|) = sqrt(|xx*yy - xy*yx|): para escala pura
+    (con o sin reflejo) coincide con el factor; con rotación pura es 1.0 (la rotación no
+    cambia el tamaño). `es_compleja` si hay rotación/shear (xy o yx > 1% de la escala) o
+    escala anisotrópica (||xx|-|yy|| > 1% de la escala), donde una sola escala es aproximada. tx/ty son posición, no afectan. Identidad, atributo
+    ausente o valor inválido -> (1.0, False).
+    """
+    try:
+        xx, xy, yx, yy = (float(x) for x in tuple(layer.transform)[:4])
+    except (AttributeError, TypeError, ValueError):
+        return 1.0, False
+    scale = abs(xx * yy - xy * yx) ** 0.5
+    if not math.isfinite(scale) or not scale > 1e-9:
+        return 1.0, False
+    if abs(scale - 1.0) < 1e-6:
+        scale = 1.0
+    tol = 0.01 * scale
+    return scale, max(abs(xy), abs(yx)) > tol or abs(abs(xx) - abs(yy)) > tol
+
+
+def extract(psd_bytes: bytes, *, theme_families: list[str] | None = None, profile=None,
+            mode: str = "online") -> dict:
+    from . import artboards as _artboards, layers as _layers, limits, raster, text as _text
+    from .model import bbox_dict, map_kind
+
+    p = profile or limits.server()
+    head = check_header(psd_bytes, p)
+
+    from psd_tools import PSDImage
+    psd = PSDImage.open(io.BytesIO(psd_bytes))
+
+    from .color import ColorConverter
+
+    converter = ColorConverter(raster._icc_profile(psd), head["color_mode"])
+
+    all_layers = list(psd.descendants())
+    if len(all_layers) > p.max_layers:
+        raise GuardError("psd_too_complex", f"{len(all_layers)} capas > {p.max_layers}")
+    for l in all_layers:
+        try:
+            b = bbox_dict(l.bbox)
+        except ValueError:
+            continue
+        if b["w"] * b["h"] > p.max_layer_pixels:
+            raise GuardError("psd_too_complex",
+                             f"capa '{l.name}' {b['w']}x{b['h']}px > {p.max_layer_pixels}")
+
+    boards = _artboards.detect(psd)
+    tree = _layers.walk(psd, boards)
+    warnings: list[dict] = []
+    fonts: dict[str, dict] = {}
+    theme = set(theme_families or [])
+
+    flat_nodes = list(_flatten(tree))
+    ordered_layers = list(_preorder(list(psd)))
+    if len(flat_nodes) != len(ordered_layers):
+        raise RuntimeError(
+            f"desalineado nodo/capa: {len(flat_nodes)} nodos vs {len(ordered_layers)} capas")
+    for node, layer in zip(flat_nodes, ordered_layers):
+        if node["name"] != layer.name or node["kind"] != map_kind(layer):
+            raise RuntimeError(
+                f"desalineado nodo/capa: nodo {node['id']} ({node['name']!r}, {node['kind']}) "
+                f"vs capa {layer.name!r} ({map_kind(layer)})")
+        node["text"] = None
+        node["asset"] = None
+        if node["kind"] != "text":
+            continue
+        scale, complex_tf = _transform_scale(layer)
+        try:
+            t = _text.runs(layer, scale, theme, to_hex=converter.hex)
+        except Exception as exc:  # noqa: BLE001 - un run malo no debe perder el PSD entero
+            warnings.append({"code": "text_parse_failed", "layer": node["id"],
+                             "detail": repr(exc)})
+            continue
+        node["text"] = t
+        for r in t["runs"]:
+            f = fonts.setdefault(r["family"], {"family": r["family"],
+                                               "available": r["font_available"], "runs": 0})
+            f["runs"] += 1
+        if complex_tf:
+            warnings.append({"code": "text_transform_complex", "layer": node["id"],
+                             "scale": round(scale, 6)})
+
+    # Nodo extra por mesa con el background rasterizado (bytes; la subida es Task 7).
+    for a in boards:
+        bg = raster.artboard_background(psd, a, converter)
+        warnings.extend(bg["warnings"])
+        tree.append({
+            "id": f"{a['id']}-bg", "name": f"{a['name']} (fondo sin texto)", "kind": "pixel",
+            "artboard": a["id"], "bbox": dict(a["rect"]), "visible": True, "opacity": 1.0,
+            "clipping": False, "mask": False, "effects": [], "children": [], "text": None,
+            "asset": {"png": bg["png"], "rgba_hash": bg["rgba_hash"], "w": bg["w"], "h": bg["h"]},
+        })
+
+    return {
+        "contract_version": 1,
+        "extractor": {"mode": mode, "version": EXTRACTOR_VERSION},
+        "document": {"width": head["width"], "height": head["height"], "ppi": _ppi(psd),
+                     "color_mode": head["color_mode"], "depth": head["depth"]},
+        "artboards": boards,
+        "layers": tree,
+        "fonts_used": list(fonts.values()),
+        "warnings": warnings,
+    }

studio_psd_extract/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

studio_psd_extract/artboards.py

@@ -0,0 +1,22 @@
+"""Detección de mesas (artboards) de un PSDImage de psd-tools."""
+from __future__ import annotations
+
+from .model import bbox_dict
+
+
+def detect(psd) -> list[dict]:
+    """Mesas = grupos con tagged block ARTBOARD_DATA (psd-tools los expone como
+    `Artboard`, con bbox = artboardRect). Sin mesas: una sola `A0` = canvas."""
+    found = []
+    for layer in psd.descendants():
+        if layer.kind != "artboard":
+            continue
+        try:
+            rect = bbox_dict(layer.bbox)
+        except ValueError:  # artboardRect ausente/incompleto
+            continue
+        found.append({"id": f"A{len(found)}", "name": layer.name, "rect": rect})
+    if found:
+        return found
+    return [{"id": "A0", "name": "A0",
+             "rect": {"x": 0, "y": 0, "w": psd.width, "h": psd.height}}]

studio_psd_extract/builtin_fonts.py

@@ -0,0 +1,15 @@
+"""Fuentes built-in del render de Studio.
+
+Espejo de BUILTIN_FONTS (packages/studio-render-core/src/builtin-fonts.ts en
+omnitok-studio-api). Mantener en sync a mano si se agrega o quita una built-in.
+"""
+BUILTIN_FONTS = (
+    "Nunito Sans",
+    "Open Sans",
+    "Inter",
+    "Manrope",
+    "Libre Franklin",
+    "Lora",
+    "Roboto Slab",
+    "Plus Jakarta Sans",
+)

studio_psd_extract/cli.py

@@ -0,0 +1,94 @@
+"""CLI local: `studio-psd-extract <archivo.psd> --out-dir <carpeta>`.
+
+Escribe `extraction.json` (contrato completo) y `assets/psd-<hash12>.png`, e imprime en stdout
+solo el resumen compacto. Corre `extract()` directo, sin sandbox: el archivo es de la persona.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import extract, limits
+from .compact import iter_nodes, outline, summary
+from .guard import GuardError
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="studio-psd-extract",
+                                description="Extrae un PSD al contrato JSON de Omnitok Studio.")
+    p.add_argument("psd", type=Path, help="archivo .psd, o un extraction.json ya generado (con --artboard)")
+    p.add_argument("--out-dir", type=Path, help="carpeta de salida (obligatoria con un .psd)")
+    p.add_argument("--artboard", help="imprime el outline compacto de esa mesa en vez del resumen")
+    p.add_argument("--brand-fonts", default="",
+                   help="familias de la marca separadas por coma (font_available=theme)")
+    p.add_argument("--font-dir", type=Path, action="append", default=[],
+                   help="carpeta extra de fuentes (se puede repetir); se busca antes que las del sistema")
+    p.add_argument("--no-metrics", action="store_true", help="no medir fuentes sustitutas")
+    return p
+
+
+def _write_assets(result: dict, out_dir: Path) -> None:
+    assets_dir = out_dir / "assets"
+    assets_dir.mkdir(parents=True, exist_ok=True)
+    for node in iter_nodes(result.get("layers") or []):
+        a = node.get("asset")
+        if not isinstance(a, dict) or "png" not in a:
+            continue
+        h = a["rgba_hash"]
+        name = f"psd-{h[:12]}.png"
+        path = (assets_dir / name).resolve()
+        path.write_bytes(a["png"])
+        node["asset"] = {"local_path": str(path), "filename": name, "content_type": "image/png",
+                         "size": len(a["png"]), "hash": h, "tag": f"psd-hash:{h}",
+                         "w": a["w"], "h": a["h"]}
+
+
+def _error(code: str, message: str) -> int:
+    print(json.dumps({"error": {"code": code, "message": message}}, ensure_ascii=False))
+    return 2
+
+
+def _print_outline(result: dict, artboard_id: str) -> int:
+    view = outline(result, artboard_id)
+    if view is None:
+        return _error("artboard_not_found", f"no existe la mesa {artboard_id!r}")
+    print(json.dumps(view, ensure_ascii=False))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _parser()
+    args = parser.parse_args(argv)
+    if not args.psd.is_file():
+        parser.error(f"no existe el archivo: {args.psd}")
+    if args.psd.suffix.lower() == ".json":
+        if not args.artboard:
+            parser.error("con un extraction.json se necesita --artboard")
+        return _print_outline(json.loads(args.psd.read_text(encoding="utf-8")), args.artboard)
+    if args.out_dir is None:
+        parser.error("con un .psd se necesita --out-dir")
+    theme = [f.strip() for f in args.brand_fonts.split(",") if f.strip()]
+    try:
+        result = extract(args.psd.read_bytes(), theme_families=theme, profile=limits.local(), mode="local")
+    except GuardError as err:
+        return _error(err.code, str(err))
+    except Exception as err:  # noqa: BLE001 - el contrato del CLI es JSON + exit 2, no un traceback
+        return _error("extract_failed", f"{type(err).__name__}: {err}")
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    _write_assets(result, args.out_dir)
+    if not args.no_metrics:
+        from . import metrics
+
+        metrics.annotate(result, font_dirs=[*args.font_dir, *metrics.default_font_dirs()])
+    path = (args.out_dir / "extraction.json").resolve()
+    path.write_text(json.dumps(result, ensure_ascii=False, indent=1), encoding="utf-8")
+    if args.artboard:
+        return _print_outline(result, args.artboard)
+    print(json.dumps(summary(result, path, (args.out_dir / "assets").resolve()), ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

studio_psd_extract/color.py

@@ -0,0 +1,65 @@
+"""Conversión del color del documento (rgb|cmyk) a sRGB, para fondos y colores de texto.
+
+Un único transform por documento: el texto y los fondos quedan consistentes entre sí.
+"""
+from __future__ import annotations
+
+import io
+
+from PIL import Image, ImageCms
+
+
+def _clamp255(value: float) -> int:
+    return max(0, min(255, round(float(value) * 255)))
+
+
+class ColorConverter:
+    def __init__(self, icc: bytes | None, color_mode: str):
+        self.icc = icc
+        self.color_mode = color_mode
+        self._cmyk = None
+        self._cmyk_failed = False
+
+    def _cmyk_transform(self):
+        if self._cmyk is None and not self._cmyk_failed and self.icc:
+            try:
+                src = ImageCms.ImageCmsProfile(io.BytesIO(self.icc))
+                self._cmyk = ImageCms.buildTransform(src, ImageCms.createProfile("sRGB"), "CMYK", "RGB")
+            except (ImageCms.PyCMSError, OSError):
+                self._cmyk_failed = True
+        return self._cmyk
+
+    def image(self, img: Image.Image) -> tuple[Image.Image, list[dict]]:
+        """Imagen compuesta -> (RGBA sRGB, warnings)."""
+        if self.color_mode == "cmyk":
+            if img.mode != "CMYK":  # p. ej. el lienzo vacío de respaldo de raster._composite
+                return img.convert("RGBA"), []
+            if not self.icc:
+                return img.convert("RGB").convert("RGBA"), [{"code": "cmyk_no_icc"}]
+            transform = self._cmyk_transform()
+            if transform is None:
+                return img.convert("RGB").convert("RGBA"), [{"code": "icc_conversion_failed"}]
+            return ImageCms.applyTransform(img, transform).convert("RGBA"), []
+        img = img.convert("RGBA")
+        if not self.icc:
+            return img, [{"code": "icc_missing"}]
+        try:
+            src = ImageCms.ImageCmsProfile(io.BytesIO(self.icc))
+            return ImageCms.profileToProfile(img, src, ImageCms.createProfile("sRGB"), outputMode="RGBA"), []
+        except (ImageCms.PyCMSError, OSError):
+            return img, [{"code": "icc_conversion_failed"}]
+
+    def hex(self, values) -> str | None:
+        """`Values` de un FillColor del engine: [A,R,G,B] o [A,C,M,Y,K], floats 0..1 -> '#rrggbb'."""
+        try:
+            vals = [float(v) for v in values]
+        except (TypeError, ValueError):
+            return None
+        if len(vals) == 4:
+            return "#" + "".join(f"{_clamp255(c):02x}" for c in vals[1:])
+        if len(vals) == 5:
+            px = Image.new("CMYK", (1, 1), tuple(_clamp255(c) for c in vals[1:]))
+            transform = self._cmyk_transform()
+            rgb = (ImageCms.applyTransform(px, transform) if transform else px.convert("RGB")).getpixel((0, 0))
+            return "#" + "".join(f"{c:02x}" for c in rgb[:3])
+        return None

studio_psd_extract/compact.py

@@ -0,0 +1,111 @@
+"""Vistas compactas de la extracción (sin red): lo que ve el agente por defecto."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional
+
+PREVIEW_CHARS = 80
+
+
+def iter_nodes(nodes: List[Dict[str, Any]]) -> Iterator[Dict[str, Any]]:
+    """Recorre el árbol de capas en pre-orden."""
+    for n in nodes:
+        yield n
+        yield from iter_nodes(n.get("children") or [])
+
+
+def compact_text(result: Dict[str, Any], full_ids: Optional[set]) -> None:
+    """Reemplaza `text.runs` por {align, run_count, text_preview}, salvo en `full_ids` (None = todos)."""
+    for n in iter_nodes(result.get("layers") or []):
+        t = n.get("text")
+        if not isinstance(t, dict) or "runs" not in t:
+            continue
+        if full_ids is None or n.get("id") in full_ids:
+            continue
+        runs = t.get("runs") or []
+        joined = "".join(r.get("text", "") for r in runs)
+        n["text"] = {"align": t.get("align"), "run_count": len(runs),
+                     "text_preview": joined[:PREVIEW_CHARS]}
+
+
+MAX_SUSPECT_IN_SUMMARY = 30
+
+
+def _metrics_summary(nodes) -> Optional[Dict[str, Any]]:
+    suspect, missing, counts = [], {}, {"match": 0, "skipped": 0}
+    for n in nodes:
+        t = n.get("text")
+        m = t.get("metrics") if isinstance(t, dict) else None
+        if not m:
+            continue
+        run = (t.get("runs") or [{}])[0]
+        if m["status"] == "suspect":
+            suspect.append({"layer": n["id"], "name": n.get("name"), "font_ps_name": run.get("font_ps_name"),
+                            "text_preview": (run.get("text") or "")[:40], "width_ratio": m["width_ratio"],
+                            "tracking_needed_em": m["tracking_needed_em"]})
+        elif m["status"] == "font_not_installed":
+            ps = run.get("font_ps_name") or ""
+            missing[ps] = missing.get(ps, 0) + 1
+        else:
+            counts[m["status"]] += 1
+    if not (suspect or missing or counts["match"] or counts["skipped"]):
+        return None
+    return {"suspect": suspect[:MAX_SUSPECT_IN_SUMMARY], "suspect_total": len(suspect),
+            "font_not_installed": missing, **counts}
+
+
+ASSET_KEYS = ("filename", "size", "tag", "w", "h")  # local_path/hash/content_type quedan en extraction.json
+OUTLINE_PREVIEW_CHARS = 40
+
+
+def summary(result: Dict[str, Any], extraction_path: Path, assets_dir: Path) -> Dict[str, Any]:
+    """Resumen para stdout del CLI: todo menos el árbol de capas (ese queda en extraction.json)."""
+    nodes = list(iter_nodes(result.get("layers") or []))
+    text_nodes = [n for n in nodes if isinstance(n.get("text"), dict)]
+    warnings: Dict[str, int] = {}
+    for w in result.get("warnings") or []:
+        warnings[w.get("code")] = warnings.get(w.get("code"), 0) + 1
+    metrics_view = _metrics_summary(nodes)
+    out = {
+        "extraction_json": str(extraction_path),
+        "assets_dir": str(assets_dir),
+        "extractor": result.get("extractor"),
+        "document": result.get("document"),
+        "artboards": [{"id": a["id"], "name": a["name"], "w": a["rect"]["w"], "h": a["rect"]["h"]}
+                      for a in result.get("artboards") or []],
+        "counts": {"layers": len(nodes), "text_layers": len(text_nodes),
+                   "runs": sum(len(n["text"].get("runs") or []) for n in text_nodes)},
+        "fonts_used": result.get("fonts_used") or [],
+        "warnings": warnings,
+        "assets": [{"node": n["id"], **{k: n["asset"][k] for k in ASSET_KEYS if k in n["asset"]}}
+                   for n in nodes if isinstance(n.get("asset"), dict)],
+    }
+    if metrics_view is not None:
+        out["metrics"] = metrics_view
+    return out
+
+
+def outline(result: Dict[str, Any], artboard_id: str) -> Optional[Dict[str, Any]]:
+    """Capas de una mesa en pre-orden, compactas (medido: orden de 2-8 KB por mesa; la A1 de Indurama, ~7,8 KB). None si la mesa no existe."""
+    board = next((a for a in result.get("artboards") or [] if a.get("id") == artboard_id), None)
+    if board is None:
+        return None
+    rows: List[Dict[str, Any]] = []
+
+    def walk(nodes, depth):
+        for n in nodes:
+            if n.get("artboard") == artboard_id and n.get("kind") != "artboard":
+                bb = n.get("bbox")
+                row = {"id": n["id"], "name": n.get("name"), "kind": n.get("kind"), "depth": depth,
+                       "bbox": [bb["x"], bb["y"], bb["w"], bb["h"]] if isinstance(bb, dict) else bb}
+                t = n.get("text")
+                if isinstance(t, dict):
+                    joined = "".join(r.get("text", "") for r in t.get("runs") or []) or t.get("text_preview", "")
+                    row["text_preview"] = joined[:OUTLINE_PREVIEW_CHARS]
+                    if t.get("metrics"):
+                        row["metrics"] = t["metrics"]["status"]
+                rows.append(row)
+            walk(n.get("children") or [], depth + 1)
+
+    walk(result.get("layers") or [], 0)
+    return {"artboard": {"id": board["id"], "name": board.get("name"), "rect": board.get("rect")}, "nodes": rows}

studio_psd_extract/fonts.py

@@ -0,0 +1,53 @@
+"""Resolución de nombres PostScript a family/weight/italic y disponibilidad."""
+import re
+
+from .builtin_fonts import BUILTIN_FONTS
+
+_WEIGHTS = {
+    "thin": 100, "hairline": 100,
+    "extralight": 200, "ultralight": 200,
+    "light": 300,
+    "regular": 400, "normal": 400, "book": 400, "roman": 400,
+    "medium": 500,
+    "semibold": 600, "demibold": 600, "demi": 600,
+    "bold": 700,
+    "extrabold": 800, "ultrabold": 800, "heavy": 800,
+    "black": 900,
+}
+_ITALIC = {"italic", "it", "oblique", "ital"}
+
+
+def _split_camel(s: str) -> str:
+    # "OpenSans" -> "Open Sans"; "PlusJakartaSans" -> "Plus Jakarta Sans"
+    return re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", s)
+
+
+def _style_tokens(style: str) -> list[str]:
+    return [t.lower() for t in re.findall(r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])", style)]
+
+
+def resolve(ps_name: str, theme_families: set[str]) -> dict:
+    base, _, style = (ps_name or "").partition("-")
+    family = _split_camel(base).strip()
+    weight, italic = 400, False
+    # Une tokens: "SemiBold", "BoldItalic", "Semi"+"Bold" -> comparar por concatenación.
+    tokens = _style_tokens(style)
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if i + 1 < len(tokens) and tok + tokens[i + 1] in _WEIGHTS:
+            weight = _WEIGHTS[tok + tokens[i + 1]]
+            i += 1
+        elif tok in _ITALIC:
+            italic = True
+        elif tok in _WEIGHTS:
+            weight = _WEIGHTS[tok]
+        i += 1
+
+    fam_l = family.lower()
+    available = None
+    if any(fam_l == b.lower() for b in BUILTIN_FONTS):
+        available = "builtin"
+    elif any(fam_l == t.lower() for t in theme_families):
+        available = "theme"
+    return {"family": family, "weight": weight, "italic": italic, "available": available}

studio_psd_extract/guard.py

@@ -0,0 +1,25 @@
+import struct
+from . import limits
+
+class GuardError(Exception):
+    def __init__(self, code: str, message: str):
+        super().__init__(message)
+        self.code = code
+
+def check_header(psd_bytes: bytes, profile: "limits.Profile | None" = None) -> dict:
+    p = profile or limits.server()
+    if len(psd_bytes) > p.max_bytes:
+        raise GuardError("psd_too_large", f"PSD supera {p.max_bytes} bytes")
+    if len(psd_bytes) < 26 or psd_bytes[:4] != b"8BPS":
+        raise GuardError("invalid_psd", "firma 8BPS ausente")
+    sig, ver, _res, channels, height, width, depth, mode = struct.unpack(">4sH6sHIIHH", psd_bytes[:26])
+    if ver != 1:
+        raise GuardError("psd_unsupported_mode", "PSB (version 2) no soportado en P0")
+    color_mode = limits._COLOR_MODES.get(mode, str(mode))
+    if color_mode not in ("rgb", "cmyk"):
+        raise GuardError("psd_unsupported_mode", f"color mode {color_mode} no soportado (solo RGB y CMYK)")
+    if depth > 16:
+        raise GuardError("psd_unsupported_mode", f"depth {depth} > 16 no soportado")
+    if width * height > p.max_canvas_pixels:
+        raise GuardError("psd_too_large", f"canvas {width}x{height} supera {p.max_canvas_pixels}px")
+    return {"width": width, "height": height, "color_mode": color_mode, "depth": depth, "n_layers": 0}

studio_psd_extract/layers.py

@@ -0,0 +1,73 @@
+"""Árbol de capas de un PSDImage de psd-tools."""
+from __future__ import annotations
+
+from . import model
+
+
+_EMPTY = {"x": 0, "y": 0, "w": 0, "h": 0}
+
+
+def _safe_bbox(layer) -> dict:
+    try:
+        return model.bbox_dict(layer.bbox)
+    except ValueError:  # p.ej. Artboard sin artboardRect
+        return dict(_EMPTY)
+
+
+def _artboard_by_center(bbox: dict, artboards: list[dict]):
+    if bbox["w"] <= 0 or bbox["h"] <= 0:
+        return None
+    cx = bbox["x"] + bbox["w"] / 2
+    cy = bbox["y"] + bbox["h"] / 2
+    for a in artboards:
+        r = a["rect"]
+        if r["x"] <= cx < r["x"] + r["w"] and r["y"] <= cy < r["y"] + r["h"]:
+            return a["id"]
+    return None
+
+
+def walk(psd, artboards: list[dict]) -> list[dict]:
+    """Nodos {id,name,kind,artboard,bbox,visible,opacity,clipping,mask,effects,children}.
+
+    `artboard`: hijos directos de una mesa heredan su id; el resto, la mesa que contiene
+    el centro de su propio bbox (bbox vacío o fuera de toda mesa -> None).
+    """
+    counter = [0]
+    unused = list(artboards)
+
+    def resolve_board(layer, bbox):
+        """Id de la mesa que `detect` devolvió para esta capa (por name+rect), o None."""
+        for a in unused:
+            if a["name"] == layer.name and a["rect"] == bbox:
+                unused.remove(a)
+                return a["id"]
+        return None
+
+    def node(layer, inherited, parent_is_artboard):
+        counter[0] += 1
+        kind = model.map_kind(layer)
+        bbox = _safe_bbox(layer)
+        if kind == "artboard":
+            board = resolve_board(layer, bbox)  # None si detect la omitió
+        elif parent_is_artboard:
+            board = inherited
+        else:
+            board = _artboard_by_center(bbox, artboards)
+        children = []
+        if layer.is_group():
+            children = [node(c, board, kind == "artboard") for c in layer]
+        return {
+            "id": f"L{counter[0]}",
+            "name": layer.name,
+            "kind": kind,
+            "artboard": board,
+            "bbox": bbox,
+            "visible": layer.is_visible(),
+            "opacity": model.opacity_unit(layer.opacity),
+            "clipping": bool(layer.clipping),
+            "mask": layer.mask is not None,
+            "effects": model.effect_names(layer),
+            "children": children,
+        }
+
+    return [node(l, None, False) for l in psd]

studio_psd_extract/limits.py

@@ -0,0 +1,36 @@
+MAX_BYTES = 64 * 1024 * 1024
+MAX_CANVAS_PIXELS = 40_000_000
+MAX_LAYER_PIXELS = 40_000_000
+MAX_LAYERS = 2000
+MAX_DEPTH = 20
+EXTRACT_TIMEOUT_S = 40
+RLIMIT_AS_BYTES = 2 * 1024 ** 3
+MAX_ASSETS = 12
+UPLOAD_CONCURRENCY = 4
+TOOL_DEADLINE_S = 45
+_COLOR_MODES = {1: "grayscale", 3: "rgb", 4: "cmyk", 9: "lab"}
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Profile:
+    max_bytes: int
+    max_canvas_pixels: int
+    max_layer_pixels: int
+    max_layers: int
+
+
+LOCAL_MAX_BYTES = 1024 ** 3
+LOCAL_MAX_CANVAS_PIXELS = 300_000_000
+LOCAL_MAX_LAYER_PIXELS = 300_000_000
+LOCAL_MAX_LAYERS = 10_000
+
+
+def server() -> Profile:
+    """Perfil del contenedor compartido. Se arma en cada llamada (los tests parchean las constantes)."""
+    return Profile(MAX_BYTES, MAX_CANVAS_PIXELS, MAX_LAYER_PIXELS, MAX_LAYERS)
+
+
+def local() -> Profile:
+    """Perfil del CLI: la máquina es de la persona y el archivo es suyo; sin contenedor que proteger."""
+    return Profile(LOCAL_MAX_BYTES, LOCAL_MAX_CANVAS_PIXELS, LOCAL_MAX_LAYER_PIXELS, LOCAL_MAX_LAYERS)

studio_psd_extract/metrics.py

@@ -0,0 +1,234 @@
+"""`substituted`: detecta si Photoshop dibujó una capa con una fuente distinta de la declarada.
+
+La caja de la capa de texto (`bbox`) es la tinta que Photoshop rasterizó con la fuente que usó de
+verdad. Se compara con el ancho de tinta predicho con la fuente declarada (fontTools: avances `hmtx`
++ `kern` clásico + tracking). Solo local: el servidor no tiene los archivos de fuente. fontTools se
+importa al usar estas funciones, no al importar el paquete.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .compact import iter_nodes
+
+MATCH_TOLERANCE = 0.04
+INVALID_FONT = "AdobeInvalidFont"
+FONT_SUFFIXES = {".ttf", ".otf", ".ttc", ".otc"}
+LINE_BREAKS = ("\r", "\n", "\x03")
+
+
+def default_font_dirs() -> list[Path]:
+    home = Path.home()
+    dirs = [
+        home / "Library" / "Fonts",
+        Path("/Library/Fonts"),
+        Path("/System/Library/Fonts"),
+        home / "Library" / "Application Support" / "Adobe" / "CoreSync" / "plugins" / "livetype" / ".r",
+        home / ".fonts",
+        home / ".local" / "share" / "fonts",
+        Path("/usr/share/fonts"),
+    ]
+    if os.environ.get("WINDIR"):
+        dirs.append(Path(os.environ["WINDIR"]) / "Fonts")
+    if os.environ.get("LOCALAPPDATA"):
+        dirs.append(Path(os.environ["LOCALAPPDATA"]) / "Microsoft" / "Windows" / "Fonts")
+    return dirs
+
+
+def _index_font(index: dict, font, path: str, number: int) -> None:
+    """Registra el nombre PostScript principal y, si es variable, el de cada instancia con nombre."""
+    name = font["name"]
+    ps = name.getDebugName(6)
+    if ps:
+        index.setdefault(ps, (path, number, None))
+    if "fvar" in font:
+        for inst in font["fvar"].instances:
+            if inst.postscriptNameID in (None, 0xFFFF):
+                continue
+            ips = name.getDebugName(inst.postscriptNameID)
+            if ips:
+                index.setdefault(ips, (path, number, dict(inst.coordinates)))
+
+
+def _open_font(path: str, number: int, coords: dict | None):
+    """Abre la fuente; si `coords` viene, la instancia en esas coordenadas (fuente variable)."""
+    from fontTools.ttLib import TTFont
+
+    if not coords:
+        return TTFont(path, fontNumber=number, lazy=True)
+    from fontTools.varLib.instancer import instantiateVariableFont
+
+    return instantiateVariableFont(TTFont(path, fontNumber=number), coords, inplace=True)
+
+
+def index_fonts(dirs) -> dict[str, tuple[str, int, dict | None]]:
+    """Nombre PostScript -> (ruta, índice en la colección, coords de instancia variable o None). Cierra cada archivo."""
+    from fontTools.ttLib import TTCollection, TTFont
+
+    index: dict[str, tuple[str, int, dict | None]] = {}
+    for d in dirs:
+        if not Path(d).is_dir():
+            continue
+        for root, _subdirs, files in os.walk(d):
+            for name in files:
+                path = Path(root) / name
+                suffix = path.suffix.lower()
+                if suffix not in FONT_SUFFIXES:
+                    continue
+                try:
+                    if suffix in (".ttc", ".otc"):
+                        coll = TTCollection(str(path), lazy=True)
+                        try:
+                            for i, font in enumerate(coll.fonts):
+                                _index_font(index, font, str(path), i)
+                        finally:
+                            coll.close()
+                    else:
+                        font = TTFont(str(path), lazy=True)
+                        try:
+                            _index_font(index, font, str(path), 0)
+                        finally:
+                            font.close()
+                except Exception:  # noqa: BLE001 - un archivo roto no corta el índice
+                    continue
+    return index
+
+
+def predicted_ink_width(font, text: str, size_px: float) -> tuple[float, int] | None:
+    """(ancho de tinta sin tracking en px, cantidad de huecos entre glifos), o None si falta un glifo."""
+    from fontTools.pens.boundsPen import BoundsPen
+
+    cmap = font.getBestCmap() or {}
+    names = [cmap.get(ord(ch)) for ch in text]
+    if not names or None in names:
+        return None
+    hmtx = font["hmtx"]
+    kern: dict = {}
+    if "kern" in font:
+        for sub in getattr(font["kern"], "kernTables", None) or []:
+            kern.update(getattr(sub, "kernTable", None) or {})
+    glyphs = font.getGlyphSet()
+
+    def bounds(glyph):
+        pen = BoundsPen(glyphs)
+        glyphs[glyph].draw(pen)
+        return pen.bounds
+
+    x, positions = 0, []
+    for i, g in enumerate(names):
+        positions.append(x)
+        x += hmtx[g][0] + (kern.get((g, names[i + 1]), 0) if i + 1 < len(names) else 0)
+    first, last = bounds(names[0]), bounds(names[-1])
+    if first is None or last is None:
+        return None
+    units = positions[-1] + last[2] - (positions[0] + first[0])
+    return round(units * size_px / font["head"].unitsPerEm, 4), len(names) - 1
+
+
+def merge_runs(runs: list[dict]) -> dict | None:
+    """Une runs con la misma fuente, tamaño, caps y escala (Photoshop los parte por tracking por letra).
+
+    El tracking resultante se pondera por caracteres. None si algún run difiere en esas claves.
+    """
+    if not runs:
+        return None
+    keys = ("font_ps_name", "size_px", "caps", "h_scale")
+    first = runs[0]
+    if any(tuple(r.get(k) for k in keys) != tuple(first.get(k) for k in keys) for r in runs[1:]):
+        return None
+    lengths = [len(r.get("text") or "") for r in runs]
+    total = sum(lengths)
+    tracking = (sum(float(r.get("tracking_em") or 0.0) * n for r, n in zip(runs, lengths)) / total) if total else 0.0
+    return {**first, "text": "".join(r.get("text") or "" for r in runs), "tracking_em": round(tracking, 6)}
+
+
+def _metric(status, *, ratio=None, needed=None, font_file=None, reason=None) -> dict:
+    return {"status": status, "width_ratio": ratio, "tracking_needed_em": needed,
+            "font_file": font_file, "reason": reason}
+
+
+def annotate(result: dict, *, font_dirs) -> None:
+    """Escribe `text.metrics` en cada capa de texto y `suspect_runs` en `fonts_used`."""
+    complex_ids = {w.get("layer") for w in result.get("warnings") or []
+                   if w.get("code") == "text_transform_complex"}
+    index = None
+    opened: dict[tuple, object] = {}
+    suspects: dict[str, int] = {}
+    try:
+        for node in iter_nodes(result.get("layers") or []):
+            t = node.get("text")
+            if not isinstance(t, dict) or "runs" not in t:
+                continue
+            runs = t.get("runs") or []
+            joined = "".join(r.get("text", "") for r in runs).strip()
+            if not joined:
+                t["metrics"] = _metric("skipped", reason="empty")
+                continue
+            run = merge_runs(runs)
+            if run is None:
+                t["metrics"] = _metric("skipped", reason="multi_run")
+                continue
+            if t.get("shape") == "area":  # caja con ajuste automático: la tinta abarca varias líneas
+                t["metrics"] = _metric("skipped", reason="area_text")
+                continue
+            line_h = float(run.get("line_height_px") or 0)
+            if t.get("shape") is None and line_h > 0 and float((node.get("bbox") or {}).get("h") or 0) > 1.5 * line_h:
+                t["metrics"] = _metric("skipped", reason="multiline")
+                continue
+            if run.get("caps") == "small":
+                t["metrics"] = _metric("skipped", reason="small_caps")
+                continue
+            text = (run.get("text") or "").strip()
+            if run.get("caps") == "all":
+                text = text.upper()
+            if any(b in text for b in LINE_BREAKS):
+                t["metrics"] = _metric("skipped", reason="multiline")
+                continue
+            if node.get("id") in complex_ids:
+                t["metrics"] = _metric("skipped", reason="transform_complex")
+                continue
+            ps = run.get("font_ps_name") or ""
+            if ps == INVALID_FONT:
+                t["metrics"] = _metric("font_not_installed")
+                continue
+            if index is None:
+                index = index_fonts(font_dirs)
+            entry = index.get(ps)
+            if entry is None:
+                t["metrics"] = _metric("font_not_installed")
+                continue
+            font_file = Path(entry[0]).name
+            try:
+                key = (entry[0], entry[1], tuple(sorted(entry[2].items())) if entry[2] else None)
+                if key not in opened:
+                    opened[key] = _open_font(*entry)
+                size = float(run.get("size_px") or 0)
+                pred = predicted_ink_width(opened[key], text, size) if size > 0 else None
+            except Exception:  # noqa: BLE001 - una capa con fuente rara no corta el resto
+                t["metrics"] = _metric("skipped", font_file=font_file, reason="metrics_error")
+                continue
+            if pred is None:
+                t["metrics"] = _metric("skipped", font_file=font_file, reason="glyph_missing")
+                continue
+            base, gaps = pred
+            base *= float(run.get("h_scale") or 1.0)  # escala horizontal: afecta glifos y avances
+            tracking = float(run.get("tracking_em") or 0.0)
+            predicted = base + tracking * size * gaps
+            observed = float((node.get("bbox") or {}).get("w") or 0)
+            if predicted <= 0 or observed <= 0:
+                t["metrics"] = _metric("skipped", font_file=font_file, reason="empty")
+                continue
+            ratio = observed / predicted
+            needed = round((observed - base) / (size * gaps), 4) if gaps else None
+            tolerance = max(MATCH_TOLERANCE, 2.0 / observed)  # ±2 px de antialias en etiquetas chicas
+            status = "match" if abs(ratio - 1) <= tolerance else "suspect"
+            t["metrics"] = _metric(status, ratio=round(ratio, 4), needed=needed, font_file=font_file)
+            if status == "suspect":
+                fam = run.get("family") or ""
+                suspects[fam] = suspects.get(fam, 0) + 1
+    finally:
+        for font in opened.values():
+            font.close()
+    for f in result.get("fonts_used") or []:
+        f["suspect_runs"] = suspects.get(f.get("family"), 0)

studio_psd_extract/model.py

@@ -0,0 +1,41 @@
+"""Helpers puros (sin importar psd-tools) para mapear capas a nuestro modelo."""
+from __future__ import annotations
+
+# Orden importa: Artboard hereda de Group; los subtipos de ajuste/relleno
+# heredan de AdjustmentLayer/FillLayer.
+_BY_CLASS = (
+    ("Artboard", "artboard"),
+    ("Group", "group"),
+    ("TypeLayer", "text"),
+    ("SmartObjectLayer", "smartobject"),
+    ("ShapeLayer", "shape"),
+    ("AdjustmentLayer", "adjustment"),
+    ("FillLayer", "fill"),
+    ("PixelLayer", "pixel"),
+)
+
+
+def map_kind(layer) -> str:
+    names = {c.__name__ for c in type(layer).__mro__}
+    for cls, kind in _BY_CLASS:
+        if cls in names:
+            return kind
+    return "pixel"
+
+
+def bbox_dict(bbox) -> dict:
+    """(left, top, right, bottom) -> {x, y, w, h} en coords de documento."""
+    left, top, right, bottom = bbox
+    return {"x": left, "y": top, "w": right - left, "h": bottom - top}
+
+
+def opacity_unit(opacity: int) -> float:
+    """psd-tools da 0-255; exponemos 0..1."""
+    return round(opacity / 255, 4)
+
+
+def effect_names(layer) -> list[str]:
+    effects = layer.effects
+    if not layer.has_effects() or not effects.enabled:
+        return []
+    return [e.__class__.__name__ for e in effects]

studio_psd_extract/raster.py

@@ -0,0 +1,143 @@
+"""Rasteriza una mesa SIN capas de texto (el texto se re-emite como bloques)."""
+from __future__ import annotations
+
+import hashlib
+import io
+
+from PIL import Image
+
+from .model import bbox_dict, effect_names
+
+
+def _keep(layer) -> bool:
+    return layer.is_visible() and layer.kind != "type"
+
+
+def _icc_profile(psd):
+    from psd_tools.constants import Resource
+    data = psd.image_resources.get_data(Resource.ICC_PROFILE)
+    return data or None
+
+
+def _color_mode(psd) -> str:
+    return getattr(getattr(psd, "color_mode", None), "name", "rgb").lower()
+
+
+def _in_rect(layer, rect) -> bool:
+    try:
+        b = bbox_dict(layer.bbox)
+    except Exception:
+        return False
+    if b["w"] <= 0 or b["h"] <= 0:
+        return False
+    cx, cy = b["x"] + b["w"] / 2, b["y"] + b["h"] / 2
+    return rect["x"] <= cx < rect["x"] + rect["w"] and rect["y"] <= cy < rect["y"] + rect["h"]
+
+
+def _scope(psd, rect):
+    """Capas de la mesa: descendientes del Artboard con ese rect; si no hay
+    (A0 = canvas), todo el documento."""
+    for layer in psd.descendants():
+        if layer.kind == "artboard":
+            try:
+                if bbox_dict(layer.bbox) == rect:
+                    return layer.descendants()
+            except ValueError:
+                continue
+    return psd.descendants()
+
+
+def _warnings(psd, rect) -> list[dict]:
+    out = []
+    for layer in _scope(psd, rect):
+        if not layer.is_visible() or layer.kind in ("group", "artboard"):
+            continue
+        feats = []
+        if effect_names(layer):
+            feats.append("effects")
+        if layer.kind == "adjustment":
+            feats.append("adjustment")
+        if layer.kind == "smartobject":
+            so = getattr(layer, "smart_object", None)
+            if so is not None and getattr(so, "kind", None) == "external":
+                feats.append("smartobject_linked")
+        if not feats:
+            continue
+        if layer.kind != "adjustment" and not _in_rect(layer, rect):
+            continue
+        for f in feats:
+            out.append({"code": "unsupported_feature", "feature": f, "layer": layer.name})
+    return out
+
+
+def _has_stroke(layer) -> bool:
+    """Stroke vectorial (aggdraw) o efecto Stroke (scipy)."""
+    try:
+        if getattr(layer, "has_stroke", None) and layer.has_stroke():
+            return True
+    except Exception:
+        pass
+    try:
+        return "Stroke" in effect_names(layer)
+    except Exception:
+        return False
+
+
+def _needs_extras(layer) -> bool:
+    """Capas que en psd-tools piden scipy/aggdraw (no incluidos): ajustes,
+    rellenos de gradiente y cualquier efecto."""
+    try:
+        return layer.kind in ("adjustment", "gradientfill") or bool(effect_names(layer))
+    except Exception:
+        return False
+
+
+def _composite(psd, viewport, rect, warnings):
+    """composite() tolerante a ImportError (aggdraw/scipy ausentes): omite las
+    capas afectadas con warning; nunca propaga el ImportError."""
+    def run(flt):
+        return psd.composite(viewport=viewport, force=True, layer_filter=flt, apply_icc=False)
+    try:
+        return run(_keep)
+    except ImportError:
+        pass
+    scope = [l for l in _scope(psd, rect) if l.is_visible() and l.kind not in ("group", "artboard")]
+    skip = {id(l) for l in scope if _has_stroke(l)}
+    for l in scope:
+        if id(l) in skip:
+            warnings.append({"code": "unsupported_feature", "feature": "stroke", "layer": l.name})
+    try:
+        return run(lambda l: _keep(l) and id(l) not in skip)
+    except ImportError:
+        pass
+    skip2 = skip | {id(l) for l in scope if _needs_extras(l)}
+    for l in scope:
+        if id(l) in skip2 - skip:
+            warnings.append({"code": "unsupported_feature", "feature": "composite_dependency", "layer": l.name})
+    try:
+        return run(lambda l: _keep(l) and id(l) not in skip2)
+    except ImportError:
+        warnings.append({"code": "unsupported_feature", "feature": "composite_dependency", "layer": None})
+        return Image.new("RGBA", (viewport[2] - viewport[0], viewport[3] - viewport[1]), (0, 0, 0, 0))
+
+
+def artboard_background(psd, artboard: dict, converter=None) -> dict:
+    from .color import ColorConverter
+
+    r = artboard["rect"]
+    viewport = (r["x"], r["y"], r["x"] + r["w"], r["y"] + r["h"])
+    warnings: list[dict] = []
+    if converter is None:
+        converter = ColorConverter(_icc_profile(psd), _color_mode(psd))
+    img, color_warnings = converter.image(_composite(psd, viewport, r, warnings))
+    warnings.extend(color_warnings)
+    warnings.extend(_warnings(psd, r))
+    buf = io.BytesIO()
+    img.save(buf, "PNG")
+    return {
+        "png": buf.getvalue(),
+        "w": img.width,
+        "h": img.height,
+        "rgba_hash": hashlib.sha256(img.convert("RGBA").tobytes()).hexdigest(),
+        "warnings": warnings,
+    }

studio_psd_extract/text.py

@@ -0,0 +1,138 @@
+"""Runs de texto de una capa tipo (psd-tools TypeLayer.engine_dict / resource_dict)."""
+from . import fonts as _fonts
+from .color import ColorConverter
+
+_CAPS = {0: "none", 1: "small", 2: "all"}
+_ALIGN = {0: "left", 1: "right", 2: "center"}  # 3..6 = justify*
+
+
+def _val(v, default=None):
+    """Desenvuelve elementos de engine_data (Integer/Float/String/Bool) a Python."""
+    if v is None:
+        return default
+    return getattr(v, "value", v)
+
+
+def _get(d, key):
+    try:
+        return d.get(key) if d else None
+    except AttributeError:
+        return None
+
+
+def _seq(v):
+    try:
+        return list(v) if v else []
+    except TypeError:
+        return []
+
+
+def _style_get(data, default, key):
+    for src in (data, default):
+        v = _get(src, key)
+        if v is not None:
+            return v
+    return None
+
+
+def _default_sheet(resource):
+    sets = _seq(_get(resource, "StyleSheetSet"))
+    idx = _val(_get(resource, "TheNormalStyleSheet"))
+    try:
+        return _get(sets[int(idx)], "StyleSheetData")
+    except (TypeError, ValueError, IndexError):
+        return None
+
+
+_DEFAULT_HEX = ColorConverter(None, "rgb").hex
+
+
+def _color(fill, to_hex):
+    return to_hex([_val(x) for x in _seq(_get(fill, "Values"))])
+
+
+def _align(engine, resource):
+    arr = _seq(_get(_get(engine, "ParagraphRun"), "RunArray"))
+    props = _get(_get(arr[0], "ParagraphSheet"), "Properties") if arr else None
+    j = _val(_get(props, "Justification"))
+    if j is None:
+        sets = _seq(_get(resource, "ParagraphSheetSet"))
+        try:
+            props = _get(sets[int(_val(_get(resource, "TheNormalParagraphSheet")))], "Properties")
+            j = _val(_get(props, "Justification"))
+        except (TypeError, ValueError, IndexError):
+            j = None
+    if j is None:
+        return "left"
+    try:
+        j = int(j)
+    except (TypeError, ValueError):
+        return "left"
+    return _ALIGN.get(j, "justify")
+
+
+def _shape(layer):
+    """'point' | 'area' (caja con ajuste de línea automático) | None si psd-tools no lo determina."""
+    try:
+        kind = layer.text_type
+    except Exception:  # noqa: BLE001 - psd-tools lanza ValueError si no puede determinarlo
+        return None
+    name = getattr(kind, "name", None)
+    return {"POINT": "point", "PARAGRAPH": "area"}.get(name)
+
+
+def runs(layer, transform_scale: float, theme_families=None, to_hex=None) -> dict:
+    to_hex = to_hex or _DEFAULT_HEX
+    engine = layer.engine_dict
+    resource = layer.resource_dict
+    text = layer.text or ""
+    fontset = _seq(_get(resource, "FontSet"))
+    default = _default_sheet(resource)
+
+    style_run = _get(engine, "StyleRun")
+    lengths = [int(_val(x, 0)) for x in _seq(_get(style_run, "RunLengthArray"))]
+    arr = _seq(_get(style_run, "RunArray"))
+    if not lengths:
+        lengths = [len(text)]
+
+    out, pos = [], 0
+    for i, n in enumerate(lengths):
+        if pos >= len(text) and out:
+            break
+        chunk = text[pos:pos + n]
+        pos += n
+        data = _get(_get(arr[i], "StyleSheet"), "StyleSheetData") if i < len(arr) else None
+
+        try:
+            ps_name = str(_val(_get(fontset[int(_val(_style_get(data, default, "Font")))], "Name"), ""))
+        except (TypeError, ValueError, IndexError):
+            ps_name = ""
+        f = _fonts.resolve(ps_name, theme_families or set())
+        size = float(_val(_style_get(data, default, "FontSize"), 12.0))
+        if _val(_style_get(data, default, "FauxBold"), False) and f["weight"] < 700:
+            f["weight"] = 700
+        if _val(_style_get(data, default, "FauxItalic"), False):
+            f["italic"] = True
+        auto = bool(_val(_style_get(data, default, "AutoLeading"), True))
+        leading = _val(_style_get(data, default, "Leading"))
+        if auto or leading is None:
+            line_h, derived = size * 1.2, True
+        else:
+            line_h, derived = float(leading), False
+
+        out.append({
+            "text": chunk,
+            "font_ps_name": ps_name,
+            "family": f["family"],
+            "weight": f["weight"],
+            "italic": f["italic"],
+            "font_available": f["available"],
+            "size_px": size * transform_scale,
+            "color": _color(_style_get(data, default, "FillColor"), to_hex),
+            "tracking_em": float(_val(_style_get(data, default, "Tracking"), 0)) / 1000.0,
+            "line_height_px": line_h * transform_scale,
+            "line_height_derived": derived,
+            "caps": _CAPS.get(int(_val(_style_get(data, default, "FontCaps"), 0) or 0), "none"),
+            "h_scale": float(_val(_style_get(data, default, "HorizontalScale"), 1.0) or 1.0),
+        })
+    return {"align": _align(engine, resource), "shape": _shape(layer), "runs": out}

studio_psd_extract-0.2.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: studio-psd-extract
+Version: 0.2.0
+Summary: Extrae mesas, capas, texto e imágenes de un PSD al contrato JSON de Omnitok Studio.
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psd-tools<1.26,>=1.25
+Requires-Dist: Pillow>=11
+Requires-Dist: fonttools>=4.50
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Dynamic: license-file
+
+# studio-psd-extract
+
+Extrae de un PSD las mesas, el árbol de capas, los runs de texto y los fondos rasterizados
+(sin capas de texto) al contrato JSON v1 de Omnitok Studio. Es el mismo extractor que usa la
+tool `studio_extract_psd` del MCP de Studio.
+
+## Desarrollo
+
+Desde la raíz del repo `omnitok-studio-mcp`:
+
+    uv pip install --python .venv/bin/python -e packages/studio-psd-extract --no-deps
+    PYTHONPATH=. .venv/bin/python -m pytest -q packages/studio-psd-extract/tests
+
+Fixtures: `python tests/fixtures/make_fixtures.py` (dentro del paquete) regenera los PSD de prueba.
+
+## Uso
+
+    uvx studio-psd-extract <archivo.psd> --out-dir <carpeta> [--brand-fonts "Fam A,Fam B"] [--font-dir <carpeta> ...] [--no-metrics]
+    uvx studio-psd-extract <carpeta>/extraction.json --artboard A3
+
+Escribe `<carpeta>/extraction.json` (contrato completo) y `<carpeta>/assets/psd-<hash12>.png`, e
+imprime en stdout un resumen compacto (mesas, fuentes, warnings, `assets_dir` y assets). Con
+`--artboard` imprime el outline compacto de esa mesa (ids, tipos, bbox, texto). Exit 0 = ok; 2 = error
+(`{"error": {"code", "message"}}`). Límites locales: 1 GB, 300 MP; PSB y Lab no soportados.
+
+Métrica de fuente sustituta: en capas de una línea (runs de la misma fuente y tamaño se unen) compara el ancho de tinta del PSD
+con el de la fuente declarada instalada en este equipo (carpetas del sistema, Adobe Fonts y
+`--font-dir`). `metrics.status`: `match` (±4 %, o ±2 px en textos chicos), `suspect` (Photoshop probablemente dibujó otra
+fuente; `tracking_needed_em` es el tracking que haría calzar), `font_not_installed` o `skipped` (con `reason`: `multiline`, `area_text`, `multi_run`, `transform_complex`, `empty`, `glyph_missing`, `small_caps`, `metrics_error`).
+
+## Publicación
+
+Solo con un tag `psd-v<versión>` que coincida con `version` del `pyproject.toml`; el workflow
+`publish-psd-extract` corre los tests, construye y publica en PyPI con trusted publishing.
+
+## Licencia
+
+Propietaria: todos los derechos reservados (ver `LICENSE`).

studio_psd_extract-0.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+studio_psd_extract/__init__.py,sha256=8K6Hj4PhWaiVcZ8QdpFmlGwm4l1ELzKSeYIPwwtu75M,6064
+studio_psd_extract/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+studio_psd_extract/artboards.py,sha256=397BBTRXBayoLeQWO0IRlDOEkMHP3y_WSIYGwGBfFqY,799
+studio_psd_extract/builtin_fonts.py,sha256=QAefAtCgKzJGjvtDLN6OKZB7XBqfleoPMoSTfly0JEM,366
+studio_psd_extract/cli.py,sha256=-JjOzUmIIRvx9figlQVBSVouTxrlYKJwZjKa-Q1Y4u8,4082
+studio_psd_extract/color.py,sha256=NjiLArV3Tn0UVYDpGdJJUUdnRmX4_o0Fu7LLVhOyeV4,2772
+studio_psd_extract/compact.py,sha256=yvPbDKbR3nb9Zv8A3jsQGqXrdR0O5DKsR7Kmva1INZ0,5073
+studio_psd_extract/fonts.py,sha256=B9432V1VWBuLjesgt0SsnUXDXFJylKvjghOGL0aryr4,1756
+studio_psd_extract/guard.py,sha256=81dzYGVdnrgnaFhxbg-kLW5gS09_1kQw-xxT3AsuvXI,1295
+studio_psd_extract/layers.py,sha256=OzN7exSqxDTxCx8EMnzqMgTpsb2oRZEQTVttLBiz-zk,2361
+studio_psd_extract/limits.py,sha256=EtdUAewu5GYbC2OKuAQT6fU1XgU2gUMBwvx8JBhcXjQ,1045
+studio_psd_extract/metrics.py,sha256=3Od246ZGC05W4hXembn7aMOqOLnnwCyIGY4LWG8wv8c,10261
+studio_psd_extract/model.py,sha256=mIk6gk_Q5mXrtdptSRddPsCuYK3nXqSVLstu_FormTE,1208
+studio_psd_extract/raster.py,sha256=1jDAn_mYKRp2KBBHF9zbqHyCg5SZ3-f-pYvUGvsunoU,4827
+studio_psd_extract/text.py,sha256=WXwOih_BW6cQpzSI6LM_znTlcjBngZ9bQ2yfyMSBUls,4737
+studio_psd_extract-0.2.0.dist-info/licenses/LICENSE,sha256=xHqT7gAMSOBQIRkqlvinPa34PrZB8KrA_TL6PmG_9mI,358
+studio_psd_extract-0.2.0.dist-info/METADATA,sha256=jBghoh5-6ntuTG1PQoWW-xPD2BdQtnoUUcbJAypzOlI,2503
+studio_psd_extract-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+studio_psd_extract-0.2.0.dist-info/entry_points.txt,sha256=qNzcCYXQI2MtCiUacBhfG-g726ZFvzKMKcn6HAEDuyQ,67
+studio_psd_extract-0.2.0.dist-info/top_level.txt,sha256=I-xrNPxdUL39I4Z78b4kem31LSE0s6gO9UYvy_0u1cQ,19
+studio_psd_extract-0.2.0.dist-info/RECORD,,

studio_psd_extract-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

studio_psd_extract-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+studio-psd-extract = studio_psd_extract.cli:main

studio_psd_extract-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) 2026 Omnitok. Todos los derechos reservados.
+
+Este software es propietario. Se publica en PyPI solo para que el equipo y las
+personas autorizadas por Omnitok puedan instalarlo y ejecutarlo junto con Omnitok
+Studio. No se otorga permiso para copiarlo, modificarlo, redistribuirlo ni usarlo
+fuera de ese fin sin autorización escrita de Omnitok.

studio_psd_extract-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+studio_psd_extract