В поисках скрипта/идеи для отрисовки ID

[FLOKI]

Доброго дня всем. Есть ли у кого-нибудь исходники или идеи для написания скрипта по отрисовки немецких ID? Прошерстил весь инет, гитхаб, форумы - ничего из бесплатного нет (даже сурсы никто не продает). Знаю что реализация подобного есть на некоторых сайтах, но там за одну сторону айдишки просят 10$))

Была идея самому по быстрому сделать шаблон в фотошопе и через ExtendScript изменять нужные данные, маски и тд. То есть у меня был бы условный дедик на котором 24/7 открыт фотошоп и работает сервак для ожидания команды от клиента. Клиент (тг бот к примеру) посылает запрос с данными для отрисовки на сервер -> сервер обрабатывает данные и передает задачу jsx скрипту - > этот скрипт изменяет нужные слои -> экспортирует куда-нибудь -> сервер отправляет полученную отрисовку клиенту.

Однако тут уже встает вопрос по многопоточности. Создавать по 20 процессов фотошопа не лучшая идея, ведь нагрузки на дедик будут чрезмерны. А покупать сразу 5 дедиков и отдельный сервер для общения дедик<->клиент будет слишком затратно для подобной задачи.

В связи с этим хотел бы узнать про то, есть ли уже какие-то готовые решения на питоне под такую задачу? Или может быть у кого-то есть идеи для реализации подобного? Буду рад услышать

P.S: Качество доков на выходе не важно, нужно лишь минимальное визуальное сходство

 

[shrekushka]

GitHub - CompVis/stable-diffusion: A latent text-to-image diffusion model

A latent text-to-image diffusion model. Contribute to CompVis/stable-diffusion development by creating an account on GitHub.

github.com

))))

 

[FLOKI]

http://xssforum7mmh3n56inuf2h73hvhnzobi7h2ytb3gvklrfqm7ut3xdnyd.onion/attachments/108383/?hash=11abf7f2fde0e486de5f18be6f1876fe

I can use prompts for ChatGPT API in the same way — the only question is how long it takes to generate a single image. In any case, thanks for the model, I’ll play around with it tonight.

 

[rand]

Возможно и бред. Но можно создать макет карточки, и накладывать те же данные через Pillow, или через какой-нибудь ReportLab, а потом уже конвертировать в изображение через Pillow. Просто мысль к размышлению.

 

[FLOKI]

Возможно и бред. Но можно создать макет карточки, и накладывать те же данные через Pillow, или через какой-нибудь ReportLab, а потом уже конвертировать в изображение через Pillow. Просто мысль к размышлению.

Подумал об этом в первую очередь, но даже не представляю сколько горя я хапну пытаясь это все +- правдоподобно подставить данные к разным макетам
при том что реализовать я это хочу просто для своих ребят, чтобы всегда под рукой было так сказать)

 

[0xThird]

verif.tools

использовал для прохождения KYC для airdrop/ico
Работало норм

DYOR

 

[rand]

Возможно и бред. Но можно создать макет карточки, и накладывать те же данные через Pillow, или через какой-нибудь ReportLab, а потом уже конвертировать в изображение через Pillow. Просто мысль к размышлению.

Написал: rand
Специально для: xss.pro
Пример реализации отрисовщика. Работает с PSD. Но все зависит от шаблона. Нужно под него шаблон в PSD четко настраивать по всем слоям и т.д.
Кому надо заморачивайтесь, мне лень в фотожопе работать, а также меняйте скрипт под себя. =)

Скрины:
Конвертер:

Отрисовщик (на скрине отрисовка, но сам шаб PSD у меня кривоват, так и не хватило времени его допилить чтобы фотка нормально вставлялась, да и в общем скрипт нуждается в небольшой доработке напильником):

Код:

import sys
import json
import os
import threading
from datetime import datetime
from pathlib import Path

from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                             QHBoxLayout, QTabWidget, QLabel, QLineEdit, QPushButton,
                             QTextEdit, QProgressBar, QFileDialog, QMessageBox,
                             QGroupBox, QFormLayout, QScrollArea, QFrame, QSplitter,
                             QSpinBox)
from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer, QSize
from PyQt6.QtGui import QPixmap, QFont, QPalette, QColor, QIcon

from PIL import Image, ImageDraw, ImageFont, ImageQt, ImageEnhance
import shutil

try:
    from psd_tools import PSDImage

    PSD_AVAILABLE = True
except ImportError:
    PSD_AVAILABLE = False


class PSDTemplateAnalyzer:
    def __init__(self, psd_path):
        if not PSD_AVAILABLE:
            raise ImportError("psd-tools не установлен. Установите: pip install psd-tools")

        try:
            # Подавляем предупреждения о неизвестных ресурсах
            import warnings
            warnings.filterwarnings('ignore', message='Unknown image resource*')
            warnings.filterwarnings('ignore', category=UserWarning, module='psd_tools')

            print(f"Загрузка PSD файла: {psd_path}")
            self.psd = PSDImage.open(psd_path)
            print(f"PSD загружен успешно. Размер: {self.psd.width}x{self.psd.height}")

        except Exception as e:
            print(f"Ошибка загрузки PSD файла: {e}")
            raise

        self.template_data = {
            'dimensions': (self.psd.width, self.psd.height),
            'background_layers': [],
            'text_layers': [],
            'image_placeholders': [],
            'design_elements': []
        }

    def analyze_layers(self, progress_callback=None):
        """Анализирует все слои PSD с улучшенной обработкой ошибок"""
        try:
            layers = list(self.psd.descendants())
            total_layers = len(layers)
            print(f"Найдено слоев для анализа: {total_layers}")

            processed_layers = 0
            errors_count = 0

            for i, layer in enumerate(layers):
                try:
                    if progress_callback:
                        progress_callback.emit(i, total_layers, f"Анализ слоя: {layer.name}")

                    # Безопасное получение атрибутов слоя
                    layer_info = {
                        'name': getattr(layer, 'name', f'Layer_{i}'),
                        'bbox': getattr(layer, 'bbox', None),
                        'visible': getattr(layer, 'visible', True),
                        'opacity': getattr(layer, 'opacity', 255),
                        'kind': getattr(layer, 'kind', 'unknown')
                    }

                    print(f"Обрабатываем слой: {layer_info['name']} (тип: {layer_info['kind']})")

                    if layer_info['kind'] == 'type':
                        try:
                            text_info = self.extract_text_info(layer)
                            self.template_data['text_layers'].append(text_info)
                            print(f"✓ Текстовый слой обработан: {layer_info['name']}")
                        except Exception as e:
                            print(f"⚠️ Ошибка обработки текстового слоя '{layer_info['name']}': {e}")
                            errors_count += 1

                    elif layer_info['kind'] == 'pixel':
                        try:
                            if self.is_background_layer(layer):
                                self.template_data['background_layers'].append(layer_info)
                                print(f"✓ Фоновый слой: {layer_info['name']}")
                            elif self.is_placeholder(layer):
                                placeholder_info = self.extract_placeholder_info(layer)
                                self.template_data['image_placeholders'].append(placeholder_info)
                                print(f"✓ Placeholder найден: {layer_info['name']}")
                            else:
                                self.template_data['design_elements'].append(layer_info)
                                print(f"✓ Элемент дизайна: {layer_info['name']}")
                        except Exception as e:
                            print(f"⚠️ Ошибка обработки пиксельного слоя '{layer_info['name']}': {e}")
                            errors_count += 1

                    processed_layers += 1

                except Exception as e:
                    print(f"⚠️ Критическая ошибка обработки слоя {i}: {e}")
                    errors_count += 1
                    continue

            print(f"\n📊 Результаты анализа:")
            print(f"   • Обработано слоев: {processed_layers}/{total_layers}")
            print(f"   • Ошибок: {errors_count}")
            print(f"   • Текстовых слоев: {len(self.template_data['text_layers'])}")
            print(f"   • Placeholder'ов: {len(self.template_data['image_placeholders'])}")
            print(f"   • Фоновых слоев: {len(self.template_data['background_layers'])}")
            print(f"   • Элементов дизайна: {len(self.template_data['design_elements'])}")

        except Exception as e:
            print(f"❌ Критическая ошибка анализа слоев: {e}")
            raise

    def extract_text_info(self, text_layer):
        """Извлекает информацию о текстовом слое"""
        bbox = text_layer.bbox

        return {
            'name': text_layer.name,
            'position': (bbox[0], bbox[1]) if bbox else (0, 0),
            'size': (bbox[2] - bbox[0], bbox[3] - bbox[1]) if bbox else (100, 30),
            'text_content': getattr(text_layer, 'text', ''),
            'font_info': {'size': 14, 'color': (0, 0, 0), 'family': 'Arial'},
            'is_template_field': self.detect_template_field(text_layer.name)
        }

    def detect_template_field(self, layer_name):
        """Определяет поле шаблона по имени слоя"""
        # Расширенный маппинг с учетом новых полей
        field_mapping = {
            'number': ['number'],
            'address': ['address'],
            'height': ['height'],
            'colorEyes': ['colorEyes', 'coloreyes'],
            'authority': ['authority'],
            'date_hidden': ['date_hidden'],
            'date': ['date'],
            'idd2': ['idd2'],
            'idd1': ['idd1'],
            'idd3': ['idd3'],
            'seria': ['seria'],
            'family': ['family'],
            'Dateexpiry': ['Dateexpiry', 'dateexpiry'],
            'placebirth': ['placebirth'],
            'nation': ['nation'],
            'birthday': ['birthday'],
            'name': ['name'],
            'golograf_id': ['golograf_id']
        }

        # Проверяем точное совпадение
        for field, keywords in field_mapping.items():
            if layer_name in keywords:
                return field

        # Проверяем частичное совпадение (для обратной совместимости)
        layer_name_lower = layer_name.lower()
        for field, keywords in field_mapping.items():
            if any(keyword.lower() in layer_name_lower for keyword in keywords):
                return field

        return None

    def is_background_layer(self, layer):
        bg_keywords = ['background', 'bg', 'фон', 'base', 'основа']
        return any(keyword in layer.name.lower() for keyword in bg_keywords)

    def is_placeholder(self, layer):
        placeholder_keywords = ['photo', 'фото', 'image', 'изображение', 'picture', 'avatar', 'Photo Edit Duble']
        return any(keyword in layer.name.lower() for keyword in placeholder_keywords)

    def extract_placeholder_info(self, layer):
        bbox = layer.bbox
        return {
            'name': layer.name,
            'position': (bbox[0], bbox[1]) if bbox else (0, 0),
            'size': (bbox[2] - bbox[0], bbox[3] - bbox[1]) if bbox else (100, 100),
            'type': 'photo_edit_duble' if 'Photo Edit Duble' in layer.name else 'photo'
        }

    def create_background(self, progress_callback=None):
        """Создает фоновое изображение"""
        background = Image.new('RGBA', self.template_data['dimensions'], (255, 255, 255, 255))

        layers = [layer for layer in self.psd.descendants() if layer.kind != 'type']
        for i, layer in enumerate(layers):
            if progress_callback:
                progress_callback.emit(i, len(layers), f"Обработка слоя: {layer.name}")

            if hasattr(layer, 'topil'):
                try:
                    layer_img = layer.topil()
                    if layer_img and layer.bbox:
                        background.paste(layer_img, layer.bbox[:2],
                                         layer_img if 'A' in layer_img.mode else None)
                except:
                    pass

        return background


class DocumentTemplate:
    def __init__(self, config_path, assets_dir):
        with open(config_path, 'r', encoding='utf-8') as f:
            self.config = json.load(f)
        self.assets_dir = assets_dir
        self.background_image = None
        self.load_background()

    def load_background(self):
        background_path = os.path.join(self.assets_dir, "background.png")
        if os.path.exists(background_path):
            self.background_image = Image.open(background_path).convert('RGBA')

    def process_photo_for_duble(self, photo_path):
        """Обрабатывает фото для слоя Photo Edit Duble"""
        try:
            img = Image.open(photo_path)

            # Конвертируем в RGB если необходимо
            if img.mode not in ('RGB', 'RGBA'):
                img = img.convert('RGB')

            # Применяем насыщенность -100 (делаем черно-белым)
            enhancer = ImageEnhance.Color(img)
            img = enhancer.enhance(0.0)  # 0.0 = полностью черно-белое

            # Применяем яркость -20
            enhancer = ImageEnhance.Brightness(img)
            img = enhancer.enhance(0.8)  # 0.8 = уменьшение яркости на 20%

            # Конвертируем в RGBA для применения прозрачности
            if img.mode != 'RGBA':
                img = img.convert('RGBA')

            # Применяем непрозрачность 55%
            # Создаем новое изображение с альфа-каналом
            img_with_alpha = Image.new('RGBA', img.size, (255, 255, 255, 0))
            img_with_alpha.paste(img, (0, 0))

            # Изменяем альфа-канал
            alpha = img_with_alpha.split()[3]
            alpha = alpha.point(lambda p: int(p * 0.55))
            img_with_alpha.putalpha(alpha)

            return img_with_alpha

        except Exception as e:
            print(f"Ошибка обработки фото для дубликата: {e}")
            return None

    def create_document(self, data, font_overrides=None):
        if not self.background_image:
            image = Image.new('RGBA', self.config['dimensions'], (255, 255, 255, 255))
        else:
            image = self.background_image.copy()

        draw = ImageDraw.Draw(image)

        # Добавляем текстовые поля
        for field in self.config['text_layers']:
            field_key = field.get('is_template_field')
            if field_key and field_key in data:
                # Проверяем, есть ли переопределение размера шрифта
                if font_overrides and field_key in font_overrides:
                    # Создаем копию конфигурации поля с новым размером
                    field_copy = field.copy()
                    field_copy['font_info'] = field['font_info'].copy()
                    field_copy['font_info']['size'] = font_overrides[field_key]
                    self.add_text(draw, field_copy, data[field_key])
                else:
                    self.add_text(draw, field, data[field_key])

        # Добавляем изображения
        for placeholder in self.config['image_placeholders']:
            if 'photo' in data and os.path.exists(data['photo']):
                if placeholder['type'] == 'photo_edit_duble':
                    # Обрабатываем фото для дубликата
                    processed_img = self.process_photo_for_duble(data['photo'])
                    if processed_img:
                        self.add_processed_image(image, placeholder, processed_img)
                else:
                    # Обычное фото
                    self.add_image(image, placeholder, data['photo'])

        return image

    def add_text(self, draw, field_config, text):
        try:
            font_config = field_config.get('font_info', {})
            font_size = font_config.get('size', 16)
            font_family = font_config.get('family', 'Arial')
            font_weight = font_config.get('weight', 'normal')
            font_style = font_config.get('style', 'normal')

            print(f"\n=== Добавление текста ===")
            print(f"Текст: '{text}'")
            print(f"Шрифт: {font_family}")
            print(f"Размер: {font_size}")
            print(f"Вес: {font_weight}")
            print(f"Стиль: {font_style}")
            print(f"Позиция: {field_config['position']}")

            # Создаем список возможных имен шрифтов для поиска
            font_candidates = []

            # Добавляем точное имя из PSD
            if font_family != 'Arial':
                font_candidates.extend([
                    f"{font_family}.ttf",
                    f"{font_family}-Regular.ttf",
                    f"{font_family}Regular.ttf",
                ])

                # Добавляем варианты с весом и стилем
                if font_weight == 'bold' and font_style == 'italic':
                    font_candidates.extend([
                        f"{font_family}-BoldItalic.ttf",
                        f"{font_family}BoldItalic.ttf",
                        f"{font_family}-Bold-Italic.ttf"
                    ])
                elif font_weight == 'bold':
                    font_candidates.extend([
                        f"{font_family}-Bold.ttf",
                        f"{font_family}Bold.ttf",
                        f"{font_family}-B.ttf"
                    ])
                elif font_style == 'italic':
                    font_candidates.extend([
                        f"{font_family}-Italic.ttf",
                        f"{font_family}Italic.ttf",
                        f"{font_family}-I.ttf"
                    ])

            # Добавляем системные шрифты
            system_fonts = {
                'Arial': ['arial.ttf', 'Arial.ttf', 'ArialMT.ttf'],
                'Helvetica': ['helvetica.ttf', 'Helvetica.ttf', 'HelveticaNeue.ttf'],
                'Times': ['times.ttf', 'Times.ttf', 'TimesNewRoman.ttf', 'times-roman.ttf'],
                'Courier': ['courier.ttf', 'Courier.ttf', 'CourierNew.ttf'],
                'Verdana': ['verdana.ttf', 'Verdana.ttf'],
                'Georgia': ['georgia.ttf', 'Georgia.ttf'],
            }

            # Проверяем, есть ли наш шрифт в системных
            for sys_font, variants in system_fonts.items():
                if font_family.lower() in sys_font.lower() or sys_font.lower() in font_family.lower():
                    font_candidates.extend(variants)
                    break

            # Добавляем fallback шрифты
            font_candidates.extend([
                'arial.ttf', 'Arial.ttf', 'arial.TTF',  # Windows
                '/System/Library/Fonts/Arial.ttf',  # macOS
                '/System/Library/Fonts/Helvetica.ttc',  # macOS альтернатива
                'DejaVuSans.ttf', '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf',  # Linux
                'NotoSans-Regular.ttf', '/usr/share/fonts/noto/NotoSans-Regular.ttf',  # Linux
                'LiberationSans-Regular.ttf', '/usr/share/fonts/liberation/LiberationSans-Regular.ttf'  # Linux
            ])

            # Пытаемся загрузить шрифт
            font = None
            used_font_path = None

            for font_path in font_candidates:
                try:
                    # Пробуем системные пути
                    system_paths = [
                        '',  # Текущая директория или системный путь
                        'C:/Windows/Fonts/',  # Windows
                        '/System/Library/Fonts/',  # macOS
                        '/Library/Fonts/',  # macOS пользователь
                        '/usr/share/fonts/truetype/',  # Linux
                        '/usr/local/share/fonts/',  # Linux локальные
                    ]

                    for sys_path in system_paths:
                        full_path = sys_path + font_path if sys_path else font_path
                        try:
                            font = ImageFont.truetype(full_path, font_size)
                            used_font_path = full_path
                            print(f"Успешно загружен шрифт: {full_path}")
                            break
                        except:
                            continue

                    if font:
                        break

                except Exception as e:
                    continue

            # Если не удалось загрузить ни один шрифт, используем default
            if font is None:
                print(f"Не удалось найти шрифт '{font_family}', используется шрифт по умолчанию")
                font = ImageFont.load_default()
                used_font_path = "default"

                # Пытаемся масштабировать default шрифт
                try:
                    # Для default шрифта пытаемся приблизить размер
                    if font_size > 16:
                        # Создаем более крупный default шрифт путем увеличения
                        pass  # К сожалению, default шрифт нельзя масштабировать
                except:
                    pass

            position = field_config['position']
            color = font_config.get('color', (0, 0, 0))

            # Обеспечиваем правильный формат цвета
            if isinstance(color, (list, tuple)) and len(color) >= 3:
                color = tuple(int(c) for c in color[:3])
            else:
                color = (0, 0, 0)

            color = tuple(max(0, min(255, c)) for c in color)

            print(f"Используемый шрифт: {used_font_path}")
            print(f"Цвет текста: {color}")

            # Добавляем текст
            draw.text(position, str(text), fill=color, font=font)
            print(f"Текст '{text}' успешно добавлен")

        except Exception as e:
            print(f"Ошибка при добавлении текста: {e}")
            import traceback
            traceback.print_exc()

            # Fallback с безопасными параметрами
            try:
                font = ImageFont.load_default()
                draw.text(field_config['position'], str(text), fill=(0, 0, 0), font=font)
                print(f"Текст добавлен с параметрами по умолчанию")
            except Exception as fallback_error:
                print(f"Критическая ошибка добавления текста: {fallback_error}")

    def add_image(self, base_image, placeholder_config, image_path):
        try:
            if not os.path.exists(image_path):
                print(f"Файл изображения не найден: {image_path}")
                return

            img = Image.open(image_path)
            size = placeholder_config['size']
            position = placeholder_config['position']

            # Конвертируем в RGB если необходимо
            if img.mode not in ('RGB', 'RGBA'):
                img = img.convert('RGB')

            # Изменяем размер изображения под placeholder
            img = img.resize(size, Image.Resampling.LANCZOS)

            # Вставляем изображение
            if img.mode == 'RGBA':
                base_image.paste(img, position, img)
            else:
                base_image.paste(img, position)

        except Exception as e:
            print(f"Ошибка при добавлении изображения: {e}")
            # Создаем placeholder изображение в случае ошибки
            try:
                size = placeholder_config['size']
                position = placeholder_config['position']
                placeholder_img = Image.new('RGB', size, (200, 200, 200))
                base_image.paste(placeholder_img, position)
            except:
                pass

    def add_processed_image(self, base_image, placeholder_config, processed_img):
        """Добавляет обработанное изображение на документ"""
        try:
            size = placeholder_config['size']
            position = placeholder_config['position']

            # Изменяем размер изображения под placeholder
            processed_img = processed_img.resize(size, Image.Resampling.LANCZOS)

            # Вставляем изображение с учетом альфа-канала
            base_image.paste(processed_img, position, processed_img)

        except Exception as e:
            print(f"Ошибка при добавлении обработанного изображения: {e}")


class ConversionWorker(QThread):
    progress_updated = pyqtSignal(int, int, str)
    log_updated = pyqtSignal(str)
    finished_signal = pyqtSignal(bool, str)

    def __init__(self, psd_path, output_dir):
        super().__init__()
        self.psd_path = psd_path
        self.output_dir = output_dir

    def run(self):
        try:
            # Подавляем предупреждения psd-tools
            import warnings
            warnings.filterwarnings('ignore', message='Unknown image resource*')
            warnings.filterwarnings('ignore', category=UserWarning, module='psd_tools')

            self.log_updated.emit("🔄 Начало конвертации...")

            # Создаем анализатор
            self.log_updated.emit("📂 Загрузка PSD файла...")
            analyzer = PSDTemplateAnalyzer(self.psd_path)

            # Анализируем слои
            self.log_updated.emit("🔍 Анализ слоев PSD...")
            analyzer.analyze_layers(self.progress_updated)

            # Создаем директории
            assets_dir = os.path.join(self.output_dir, 'assets')
            os.makedirs(assets_dir, exist_ok=True)

            # Создаем фон
            self.log_updated.emit("🎨 Создание фонового изображения...")
            background = analyzer.create_background(self.progress_updated)
            background_path = os.path.join(assets_dir, 'background.png')
            background.save(background_path)
            self.log_updated.emit(f"💾 Фон сохранен: {background_path}")

            # Сохраняем конфигурацию
            config_path = os.path.join(self.output_dir, 'template_config.json')
            with open(config_path, 'w', encoding='utf-8') as f:
                json.dump(analyzer.template_data, f, ensure_ascii=False, indent=2)
            self.log_updated.emit(f"⚙️ Конфигурация сохранена: {config_path}")

            # Статистика
            text_layers = len(analyzer.template_data['text_layers'])
            placeholders = len(analyzer.template_data['image_placeholders'])

            self.log_updated.emit(f"📊 Статистика анализа:")
            self.log_updated.emit(f"   • Текстовых полей: {text_layers}")
            self.log_updated.emit(f"   • Placeholder'ов изображений: {placeholders}")
            self.log_updated.emit(f"   • Размер документа: {analyzer.template_data['dimensions']}")

            # Выводим информацию о найденных полях
            template_fields = [layer for layer in analyzer.template_data['text_layers']
                               if layer.get('is_template_field')]
            if template_fields:
                self.log_updated.emit(f"🎯 Определенные поля шаблона:")
                for field in template_fields:
                    field_name = field['is_template_field']
                    font_size = field['font_info']['size']
                    font_family = field['font_info']['family']
                    self.log_updated.emit(f"   • {field_name}: {font_family}, {font_size}px")

            self.log_updated.emit(f"✅ Шаблон успешно создан в: {self.output_dir}")

            self.finished_signal.emit(True, "Конвертация завершена успешно!")

        except Exception as e:
            error_msg = f"Ошибка конвертации: {str(e)}"
            self.log_updated.emit(f"❌ {error_msg}")

            # Выводим более подробную информацию об ошибке
            import traceback
            detailed_error = traceback.format_exc()
            self.log_updated.emit("🔍 Подробная информация об ошибке:")
            for line in detailed_error.split('\n'):
                if line.strip():
                    self.log_updated.emit(f"   {line}")

            self.finished_signal.emit(False, error_msg)


class PSDConverterWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        # Выбор файла PSD
        file_group = QGroupBox("Выбор PSD файла")
        file_layout = QHBoxLayout()

        self.psd_path_edit = QLineEdit()
        self.psd_path_edit.setPlaceholderText("Выберите PSD файл...")
        self.psd_path_edit.setStyleSheet("""
            QLineEdit {
                padding: 8px 12px;
                border: 2px solid #e0e0e0;
                border-radius: 6px;
                background-color: white;
                color: #2c3e50;
                font-size: 11px;
                selection-background-color: #3498db;
                selection-color: white;
            }
            QLineEdit:focus {
                border-color: #2196F3;
                background-color: #f8f9ff;
                color: #2c3e50;
            }
            QLineEdit:hover {
                border-color: #90caf9;
                color: #2c3e50;
            }
            QLineEdit::placeholder {
                color: #95a5a6;
            }
        """)

        browse_btn = QPushButton("Обзор...")
        browse_btn.clicked.connect(self.browse_psd)
        browse_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #6c757d, stop: 1 #5a6268);
                color: white;
                border: none;
                padding: 8px 16px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 11px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #7c868d, stop: 1 #6c757d);
            }
        """)

        convert_btn = QPushButton("Конвертировать")
        convert_btn.clicked.connect(self.convert_psd)
        convert_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #4CAF50, stop: 1 #45a049);
                color: white;
                border: none;
                padding: 10px 20px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #5CBF60, stop: 1 #4CAF50);
                box-shadow: 0 2px 8px rgba(76, 175, 80, 0.3);
            }
            QPushButton:pressed {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #3d8b40, stop: 1 #2e7d32);
            }
        """)

        file_layout.addWidget(self.psd_path_edit)
        file_layout.addWidget(browse_btn)
        file_layout.addWidget(convert_btn)
        file_group.setLayout(file_layout)

        # Прогресс бар
        progress_group = QGroupBox("Прогресс")
        progress_layout = QVBoxLayout()

        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)

        self.progress_label = QLabel("Готов к работе")
        self.progress_label.setAlignment(Qt.AlignmentFlag.AlignCenter)

        progress_layout.addWidget(self.progress_bar)
        progress_layout.addWidget(self.progress_label)
        progress_group.setLayout(progress_layout)

        # Лог конвертации
        log_group = QGroupBox("Лог конвертации")
        log_layout = QVBoxLayout()

        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)
        self.log_text.setFont(QFont("Consolas", 9))
        self.log_text.setStyleSheet("""
            QTextEdit {
                background-color: #1e1e1e;
                color: #ffffff;
                border: 1px solid #404040;
                border-radius: 6px;
                padding: 8px;
                selection-background-color: #264f78;
            }
        """)

        clear_log_btn = QPushButton("Очистить лог")
        clear_log_btn.clicked.connect(self.log_text.clear)
        clear_log_btn.setStyleSheet("""
            QPushButton {
                background-color: #6c757d;
                color: white;
                border: none;
                padding: 6px 12px;
                border-radius: 4px;
                font-size: 11px;
            }
            QPushButton:hover {
                background-color: #5a6268;
            }
        """)

        log_layout.addWidget(self.log_text)
        log_layout.addWidget(clear_log_btn)
        log_group.setLayout(log_layout)

        layout.addWidget(file_group)
        layout.addWidget(progress_group)
        layout.addWidget(log_group)

        self.setLayout(layout)

        if not PSD_AVAILABLE:
            self.log_message("⚠️ ПРЕДУПРЕЖДЕНИЕ: psd-tools не установлен!")
            self.log_message("Установите: pip install psd-tools")

    def browse_psd(self):
        filename, _ = QFileDialog.getOpenFileName(
            self, "Выберите PSD файл", "", "PSD files (*.psd);;All files (*.*)"
        )
        if filename:
            self.psd_path_edit.setText(filename)

    def log_message(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        formatted_message = f"[{timestamp}] {message}"
        self.log_text.append(formatted_message)
        # Прокручиваем к концу
        cursor = self.log_text.textCursor()
        cursor.movePosition(cursor.MoveOperation.End)
        self.log_text.setTextCursor(cursor)

    def update_progress(self, current, total, message):
        if total > 0:
            progress = int((current / total) * 100)
            self.progress_bar.setValue(progress)
        self.progress_label.setText(message)

    def convert_psd(self):
        if not self.psd_path_edit.text():
            QMessageBox.critical(self, "Ошибка", "Выберите PSD файл")
            return

        if not PSD_AVAILABLE:
            QMessageBox.critical(self, "Ошибка", "psd-tools не установлен")
            return

        output_dir = QFileDialog.getExistingDirectory(
            self, "Выберите папку для сохранения шаблона"
        )
        if not output_dir:
            return

        # Создаем и запускаем worker thread
        self.worker = ConversionWorker(self.psd_path_edit.text(), output_dir)
        self.worker.progress_updated.connect(self.update_progress)
        self.worker.log_updated.connect(self.log_message)
        self.worker.finished_signal.connect(self.conversion_finished)

        self.progress_bar.setValue(0)
        self.worker.start()

    def conversion_finished(self, success, message):
        if success:
            self.progress_bar.setValue(100)
            self.progress_label.setText("Конвертация завершена!")
            self.log_message("✅ Конвертация завершена успешно!")
            QMessageBox.information(self, "Успех", message)
        else:
            QMessageBox.critical(self, "Ошибка", message)


class DocumentGeneratorWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.current_template = None
        self.preview_image = None
        self.init_ui()

    def init_ui(self):
        # Основной layout с разделителем
        splitter = QSplitter(Qt.Orientation.Horizontal)

        # Левая панель - форма
        left_widget = QWidget()
        left_layout = QVBoxLayout()

        # Загрузка шаблона
        template_group = QGroupBox("Шаблон")
        template_layout = QVBoxLayout()

        load_template_btn = QPushButton("Загрузить шаблон")
        load_template_btn.clicked.connect(self.load_template)
        load_template_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #2196F3, stop: 1 #1976D2);
                color: white;
                border: none;
                padding: 12px 20px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #42A5F5, stop: 1 #2196F3);
                box-shadow: 0 2px 8px rgba(33, 150, 243, 0.3);
            }
            QPushButton:pressed {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #1565C0, stop: 1 #0d47a1);
            }
        """)

        self.template_info_label = QLabel("Шаблон не загружен")
        self.template_info_label.setWordWrap(True)
        self.template_info_label.setStyleSheet("color: #666; padding: 5px;")

        template_layout.addWidget(load_template_btn)
        template_layout.addWidget(self.template_info_label)
        template_group.setLayout(template_layout)

        # Создаем скролл для формы
        form_scroll = QScrollArea()
        form_scroll.setWidgetResizable(True)
        form_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)

        # Контейнер для формы
        form_container = QWidget()
        form_layout = QFormLayout()

        # Форма данных
        form_group = QGroupBox("Данные документа")

        self.form_fields = {}

        # Обновленный список полей
        fields = [
            ('number', 'Номер ID:'),
            ('address', 'Адрес:'),
            ('height', 'Рост:'),
            ('colorEyes', 'Цвет глаз:'),
            ('authority', 'Место выдачи:'),
            ('date_hidden', 'Срок истечения 2:'),
            ('date', 'Дата выдачи:'),
            ('idd2', 'Голограф.полоска:'),
            ('idd1', 'IDD оборот:'),
            ('idd3', 'Мелкий IDD:'),
            ('seria', 'Серия ID:'),
            ('family', 'Фамилия:'),
            ('Dateexpiry', 'Срок истечения:'),
            ('placebirth', 'Место рождения:'),
            ('nation', 'Нация:'),
            ('birthday', 'Дата рождения:'),
            ('name', 'Имя:'),
            ('golograf_id', 'ID голограмма:')
        ]

        for field_key, field_label in fields:
            # Создаем метку
            label = QLabel(field_label)
            label.setStyleSheet("""
                QLabel {
                    font-weight: bold;
                    color: #2c3e50;
                    padding: 4px 0;
                }
            """)

            # Создаем контейнер для поля и настроек шрифта
            field_container = QWidget()
            field_layout = QHBoxLayout()
            field_layout.setContentsMargins(0, 0, 0, 0)

            # Создаем поле ввода
            line_edit = QLineEdit()
            line_edit.textChanged.connect(self.update_preview)
            line_edit.setStyleSheet("""
                QLineEdit {
                    padding: 8px 12px;
                    border: 2px solid #e0e0e0;
                    border-radius: 6px;
                    background-color: white;
                    color: #2c3e50;
                    font-size: 11px;
                    selection-background-color: #3498db;
                    selection-color: white;
                }
                QLineEdit:focus {
                    border-color: #2196F3;
                    background-color: #f8f9ff;
                    color: #2c3e50;
                }
                QLineEdit:hover {
                    border-color: #90caf9;
                    color: #2c3e50;
                }
                QLineEdit::placeholder {
                    color: #95a5a6;
                }
            """)

            # Создаем спинбокс для размера шрифта
            font_size_spin = QSpinBox()
            font_size_spin.setRange(8, 200)
            font_size_spin.setValue(16)  # Значение по умолчанию
            font_size_spin.setSuffix("px")
            font_size_spin.setFixedWidth(70)
            font_size_spin.valueChanged.connect(self.update_preview)
            font_size_spin.setStyleSheet("""
                QSpinBox {
                    padding: 6px;
                    border: 2px solid #e0e0e0;
                    border-radius: 4px;
                    background-color: white;
                    color: #2c3e50;
                    font-size: 10px;
                }
                QSpinBox:focus {
                    border-color: #2196F3;
                }
            """)

            # Добавляем в контейнер
            field_layout.addWidget(line_edit, 1)  # Растягивающееся поле
            field_layout.addWidget(font_size_spin, 0)  # Фиксированный размер
            field_container.setLayout(field_layout)

            # Сохраняем ссылки
            self.form_fields[field_key] = {
                'text': line_edit,
                'font_size': font_size_spin
            }

            # Добавляем в форму метку и контейнер
            form_layout.addRow(label, field_container)

        # Выбор фото - создаем отдельно для лучшего контроля
        photo_label = QLabel("Фото:")
        photo_label.setStyleSheet("""
            QLabel {
                font-weight: bold;
                color: #2c3e50;
                padding: 4px 0;
            }
        """)

        photo_layout = QHBoxLayout()
        self.photo_path_edit = QLineEdit()
        self.photo_path_edit.setPlaceholderText("Выберите фото...")
        self.photo_path_edit.textChanged.connect(self.update_preview)
        self.photo_path_edit.setStyleSheet("""
            QLineEdit {
                padding: 8px 12px;
                border: 2px solid #e0e0e0;
                border-radius: 6px;
                background-color: white;
                color: #2c3e50;
                font-size: 11px;
                selection-background-color: #3498db;
                selection-color: white;
            }
            QLineEdit:focus {
                border-color: #2196F3;
                background-color: #f8f9ff;
                color: #2c3e50;
            }
            QLineEdit:hover {
                border-color: #90caf9;
                color: #2c3e50;
            }
            QLineEdit::placeholder {
                color: #95a5a6;
            }
        """)

        browse_photo_btn = QPushButton("...")
        browse_photo_btn.clicked.connect(self.browse_photo)
        browse_photo_btn.setFixedWidth(40)
        browse_photo_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #6c757d, stop: 1 #5a6268);
                color: white;
                border: none;
                padding: 8px;
                border-radius: 6px;
                font-weight: bold;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #7c868d, stop: 1 #6c757d);
            }
        """)

        photo_layout.addWidget(self.photo_path_edit)
        photo_layout.addWidget(browse_photo_btn)

        # Создаем контейнер для фото
        photo_container = QWidget()
        photo_container.setLayout(photo_layout)

        form_layout.addRow(photo_label, photo_container)

        form_container.setLayout(form_layout)
        form_scroll.setWidget(form_container)

        form_group_layout = QVBoxLayout()
        form_group_layout.addWidget(form_scroll)
        form_group.setLayout(form_group_layout)

        # Кнопки действий
        actions_group = QGroupBox("Действия")
        actions_layout = QVBoxLayout()

        preview_btn = QPushButton("🔄 Обновить предпросмотр")
        preview_btn.clicked.connect(self.update_preview)
        preview_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #17a2b8, stop: 1 #138496);
                color: white;
                border: none;
                padding: 10px 16px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #20c4e0, stop: 1 #17a2b8);
            }
        """)

        save_btn = QPushButton("💾 Сохранить документ")
        save_btn.clicked.connect(self.save_document)
        save_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #28a745, stop: 1 #218838);
                color: white;
                border: none;
                padding: 12px 20px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 12px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #34ce57, stop: 1 #28a745);
                box-shadow: 0 2px 8px rgba(40, 167, 69, 0.3);
            }
            QPushButton:pressed {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #1e7e34, stop: 1 #155724);
            }
        """)

        load_font_sizes_btn = QPushButton("📏 Загрузить размеры из шаблона")
        load_font_sizes_btn.clicked.connect(self.load_font_sizes_from_template)
        load_font_sizes_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #6f42c1, stop: 1 #563d7c);
                color: white;
                border: none;
                padding: 8px 16px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 11px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #8a63d2, stop: 1 #6f42c1);
            }
        """)

        test_data_btn = QPushButton("📝 Заполнить тестовыми данными")
        test_data_btn.clicked.connect(self.fill_test_data)
        test_data_btn.setStyleSheet("""
            QPushButton {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #ffc107, stop: 1 #e0a800);
                color: #212529;
                border: none;
                padding: 8px 16px;
                border-radius: 6px;
                font-weight: bold;
                font-size: 11px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #ffcd39, stop: 1 #ffc107);
            }
        """)

        # Общие настройки шрифта
        font_settings_frame = QFrame()
        font_settings_frame.setStyleSheet("""
            QFrame {
                border: 1px solid #dee2e6;
                border-radius: 6px;
                background-color: #f8f9fa;
                margin: 5px 0;
            }
        """)
        font_settings_layout = QVBoxLayout()

        font_settings_label = QLabel("⚙️ Общие настройки шрифта:")
        font_settings_label.setStyleSheet("font-weight: bold; color: #495057; margin: 5px;")

        global_font_layout = QHBoxLayout()
        global_font_layout.addWidget(QLabel("Глобальный размер:"))

        self.global_font_size_spin = QSpinBox()
        self.global_font_size_spin.setRange(8, 200)
        self.global_font_size_spin.setValue(16)
        self.global_font_size_spin.setSuffix("px")
        self.global_font_size_spin.setFixedWidth(80)

        apply_global_btn = QPushButton("Применить ко всем")
        apply_global_btn.clicked.connect(self.apply_global_font_size)
        apply_global_btn.setFixedWidth(120)
        apply_global_btn.setStyleSheet("""
            QPushButton {
                background-color: #6c757d;
                color: white;
                border: none;
                padding: 4px 8px;
                border-radius: 4px;
                font-size: 10px;
            }
            QPushButton:hover {
                background-color: #5a6268;
            }
        """)

        global_font_layout.addWidget(self.global_font_size_spin)
        global_font_layout.addWidget(apply_global_btn)
        global_font_layout.addStretch()

        font_settings_layout.addWidget(font_settings_label)
        font_settings_layout.addLayout(global_font_layout)
        font_settings_frame.setLayout(font_settings_layout)

        actions_layout.addWidget(preview_btn)
        actions_layout.addWidget(save_btn)
        actions_layout.addWidget(load_font_sizes_btn)
        actions_layout.addWidget(test_data_btn)
        actions_layout.addWidget(font_settings_frame)
        actions_layout.addStretch()  # Добавляем растяжение внизу
        actions_group.setLayout(actions_layout)

        # Собираем левую панель
        left_layout.addWidget(template_group)
        left_layout.addWidget(form_group, 1)  # Растягиваем форму
        left_layout.addWidget(actions_group)
        left_widget.setLayout(left_layout)
        left_widget.setMinimumWidth(400)  # Увеличиваем минимальную ширину
        left_widget.setMaximumWidth(500)  # Увеличиваем максимальную ширину

        # Правая панель - предпросмотр
        right_widget = QWidget()
        right_layout = QVBoxLayout()

        preview_group = QGroupBox("Предпросмотр")
        preview_layout = QVBoxLayout()

        # Scroll area для предпросмотра
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setAlignment(Qt.AlignmentFlag.AlignCenter)

        self.preview_label = QLabel()
        self.preview_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.preview_label.setMinimumSize(400, 300)
        self.preview_label.setStyleSheet("""
            QLabel {
                border: 3px dashed #b0bec5;
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 1,
                    stop: 0 #f5f5f5, stop: 1 #eeeeee);
                color: #757575;
                border-radius: 12px;
                font-size: 14px;
                font-weight: bold;
            }
        """)
        self.preview_label.setText("Загрузите шаблон\nдля предпросмотра")

        scroll_area.setWidget(self.preview_label)

        self.preview_info_label = QLabel("Загрузите шаблон для предпросмотра")
        self.preview_info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.preview_info_label.setStyleSheet("color: #666; padding: 10px;")

        preview_layout.addWidget(scroll_area)
        preview_layout.addWidget(self.preview_info_label)
        preview_group.setLayout(preview_layout)

        right_layout.addWidget(preview_group)
        right_widget.setLayout(right_layout)

        # Добавляем в splitter
        splitter.addWidget(left_widget)
        splitter.addWidget(right_widget)
        splitter.setStretchFactor(0, 0)
        splitter.setStretchFactor(1, 1)

        # Основной layout
        main_layout = QHBoxLayout()
        main_layout.addWidget(splitter)
        self.setLayout(main_layout)

    def load_template(self):
        config_path, _ = QFileDialog.getOpenFileName(
            self, "Выберите файл конфигурации шаблона", "",
            "JSON files (*.json);;All files (*.*)"
        )

        if config_path:
            try:
                assets_dir = os.path.join(os.path.dirname(config_path), 'assets')
                self.current_template = DocumentTemplate(config_path, assets_dir)

                dimensions = self.current_template.config['dimensions']
                text_fields = len(self.current_template.config['text_layers'])

                info_text = f"✅ Шаблон загружен\n📐 Размер: {dimensions[0]}x{dimensions[1]}\n📝 Текстовых полей: {text_fields}"
                self.template_info_label.setText(info_text)
                self.template_info_label.setStyleSheet("color: #4CAF50; padding: 5px;")

                self.update_preview()

            except Exception as e:
                QMessageBox.critical(self, "Ошибка", f"Ошибка загрузки шаблона: {str(e)}")

    def browse_photo(self):
        filename, _ = QFileDialog.getOpenFileName(
            self, "Выберите фото", "",
            "Image files (*.png *.jpg *.jpeg *.bmp *.gif);;All files (*.*)"
        )
        if filename:
            self.photo_path_edit.setText(filename)

    def fill_test_data(self):
        test_data = {
            'number': 'ID123456789',
            'address': 'ул. Тестовая, д. 1, кв. 1',
            'height': '180 см',
            'colorEyes': 'Карие',
            'authority': 'УФМС России по г. Москва',
            'date_hidden': '31.12.2035',
            'date': '01.01.2020',
            'idd2': 'HOLOGRAM123',
            'idd1': 'IDD-BACK-001',
            'idd3': 'IDD-SMALL-001',
            'seria': 'AB',
            'family': 'ИВАНОВ',
            'Dateexpiry': '01.01.2030',
            'placebirth': 'г. Москва',
            'nation': 'Россия',
            'birthday': '01.01.1990',
            'name': 'ИВАН',
            'golograf_id': 'HOLO-ID-001'
        }

        for field, value in test_data.items():
            if field in self.form_fields:
                self.form_fields[field]['text'].setText(value)

    def update_preview(self):
        if not self.current_template:
            return

        try:
            # Собираем данные из формы
            data = {}
            font_overrides = {}  # Переопределения размеров шрифтов

            for field, field_data in self.form_fields.items():
                if isinstance(field_data, dict):
                    # Новый формат с настройками шрифта
                    text_value = field_data['text'].text().strip()
                    font_size = field_data['font_size'].value()

                    if text_value:
                        data[field] = text_value
                        font_overrides[field] = font_size
                else:
                    # Старый формат (совместимость)
                    text_value = field_data.text().strip()
                    if text_value:
                        data[field] = text_value

            if self.photo_path_edit.text().strip():
                photo_path = self.photo_path_edit.text().strip()
                if os.path.exists(photo_path):
                    data['photo'] = photo_path
                else:
                    print(f"Предупреждение: файл фото не найден: {photo_path}")

            print(f"Данные для создания документа: {data}")
            print(f"Переопределения размеров шрифтов: {font_overrides}")

            # Создаем документ с переопределениями размеров
            self.preview_image = self.current_template.create_document(data, font_overrides)

            # Конвертируем в QPixmap для отображения
            qt_image = ImageQt.ImageQt(self.preview_image)
            pixmap = QPixmap.fromImage(qt_image)

            # Масштабируем для предпросмотра (максимум 600px по ширине)
            if pixmap.width() > 600:
                pixmap = pixmap.scaledToWidth(600, Qt.TransformationMode.SmoothTransformation)

            self.preview_label.setPixmap(pixmap)
            self.preview_label.setScaledContents(False)
            self.preview_label.resize(pixmap.size())

            self.preview_info_label.setText(f"Предпросмотр: {pixmap.width()}x{pixmap.height()}")

        except Exception as e:
            print(f"Ошибка предпросмотра: {e}")
            import traceback
            traceback.print_exc()
            self.preview_label.setText(f"Ошибка предпросмотра:\n{str(e)}")
            self.preview_label.setPixmap(QPixmap())  # Очищаем изображение

    def save_document(self):
        if not self.current_template or not self.preview_image:
            QMessageBox.critical(self, "Ошибка", "Создайте предпросмотр документа")
            return

        filename, _ = QFileDialog.getSaveFileName(
            self, "Сохранить документ", "",
            "PNG files (*.png);;JPEG files (*.jpg);;All files (*.*)"
        )

        if filename:
            try:
                self.preview_image.save(filename)
                QMessageBox.information(self, "Успех", f"Документ сохранен:\n{filename}")
            except Exception as e:
                QMessageBox.critical(self, "Ошибка", f"Ошибка сохранения:\n{str(e)}")

    def load_font_sizes_from_template(self):
        """Загружает размеры шрифтов из конфигурации шаблона"""
        if not self.current_template:
            QMessageBox.warning(self, "Предупреждение", "Сначала загрузите шаблон")
            return

        try:
            loaded_count = 0
            for layer in self.current_template.config.get('text_layers', []):
                field_key = layer.get('is_template_field')
                if field_key and field_key in self.form_fields:
                    font_size = layer.get('font_info', {}).get('size', 16)
                    self.form_fields[field_key]['font_size'].setValue(font_size)
                    loaded_count += 1

            QMessageBox.information(self, "Успех",
                                    f"Загружено размеров шрифтов: {loaded_count}")
            self.update_preview()

        except Exception as e:
            QMessageBox.critical(self, "Ошибка",
                                 f"Ошибка загрузки размеров шрифтов:\n{str(e)}")

    def apply_global_font_size(self):
        """Применяет глобальный размер шрифта ко всем полям"""
        global_size = self.global_font_size_spin.value()

        for field_data in self.form_fields.values():
            if isinstance(field_data, dict) and 'font_size' in field_data:
                field_data['font_size'].setValue(global_size)

        self.update_preview()


class PSDConverterMainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("PSD Template Converter & Document Generator")
        self.setGeometry(100, 100, 1400, 900)

        # Устанавливаем иконку (если есть)
        # self.setWindowIcon(QIcon('icon.png'))

        # Создаем центральный виджет с вкладками
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        layout = QVBoxLayout()

        # Заголовок
        title_label = QLabel("🎨 PSD Template Converter & Document Generator")
        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        title_label.setFont(QFont("Arial", 16, QFont.Weight.Bold))
        title_label.setStyleSheet("""
            QLabel {
                color: white;
                padding: 20px;
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 #667eea, stop: 1 #764ba2);
                border-radius: 12px;
                margin-bottom: 15px;
                border: 2px solid #5a67d8;
            }
        """)

        # Создаем вкладки
        self.tab_widget = QTabWidget()
        self.tab_widget.setStyleSheet("""
            QTabWidget::pane {
                border: 2px solid #e1e5e9;
                border-radius: 10px;
                background-color: #ffffff;
                margin-top: 2px;
            }
            QTabBar::tab {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #f8f9fa, stop: 1 #e9ecef);
                color: #495057;
                padding: 12px 20px;
                margin-right: 4px;
                border-top-left-radius: 8px;
                border-top-right-radius: 8px;
                border: 2px solid #dee2e6;
                border-bottom: none;
                font-weight: bold;
                font-size: 12px;
            }
            QTabBar::tab:selected {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #667eea, stop: 1 #764ba2);
                color: white;
                border-color: #5a67d8;
            }
            QTabBar::tab:hover:!selected {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #e3f2fd, stop: 1 #bbdefb);
                color: #1976d2;
            }
        """)

        # Вкладка конвертера
        self.converter_widget = PSDConverterWidget()
        self.tab_widget.addTab(self.converter_widget, "🔄 Конвертер PSD")

        # Вкладка генератора
        self.generator_widget = DocumentGeneratorWidget()
        self.tab_widget.addTab(self.generator_widget, "📄 Генератор документов")

        layout.addWidget(title_label)
        layout.addWidget(self.tab_widget)

        central_widget.setLayout(layout)

        # Устанавливаем стиль приложения
        self.setStyleSheet("""
            QMainWindow {
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 1,
                    stop: 0 #f0f2f5, stop: 1 #e8ebef);
            }
            QGroupBox {
                font-weight: bold;
                border: 2px solid #c2c8d0;
                border-radius: 10px;
                margin-top: 15px;
                padding-top: 15px;
                background-color: rgba(255, 255, 255, 0.9);
                color: #2c3e50;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 15px;
                padding: 0 8px 0 8px;
                color: #34495e;
                font-size: 13px;
                background-color: white;
                border-radius: 4px;
            }
            QPushButton {
                padding: 8px 16px;
                border-radius: 6px;
                border: 2px solid #bdc3c7;
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #ffffff, stop: 1 #f8f9fa);
                color: #495057;
                font-weight: 500;
                font-size: 11px;
            }
            QPushButton:hover {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #f8f9fa, stop: 1 #e9ecef);
                border-color: #95a5a6;
                color: #2c3e50;
            }
            QPushButton:pressed {
                background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                    stop: 0 #e9ecef, stop: 1 #dee2e6);
                border-color: #7f8c8d;
            }
            QProgressBar {
                border: 2px solid #bdc3c7;
                border-radius: 8px;
                background-color: #ecf0f1;
                text-align: center;
                font-weight: bold;
                color: #2c3e50;
                height: 25px;
            }
            QProgressBar::chunk {
                background: qlineargradient(x1: 0, y1: 0, x2: 1, y2: 0,
                    stop: 0 #3498db, stop: 1 #2980b9);
                border-radius: 6px;
                margin: 2px;
            }
        """)

        # Статусная строка
        self.statusBar().showMessage("Готов к работе")

        # Центрируем окно
        self.center_window()

    def center_window(self):
        """Центрирует окно на экране"""
        screen = QApplication.primaryScreen().geometry()
        window = self.geometry()
        x = (screen.width() - window.width()) // 2
        y = (screen.height() - window.height()) // 2
        self.move(x, y)


def main():
    # Подавляем предупреждения psd-tools
    import warnings
    warnings.filterwarnings('ignore', message='Unknown image resource*')
    warnings.filterwarnings('ignore', category=UserWarning, module='psd_tools')

    app = QApplication(sys.argv)

    # Устанавливаем стиль приложения
    app.setStyle('Fusion')

    # Устанавливаем информацию о приложении
    app.setApplicationName("PSD Template Converter")
    app.setApplicationVersion("1.0")
    app.setOrganizationName("Template Tools")

    try:
        # Создаем и отображаем главное окно
        window = PSDConverterMainWindow()
        window.show()

        # Проверяем доступность psd-tools при старте
        if not PSD_AVAILABLE:
            QMessageBox.warning(
                window,
                "Предупреждение",
                "⚠️ psd-tools не установлен!\n\n"
                "Для работы с PSD файлами установите:\n"
                "pip install psd-tools\n\n"
                "Без этой библиотеки конвертер работать не будет."
            )
        else:
            window.statusBar().showMessage("✅ Готов к работе - psd-tools загружен")

        sys.exit(app.exec())

    except Exception as e:
        print(f"Критическая ошибка приложения: {e}")
        import traceback
        traceback.print_exc()

        # Показываем диалог ошибки если возможно
        try:
            QMessageBox.critical(
                None,
                "Критическая ошибка",
                f"Не удалось запустить приложение:\n\n{str(e)}\n\n"
                f"Проверьте установку зависимостей:\n"
                f"pip install PyQt6 Pillow psd-tools"
            )
        except:
            pass

        sys.exit(1)


if __name__ == "__main__":
    main()

Для запуска требуется:

pip install PyQt6
pip install Pillow
pip install psd-tools

 

[shrekushka]

http://xssforum7mmh3n56inuf2h73hvhnzobi7h2ytb3gvklrfqm7ut3xdnyd.onion/attachments/108383/?hash=11abf7f2fde0e486de5f18be6f1876feПосмотреть вложение 108384
I can use prompts for ChatGPT API in the same way — the only question is how long it takes to generate a single image. In any case, thanks for the model, I’ll play around with it tonight.

Wait I was trolling wtf

 

[Darkxss]

rand can you please share in private i don't have enough reactions Thanks.