""" Generator PSD - Podziekowanie dla gosci weselnych (buteleczka, Wzor 2). Otwiera szablon PSD, podmienia teksty w Smart Object "Projekt" z zachowaniem pozycji warstw, zapisuje jako nowy PSD w folderze _gotowe. Wszystkie 8 warstw w szablonie to linkowane kopie tego samego Smart Object, wiec edycja w "Projekt" propaguje sie automatycznie na pozostale buteleczki. Wymaga: uruchomiony Adobe Photoshop, pakiet photoshop-python-api. Uzycie: python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \ --data "12.12.2024" --klient "Anna Kowalska" python buteleczki_slub_wzor2.py --imie_pana "Piotr" --imie_pani "Anna" \ --inicjal_pana "P" --inicjal_pani "A" --data "12.12.2024" \ --tekst "Dziekujemy!" --klient "Anna Kowalska" """ import argparse import os import photoshop.api as ps # --- Sciezki --- PROJEKT_DIR = os.path.join( r"d:\pomysloweprezenty.pl\projekty\ślub - buteleczki", "Podziękowanie dla gości weselnych buteleczka z nadrukiem UV - Wzór 2", ) SZABLON_PATH = os.path.join(PROJEKT_DIR, "szablon 370x300.psd") GOTOWE_DIR = os.path.join(PROJEKT_DIR, "_gotowe") # Nazwa warstwy Smart Object w glownym PSD (jeden z 8 - edycja propaguje na wszystkie) SMART_OBJECT_LAYER = "Projekt" def open_smart_object(app): """Otwiera zawartosc aktywnej warstwy Smart Object do edycji.""" desc = ps.ActionDescriptor() ref = ps.ActionReference() ref.putEnumerated( app.stringIDToTypeID("layer"), app.stringIDToTypeID("ordinal"), app.stringIDToTypeID("targetEnum"), ) desc.putReference(app.stringIDToTypeID("null"), ref) app.executeAction(app.stringIDToTypeID("placedLayerEditContents"), desc) def change_text_preserve_position(layer, new_text): """Zmienia tekst warstwy z zachowaniem oryginalnej pozycji. Zwraca (dx, dy, ok) gdzie ok=False oznacza ze bounds_after=(0,0,0,0) (warstwa poza canvas SO po zmianie tekstu - delta nieuzyteczna). """ bounds_before = [float(b) for b in layer.bounds] layer.textItem.contents = new_text bounds_after = [float(b) for b in layer.bounds] if bounds_after == [0.0, 0.0, 0.0, 0.0]: return (None, None, False) dx = bounds_before[0] - bounds_after[0] dy = bounds_before[1] - bounds_after[1] if dx != 0 or dy != 0: layer.translate(dx, dy) return (dx, dy, True) def apply_replacements(group, replacements): """Podmienia teksty w grupie warstw z fallbackiem dla warstw gubiacych bounds. Photoshop po zmianie textItem.contents potrafi przeniesc warstwe poza canvas SO (bounds=0). Wykrywamy to i kompensujemy srednia delta z poprawnie obsluzonych warstw - przesuniecie jest systematyczne. """ deltas = [] pending = [] for layer_name, new_text in replacements.items(): layer = group.artLayers[layer_name] old_text = layer.textItem.contents dx, dy, ok = change_text_preserve_position(layer, new_text) if ok: deltas.append((dx, dy)) print(f' {layer_name}: "{old_text}" -> "{new_text}"') else: pending.append((layer_name, layer, old_text, new_text)) print(f' {layer_name}: "{old_text}" -> "{new_text}" (poza canvas, fallback)') if pending: if not deltas: raise RuntimeError("Wszystkie warstwy poza canvas - brak referencji do fallbacku") avg_dx = sum(d[0] for d in deltas) / len(deltas) avg_dy = sum(d[1] for d in deltas) / len(deltas) for layer_name, layer, _old, _new in pending: layer.translate(avg_dx, avg_dy) print(f' [{layer_name}] fallback translate ({avg_dx:.2f},{avg_dy:.2f})') def generate( imie_pana, imie_pani, data, klient, inicjal_pana=None, inicjal_pani=None, tekst=None, ): """Generuje PSD z podmienionymi danymi.""" os.makedirs(GOTOWE_DIR, exist_ok=True) output_path = os.path.join(GOTOWE_DIR, f"{klient}.psd") # Auto-inicjaly z imion jesli nie podane if inicjal_pana is None: inicjal_pana = imie_pana[:1].upper() if imie_pana else "" if inicjal_pani is None: inicjal_pani = imie_pani[:1].upper() if imie_pani else "" app = ps.Application() doc = app.open(SZABLON_PATH) print(f"Otwarto szablon: {doc.name}") target = None for layer in doc.layers: if layer.name == SMART_OBJECT_LAYER: target = layer break if target is None: doc.close(ps.SaveOptions.DoNotSaveChanges) raise RuntimeError(f"Nie znaleziono warstwy '{SMART_OBJECT_LAYER}'") app.activeDocument.activeLayer = target open_smart_object(app) so_doc = app.activeDocument # Nawigacja do grupy z tekstami (po renamie: "Tekst") tekst_group = so_doc.layerSets["Tekst"] replacements = { "imie_pana": imie_pana, "imie_pani": imie_pani, "inicjal_pana": inicjal_pana, "inicjal_pani": inicjal_pani, "data": data, } if tekst is not None: replacements["tekst"] = tekst apply_replacements(tekst_group, replacements) so_doc.save() so_doc.close() print("Smart Object zapisany") psd_opts = ps.PhotoshopSaveOptions() app.activeDocument.saveAs(output_path, psd_opts, True) print(f"Zapisano: {output_path}") app.activeDocument.close(ps.SaveOptions.DoNotSaveChanges) print("Gotowe!") return output_path def main(): parser = argparse.ArgumentParser( description="Generator PSD - buteleczki weselne Wzor 2" ) parser.add_argument("--imie_pana", required=True, help="Imie pana mlodego (np. Piotr)") parser.add_argument("--imie_pani", required=True, help="Imie pani mlodej (np. Anna)") parser.add_argument("--data", required=True, help="Data slubu (np. 12.12.2024)") parser.add_argument("--klient", required=True, help="Nazwa pliku wyjsciowego (bez .psd)") parser.add_argument( "--inicjal_pana", default=None, help="Inicjal pana mlodego (domyslnie: pierwsza litera --imie_pana)", ) parser.add_argument( "--inicjal_pani", default=None, help="Inicjal pani mlodej (domyslnie: pierwsza litera --imie_pani)", ) parser.add_argument( "--tekst", default=None, help="Tekst podziekowania (domyslnie: oryginalny z szablonu)", ) args = parser.parse_args() generate( imie_pana=args.imie_pana, imie_pani=args.imie_pani, data=args.data, klient=args.klient, inicjal_pana=args.inicjal_pana, inicjal_pani=args.inicjal_pani, tekst=args.tekst, ) if __name__ == "__main__": main()