Anteprime, decompressione LZW e contenuto dei disegni

Aggiunge tre capacita' al lettore, tutte senza dipendenze esterne.

Anteprima incorporata (preview.py)
    Ogni file contiene una miniatura JPEG dell'ultimo salvataggio: il
    render del pezzo nei modelli, l'immagine della tavola nei disegni.
    Non e' referenziata dall'indice, quindi va cercata per firma: ogni
    candidato viene validato percorrendone i segmenti JPEG, cosi' i byte
    che iniziano per FFD8FF per caso non passano. Sui file campione il
    risultato e' esattamente una immagine per file.

Decompressione compress(1) (lzw.py)
    Creo comprime alcuni blocchi nel vecchio formato .Z. Rispetto a un
    LZW generico va riprodotto l'allineamento a gruppi di otto codici:
    senza, la decompressione produce qualche centinaio di byte corretti
    e poi diverge silenziosamente.

Contenuto dei disegni (drawing.py)
    Un .drw non ha la tabella parametri del modello ma contiene la
    rappresentazione vettoriale della tavola. Ne estraiamo i testi:
    cartiglio, note, tolleranze, quote. Le tavole diventano cosi'
    ricercabili per contenuto. Nel disegno i valori compaiono gia'
    risolti come testo, compreso il peso, mentre nel .prt sono ancora
    in codifica binaria.

I blocchi oltre l'indice sono ora interpretati da ugc.iter_blocks, che
decomprime quando serve: lo stesso blocco puo' essere memorizzato
compresso in un file e in chiaro in un altro, quindi la scelta va fatta
guardando i byte e non il nome. Cercare soltanto gli stream compressi
faceva perdere i testi su un terzo dei disegni.

Sulla codifica dei numeri: sono double IEEE big-endian con i byte bassi
omessi, preceduti da un byte-tag. Lo dimostrano i disegni, dove size_x e
size_y valgono 420,0 x 297,0 (un A3 esatto). La mappatura del byte-tag
resta pero' incerta, quindi PESO e DENSITA continuano a essere riportati
come encoded_not_decoded: un valore plausibile ma sbagliato sarebbe
peggio di un valore assente.

La geometria 3D resta fuori portata, e ora e' verificato: in 200 KB di
blocchi geometrici non compare una sola costante 1.0 in nessuna codifica
in virgola mobile. Quei blocchi sono compressi con un algoritmo che non
espone firme note.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

creoparams/cli.py

@@ -10,7 +10,7 @@ import sys
 
 from . import ugc
 from .extract import extract as extract_file
-from .extract import latest_versions, split_filename
+from .extract import latest_versions, read_preview, split_filename
 
 CREO_EXTENSIONS = (".prt", ".asm", ".drw", ".frm", ".lay")
 
@@ -58,19 +58,33 @@ def _visible(record: dict, include_system: bool, include_features: bool = False)
 
 
 def _print_table(records: "list[dict]", stream, include_system: bool = False,
-                 include_features: bool = False) -> None:
+                 include_features: bool = False, limit_texts: int = 20) -> None:
     for record in records:
         model = record["model"]
         header = f"{record['file']['name']}  [{model['kind']}"
         if model["subtype"]:
             header += f"/{model['subtype']}"
         header += f"]  Creo {model['creo_version'] or '?'}"
+        shot = record.get("preview", {})
+        if shot.get("present"):
+            header += f"  anteprima {shot['width']}x{shot['height']}"
         print(header, file=stream)
         print("-" * len(header), file=stream)
 
         if not record["extraction"]["holds_model_parameters"]:
-            print(" (i disegni non contengono la tabella parametri del modello)",
-                  file=stream)
+            sheet = record.get("drawing")
+            if sheet and sheet["texts"]:
+                print(" %d testi nella tavola (%d unici). I parametri del "
+                      "modello stanno nel .prt." % (
+                          sheet["text_count"], len(sheet["texts"])), file=stream)
+                for text in sheet["texts"][:limit_texts]:
+                    print("   %s" % text, file=stream)
+                if len(sheet["texts"]) > limit_texts:
+                    print("   ... altri %d (usare -o per averli tutti)" % (
+                          len(sheet["texts"]) - limit_texts), file=stream)
+            else:
+                print(" (i disegni non contengono la tabella parametri del modello)",
+                      file=stream)
             print(file=stream)
             continue
 
@@ -92,6 +106,40 @@ def _print_table(records: "list[dict]", stream, include_system: bool = False,
         print(file=stream)
 
 
+def _preview_path(source: str, dest: str, single: bool) -> str:
+    """Decide dove scrivere l'anteprima di `source`.
+
+    Senza destinazione la mette accanto all'originale; se la destinazione e'
+    una cartella ci scrive dentro; un nome esplicito vale solo con un file
+    solo, altrimenti i file si sovrascriverebbero a vicenda.
+    """
+    name = os.path.basename(source) + ".jpg"
+    if not dest:
+        return source + ".jpg"
+    # La barra finale indica una cartella anche se non esiste ancora; con piu'
+    # file la destinazione e' comunque una cartella, altrimenti si
+    # sovrascriverebbero a vicenda.
+    looks_like_dir = dest.endswith(("/", os.sep)) or os.path.isdir(dest)
+    if looks_like_dir or not single:
+        os.makedirs(dest, exist_ok=True)
+        return os.path.join(dest, name)
+    return dest
+
+
+def _save_previews(paths: "list[str]", dest: str, stream) -> None:
+    single = len(paths) == 1
+    for source in paths:
+        shot = read_preview(source)
+        if shot is None:
+            print(f"{os.path.basename(source)}: nessuna anteprima nel file",
+                  file=stream)
+            continue
+        target = _preview_path(source, dest, single)
+        shot.save(target)
+        print(f"Anteprima {shot.width}x{shot.height} salvata in {target}",
+              file=stream)
+
+
 def _write_csv(records: "list[dict]", path: str, include_system: bool = False,
                include_features: bool = False) -> None:
     names = sorted({n for r in records for n in _visible(r, include_system, include_features)})
@@ -131,6 +179,9 @@ def build_parser() -> argparse.ArgumentParser:
                              "con piu' file una lista")
     parser.add_argument("--csv", metavar="FILE",
                         help="scrive una tabella riepilogativa in CSV")
+    parser.add_argument("--preview", nargs="?", const="", metavar="FILE|CARTELLA",
+                        help="salva l'anteprima incorporata come JPEG. Senza "
+                             "argomento la scrive accanto al file di origine")
     parser.add_argument("-r", "--recursive", action="store_true",
                         help="esplora le sottocartelle")
     parser.add_argument("--all-versions", action="store_true",
@@ -189,6 +240,11 @@ def main(argv: "list[str] | None" = None) -> int:
         _write_csv(records, args.csv, args.system, args.features)
         print(f"CSV scritto in {args.csv}", file=sys.stderr)
 
+    if args.preview is not None:
+        _save_previews(
+            [r["source_file"] for r in records], args.preview, sys.stderr
+        )
+
     for path, reason in failures:
         print(f"SALTATO {os.path.basename(path)}: {reason}", file=sys.stderr)