sldprt2xt 1.1.0__py3-none-any.whl

sldprt2xt/__init__.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 Emilien-Etadam
+
+"""Extraire la géométrie Parasolid d'un fichier SolidWorks, sans SolidWorks.
+
+    from sldprt2xt import to_x_t
+
+    to_x_t("piece.SLDPRT")                 # écrit piece.x_t à côté
+    to_x_t("piece.SLDPRT", "sorties/")     # ailleurs
+"""
+
+from .convert import ConversionError, bodies_in, to_x_t
+from .schemas import SchemasNotFound, find_folder
+
+__version__ = "1.1.0"
+__all__ = [
+    "ConversionError",
+    "SchemasNotFound",
+    "__version__",
+    "bodies_in",
+    "find_folder",
+    "to_x_t",
+]

sldprt2xt/builtin.py

@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 Emilien-Etadam
+
+"""Les schémas que le paquet porte en lui — l'autonomie.
+
+Trois sources, du plus sûr au plus souple :
+
+- :func:`base_schema` — le schéma de base 13006, bâti depuis
+  :mod:`sldprt2xt.schema_facts`. Suffit à décoder n'importe quel transmit :
+  le fichier épisse lui-même la disposition de chaque type de nœud.
+- :func:`envelope_for` — les dispositions ASSEMBLY/INSTANCE/TRANSFORM de la
+  version demandée, si cette version est dans la table. C'est ce que
+  l'écriture multi-corps exige et que rien dans une partition ne porte.
+- :func:`envelope_from_x_t` — les mêmes dispositions, apprises d'un ``.x_t``
+  donneur exporté par le même SolidWorks : un export multi-corps greffe ces
+  dispositions dans son propre texte. C'est la sortie pour une version plus
+  récente que la table.
+
+Un fichier de schéma déposé prime toujours sur tout ceci — voir
+:mod:`sldprt2xt.convert`.
+"""
+
+from __future__ import annotations
+
+from functools import cache
+from pathlib import Path
+
+from .schema_facts import BASE_KEY, BASE_NODES, ENVELOPE_BY_VERSION, ENVELOPE_FAMILIES
+from .xt.schema import FieldSpec, NodeSpec, Schema
+
+#: Les trois types de l'enveloppe, dans l'ordre des familles de la table.
+_ASSEMBLY, _INSTANCE, _TRANSFORM = 10, 11, 100
+_ENVELOPE_NAMES = {_ASSEMBLY: "ASSEMBLY", _INSTANCE: "INSTANCE", _TRANSFORM: "TRANSFORM"}
+
+
+def _fields(rows) -> tuple[FieldSpec, ...]:
+    return tuple(
+        FieldSpec(name=name, type=kind, transmitted=sent, ptr_class=at, n_elts=n)
+        for name, kind, sent, at, n in rows
+    )
+
+
+@cache
+def base_schema() -> Schema:
+    """Le schéma de base 13006, sans fichier."""
+    nodes = {
+        node_type: NodeSpec(
+            node_type=node_type,
+            name=name,
+            description="",
+            transmitted=sent,
+            variable=variable,
+            fields=_fields(rows),
+        )
+        for node_type, (name, sent, variable, rows) in BASE_NODES.items()
+    }
+    return Schema(key=BASE_KEY, modeller_version=None, nodes=nodes)
+
+
+@cache
+def envelope_for(version: str | int) -> Schema | None:
+    """Les dispositions d'enveloppe de *version*, ou ``None`` si inconnue.
+
+    Le schéma rendu ne porte que les trois types de l'enveloppe : c'est tout
+    ce que l'écriture demande, et le recoupement de ``verify`` ne s'applique
+    alors qu'à eux — exactement ceux que nous venons d'écrire.
+    """
+    try:
+        family = ENVELOPE_BY_VERSION[int(version)]
+    except (KeyError, ValueError):
+        return None
+    return _envelope(f"SCH_{version}", ENVELOPE_FAMILIES[family])
+
+
+def envelope_from_x_t(path: str | Path) -> Schema:
+    """Les dispositions d'enveloppe apprises d'un ``.x_t`` donneur.
+
+    Le donneur doit être un export SolidWorks portant une enveloppe — un
+    multi-corps en porte toujours une. Ses greffes déclarent les dispositions
+    exactes que sa version écrit ; on les lit au lieu d'exiger la table.
+    """
+    from .parasolid import TransmitError, read_text_transmit
+    from .xt import text as xt_text
+
+    data = Path(path).read_bytes()
+    transmit = read_text_transmit(data)
+    body = transmit.data[transmit.body_offset :].decode("latin-1")
+    layouts: dict[int, list[FieldSpec]] = {}
+    xt_text.parse_nodes(body, base_schema(), layouts=layouts)
+
+    missing = [t for t in (_ASSEMBLY, _INSTANCE, _TRANSFORM) if t not in layouts]
+    if missing:
+        raise TransmitError(
+            f"{Path(path).name} : pas d'enveloppe ASSEMBLY dans ce donneur — "
+            "prenez un .x_t multi-corps exporté par le même SolidWorks"
+        )
+    return _envelope(
+        f"SCH_{transmit.version_schema}",
+        tuple(
+            tuple(
+                (f.name, f.type, f.transmitted, f.ptr_class, f.n_elts)
+                for f in layouts[t]
+            )
+            for t in (_ASSEMBLY, _INSTANCE, _TRANSFORM)
+        ),
+    )
+
+
+def _envelope(key: str, family) -> Schema:
+    nodes = {
+        node_type: NodeSpec(
+            node_type=node_type,
+            name=_ENVELOPE_NAMES[node_type],
+            description="",
+            transmitted=True,
+            variable=False,
+            fields=_fields(rows),
+        )
+        for node_type, rows in zip((_ASSEMBLY, _INSTANCE, _TRANSFORM), family, strict=True)
+    }
+    return Schema(key=key, modeller_version=None, nodes=nodes)

sldprt2xt/carve.py

@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 Emilien-Etadam
+
+"""Find and inflate compressed regions inside a container blob.
+
+Two mechanisms are known:
+
+*wrapped sections*
+    A 16-byte magic followed by an uncompressed size, a compressed size and
+    a zlib member. This is what sits inside ``__ZLB`` compound streams and
+    what splits a ``Config-N-Partition`` stream into its transmit sections.
+
+*bare zlib members*
+    Everything else. We scan for zlib headers and keep whatever inflates to
+    a non-trivial length. This is a discovery aid, deliberately noisy: it is
+    for looking at an unfamiliar stream, not for production extraction.
+"""
+
+from __future__ import annotations
+
+import struct
+import zlib
+from dataclasses import dataclass
+
+from .container import SECTION_MAGIC
+
+ZLIB_HEADERS = (b"\x78\x01", b"\x78\x9c", b"\x78\xda", b"\x78\x5e")
+
+
+@dataclass
+class Region:
+    """One inflated region of a blob."""
+
+    #: ``"section"`` (magic-framed) or ``"zlib"`` (bare scan hit).
+    kind: str
+    #: Offset of the region's frame within the containing blob.
+    offset: int
+    data: bytes
+    #: Fields read from the frame, for the record.
+    header: dict[str, int]
+
+    @property
+    def size(self) -> int:
+        return len(self.data)
+
+
+def carve_sections(blob: bytes) -> list[Region]:
+    """Inflate every magic-framed section found in ``blob``.
+
+    A section is a length-prefixed run of independently compressed members::
+
+        -0x04  u32 LE  section length, counted from the magic
+        +0x00  16 B    SECTION_MAGIC
+        +0x10  member, member, …, then a (0, 0) header to close the run
+
+    and each member is::
+
+        u32 LE  uncompressed size
+        u32 LE  compressed size
+        zlib member of exactly that many bytes
+
+    **Members must all be inflated and concatenated.** A small part fits in
+    one, which is why a single-member reading appears to work; a large one is
+    split into many, and stopping at the first truncates the payload without
+    any error — the exact failure this project cannot afford.
+    """
+    regions: list[Region] = []
+    pos = blob.find(SECTION_MAGIC)
+    while pos != -1:
+        at = pos + len(SECTION_MAGIC)
+
+        # The length prefix bounds the member run. Without it — a magic at the
+        # very start of a blob — fall back to the end of the blob and let the
+        # member headers say where to stop.
+        end = len(blob)
+        if pos >= 4:
+            declared = struct.unpack_from("<I", blob, pos - 4)[0]
+            if 0 < declared <= len(blob) - pos + 4:
+                end = min(end, pos - 4 + 4 + declared)
+
+        parts: list[bytes] = []
+        members = 0
+        while at + 8 <= end:
+            uncomp_sz, comp_sz = struct.unpack_from("<II", blob, at)
+            if uncomp_sz == 0 and comp_sz == 0:
+                at += 8
+                break
+            if comp_sz == 0 or at + 8 + comp_sz > end:
+                break
+            try:
+                raw = zlib.decompress(blob[at + 8 : at + 8 + comp_sz])
+            except zlib.error:
+                break
+            if len(raw) != uncomp_sz:
+                break
+            parts.append(raw)
+            members += 1
+            at += 8 + comp_sz
+
+        if parts:
+            regions.append(
+                Region(
+                    kind="section",
+                    offset=pos,
+                    data=b"".join(parts),
+                    header={
+                        "members": members,
+                        "uncompressed": sum(len(p) for p in parts),
+                        "consumed": at - pos,
+                    },
+                )
+            )
+            pos = blob.find(SECTION_MAGIC, at)
+            continue
+        pos = blob.find(SECTION_MAGIC, pos + 1)
+    return regions
+
+
+def carve_zlib(blob: bytes, min_size: int = 64, limit: int = 64) -> list[Region]:
+    """Scan for bare zlib members and inflate them.
+
+    Returns at most ``limit`` regions of at least ``min_size`` inflated bytes.
+    Overlapping hits are suppressed: a member found inside an already-inflated
+    span is skipped.
+    """
+    regions: list[Region] = []
+    consumed_until = 0
+    pos = 0
+    while pos < len(blob) and len(regions) < limit:
+        nxt = min(
+            (p for p in (blob.find(h, pos) for h in ZLIB_HEADERS) if p != -1),
+            default=-1,
+        )
+        if nxt == -1:
+            break
+        if nxt < consumed_until:
+            pos = nxt + 1
+            continue
+        obj = zlib.decompressobj()
+        try:
+            raw = obj.decompress(blob[nxt:])
+        except zlib.error:
+            raw = b""
+        if len(raw) >= min_size:
+            used = len(blob) - nxt - len(obj.unused_data)
+            regions.append(
+                Region(
+                    kind="zlib",
+                    offset=nxt,
+                    data=raw,
+                    header={
+                        "actual_uncompressed": len(raw),
+                        "actual_compressed": used,
+                    },
+                )
+            )
+            consumed_until = nxt + used
+            pos = consumed_until
+        else:
+            pos = nxt + 1
+    return regions
+
+
+def carve(blob: bytes, *, scan_bare: bool = True) -> list[Region]:
+    """Inflate framed sections, then bare zlib members outside them."""
+    regions = carve_sections(blob)
+    if not scan_bare:
+        return regions
+    covered = [
+        (r.offset, r.offset + r.header.get("consumed", 0)) for r in regions
+    ]
+    for region in carve_zlib(blob):
+        if any(start <= region.offset < end for start, end in covered):
+            continue
+        regions.append(region)
+    return sorted(regions, key=lambda r: r.offset)

sldprt2xt/cli.py

@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 Emilien-Etadam
+
+"""La ligne de commande."""
+
+from __future__ import annotations
+
+import argparse
+import glob as globbing
+import sys
+import time
+from pathlib import Path
+
+from .convert import ConversionError, to_x_t
+from .schemas import SchemasNotFound, find_folder
+
+USAGE = """\
+  sldprt2xt piece.SLDPRT              le .x_t se pose a cote
+  sldprt2xt *.SLDPRT -o sorties/      plusieurs fichiers
+  sldprt2xt dossier/ -o sorties/      tout un dossier, sous-dossiers compris"""
+
+#: SolidWorks pose un verrou ``~$piece.SLDPRT`` à côté de toute pièce ouverte.
+#: Ce n'est pas une pièce, et un balayage qui le ramasse fait échouer le lot.
+LOCK_PREFIX = "~$"
+
+
+def parts_under(paths: list[Path]) -> list[tuple[Path, Path]]:
+    """Les pièces désignées, chacune avec son nom de sortie relatif.
+
+    Un dossier vaut tout ce qu'il contient, sous-dossiers compris — et la
+    hiérarchie suit : deux pièces de même nom dans deux sous-dossiers gardent
+    deux sorties. Les jokers sont développés ici parce que cmd et PowerShell
+    ne le font pas, et les verrous SolidWorks sont écartés des balayages ; un
+    fichier nommé explicitement passe tel quel, c'est lui le chef.
+    """
+    found: list[tuple[Path, Path]] = []
+    for path, named_explicitly in _expanded(paths):
+        if path.is_dir():
+            for part in sorted(path.rglob("*")):
+                if part.suffix.lower() != ".sldprt":
+                    continue
+                if part.name.startswith(LOCK_PREFIX):
+                    continue
+                found.append((part, part.relative_to(path).with_suffix(".x_t")))
+        elif named_explicitly or not path.name.startswith(LOCK_PREFIX):
+            found.append((path, Path(path.stem + ".x_t")))
+    return found
+
+
+def _expanded(paths: list[Path]) -> list[tuple[Path, bool]]:
+    """Chaque argument, joker développé — avec qui fut nommé tel quel.
+
+    Un motif qui matche est un balayage (ses verrous s'écartent) ; un chemin
+    sans joker, ou un motif qui ne matche rien, reste l'argument de
+    l'utilisateur et sera traité — ou refusé — sous son propre nom.
+    """
+    out: list[tuple[Path, bool]] = []
+    for path in paths:
+        raw = str(path)
+        if any(mark in raw for mark in "*?[") and not path.exists():
+            matches = sorted(Path(found) for found in globbing.glob(raw))
+            if matches:
+                out.extend((match, False) for match in matches)
+                continue
+        out.append((path, True))
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="sldprt2xt",
+        description="Extraire la geometrie Parasolid d'un fichier SolidWorks.",
+        epilog=USAGE,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("paths", nargs="+", type=Path, metavar="FICHIER")
+    parser.add_argument(
+        "-o", "--out", type=Path, metavar="DOSSIER", help="ou ecrire les .x_t"
+    )
+    parser.add_argument(
+        "--schemas", type=Path, metavar="DOSSIER", help="dossier des schemas Parasolid"
+    )
+    parser.add_argument(
+        "--donor",
+        type=Path,
+        metavar="FICHIER.x_t",
+        help="un .x_t multi-corps exporte par le meme SolidWorks, si la "
+        "version du fichier est plus recente que les tables integrees",
+    )
+    parser.add_argument(
+        "-q", "--quiet", action="store_true", help="ne rien dire si tout va bien"
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        folder = find_folder(args.schemas)
+    except SchemasNotFound as missing:
+        print(missing, file=sys.stderr)
+        return 2
+
+    parts = parts_under(args.paths)
+    if not parts:
+        print("aucun fichier .SLDPRT la-dedans", file=sys.stderr)
+        return 1
+
+    done = failed = 0
+    written: dict[Path, Path] = {}
+    for part, relative in parts:
+        destination = args.out / relative if args.out else part.with_suffix(".x_t")
+        if destination in written:
+            print(
+                f"{part} : meme destination que {written[destination]} "
+                f"({destination}) — non ecrit",
+                file=sys.stderr,
+            )
+            failed += 1
+            continue
+        started = time.monotonic()
+        try:
+            result = to_x_t(part, destination, schemas=folder, donor=args.donor)
+        except ConversionError as failure:
+            print(f"{part.name} : {failure}", file=sys.stderr)
+            failed += 1
+        except Exception as failure:  # un fichier en echec n'arrete pas le lot
+            print(f"{part.name} : {type(failure).__name__}: {failure}", file=sys.stderr)
+            failed += 1
+        else:
+            done += 1
+            written[destination] = part
+            if not args.quiet:
+                size = result.stat().st_size / 1e6
+                print(f"{result}  {size:.2f} Mo  ({time.monotonic() - started:.1f} s)")
+
+    if len(parts) > 1 and not args.quiet:
+        print(f"\n{done} converti(s), {failed} en echec")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())