| | |
| | |
| |
|
| | from __future__ import annotations |
| |
|
| | import math |
| | import re |
| | import os |
| | import io |
| | from math import gcd, lcm |
| | from typing import List, Tuple, Literal, Dict, Optional |
| |
|
| | import gradio as gr |
| | from PIL import Image |
| |
|
| | |
| | |
| | |
| |
|
| | RoundingMode = Literal["round", "floor", "ceil"] |
| | ModelFamily = Literal["SDXL (native~1024)", "SD 1.x (native~512)", "SD 2.x (native~768)"] |
| |
|
| | DEFAULT_MODEL_FAMILY: ModelFamily = "SDXL (native~1024)" |
| |
|
| | def ensure_multiple(value: int, multiple: int, mode: RoundingMode = "round") -> int: |
| | if multiple <= 1: |
| | return max(1, value) |
| | q, r = divmod(value, multiple) |
| | if r == 0: |
| | return max(multiple, value) |
| | if mode == "floor": |
| | return max(multiple, q * multiple) |
| | if mode == "ceil": |
| | return (q + 1) * multiple |
| | lower = q * multiple |
| | upper = (q + 1) * multiple |
| | return upper if (value - lower) >= (upper - value) else lower |
| |
|
| | def simplified_ratio(width: int, height: int) -> str: |
| | if width <= 0 or height <= 0: |
| | return "—" |
| | g = gcd(width, height) |
| | return f"{width // g}:{height // g}" |
| |
|
| | def megapixels(width: int, height: int) -> float: |
| | return round((width * height) / 1_000_000.0, 3) |
| |
|
| | def parse_dims(text: str) -> List[Tuple[int, int]]: |
| | """Вытягивает все пары 'WxH' из произвольного текста.""" |
| | dims: List[Tuple[int, int]] = [] |
| | for w, h in re.findall(r"(\d{3,4})x(\d{3,4})", text): |
| | dims.append((int(w), int(h))) |
| | |
| | seen = set() |
| | uniq: List[Tuple[int, int]] = [] |
| | for d in dims: |
| | if d not in seen: |
| | seen.add(d) |
| | uniq.append(d) |
| | return uniq |
| |
|
| | |
| | |
| | |
| |
|
| | def pick_base_multiple_by_model(model_family: ModelFamily, target_max_side: Optional[int] = None) -> int: |
| | """ |
| | Эвристика: |
| | - SDXL: кратность 64 (родной 1024, датасеты шагом 64). |
| | - SD 2.x: минимум 16..32, чаще 32 в HD. |
| | - SD 1.x: минимум 8..16, чаще 32 в HD. |
| | """ |
| | if model_family == "SDXL (native~1024)": |
| | base = 64 |
| | elif model_family == "SD 2.x (native~768)": |
| | base = 32 |
| | else: |
| | base = 32 |
| | if target_max_side and target_max_side >= 1536: |
| | base = max(base, 64) |
| | return base |
| |
|
| | def combine_multiples(base_multiple: int, diffusion_tile: int = 0, vae_tile: int = 0) -> int: |
| | """ |
| | Объединяем ограничения: НОК(base_multiple, diffusion_tile, vae_tile). |
| | Нули игнорируются. Жёстко ограничим верх до 256. |
| | """ |
| | m = base_multiple |
| | for x in (diffusion_tile, vae_tile): |
| | if isinstance(x, int) and x >= 8: |
| | m = lcm(m, x) |
| | return max(8, min(m, 256)) |
| |
|
| | def explain_auto_multiple(model_family: ModelFamily, max_side: Optional[int], m_base: int, m_final: int, |
| | diffusion_tile: int, vae_tile: int) -> str: |
| | reasons = [f"модель: {model_family} -> base={m_base}"] |
| | if max_side: |
| | reasons.append(f"размер цели: ~{max_side}px") |
| | if diffusion_tile: |
| | reasons.append(f"diffusion tile={diffusion_tile}") |
| | if vae_tile: |
| | reasons.append(f"VAE tile={vae_tile}") |
| | if m_final != m_base: |
| | reasons.append(f"НОК -> {m_final}") |
| | return " | ".join(reasons) |
| |
|
| | def autopick_multiple(model_family: ModelFamily, |
| | diffusion_tile: int, |
| | vae_tile: int, |
| | width_hint: Optional[int], |
| | height_hint: Optional[int]) -> Tuple[int, str]: |
| | max_side = None |
| | if width_hint and height_hint: |
| | max_side = max(width_hint, height_hint) |
| | m_base = pick_base_multiple_by_model(model_family, max_side) |
| | m_final = combine_multiples(m_base, diffusion_tile, vae_tile) |
| | return m_final, explain_auto_multiple(model_family, max_side, m_base, m_final, diffusion_tile, vae_tile) |
| |
|
| | |
| | |
| | |
| |
|
| | def resize_by_shorter_side(image: Image.Image, target_shorter: int, multiple: int, mode: RoundingMode) -> Tuple[int, int]: |
| | w, h = image.size |
| | if w <= 0 or h <= 0 or target_shorter <= 0: |
| | return w, h |
| | scale = target_shorter / min(w, h) |
| | new_w = ensure_multiple(int(round(w * scale)), multiple, mode) |
| | new_h = ensure_multiple(int(round(h * scale)), multiple, mode) |
| | return new_w, new_h |
| |
|
| | def resize_to_pixel_count(image: Image.Image, target_pixels: int, multiple: int, mode: RoundingMode) -> Tuple[int, int]: |
| | w, h = image.size |
| | if w <= 0 or h <= 0 or target_pixels <= 0: |
| | return w, h |
| | scale = math.sqrt(target_pixels / (w * h)) |
| | new_w = ensure_multiple(int(round(w * scale)), multiple, mode) |
| | new_h = ensure_multiple(int(round(h * scale)), multiple, mode) |
| | return new_w, new_h |
| |
|
| | |
| | |
| | |
| |
|
| | def load_catalog_from_file(path: str) -> List[Tuple[int, int]]: |
| | if not os.path.isfile(path): |
| | return [] |
| | try: |
| | with open(path, "r", encoding="utf-8", errors="ignore") as f: |
| | text = f.read() |
| | return parse_dims(text) |
| | except Exception: |
| | return [] |
| |
|
| | _GRID_CACHE: Dict[Tuple[int, int, int], List[Tuple[int, int]]] = {} |
| |
|
| | def generate_grid_catalog(min_size: int, max_size: int, step: int) -> List[Tuple[int, int]]: |
| | """Генерация полной решётки кратных 'step' размеров в диапазоне [min_size, max_size], с кэшем.""" |
| | key = (min_size, max_size, step) |
| | cached = _GRID_CACHE.get(key) |
| | if cached is not None: |
| | return cached |
| | sizes = list(range(min_size, max_size + 1, step)) |
| | out: List[Tuple[int, int]] = [] |
| | for w in sizes: |
| | for h in sizes: |
| | out.append((w, h)) |
| | _GRID_CACHE[key] = out |
| | return out |
| |
|
| | def orientation_of(w: int, h: int) -> str: |
| | if w == h: |
| | return "square" |
| | return "landscape" if w > h else "portrait" |
| |
|
| | def aspect_tuple(w: int, h: int) -> Tuple[int, int]: |
| | g = gcd(w, h) |
| | return (w // g, h // g) |
| |
|
| | def _parse_aspect_tokens(aspect_str: str) -> List[Tuple[int, int, bool, float]]: |
| | """ |
| | Поддерживаем токены: |
| | - 'A:B' → точное совпадение |
| | - '~A:B' → приблизительное (±0.02 по умолчанию) |
| | - 'A:B@0.03' → точный A:B, но с допуском 0.03 (редкий кейс) |
| | - '~A:B@0.015' → приблизительный матч с явным допуском |
| | Возвращает список (ax, ay, approx, tol). |
| | """ |
| | out: List[Tuple[int, int, bool, float]] = [] |
| | if not aspect_str.strip(): |
| | return out |
| | tokens = [t.strip() for t in re.split(r"[;,]+", aspect_str) if t.strip()] |
| | for t in tokens: |
| | approx = t.startswith("~") |
| | if approx: |
| | t = t[1:].strip() |
| | tol = 0.02 if approx else 0.0 |
| | m = re.match(r"(\d+)\s*:\s*(\d+)(?:\s*@\s*(0\.\d+))?$", t) |
| | if not m: |
| | |
| | continue |
| | ax, ay = int(m.group(1)), int(m.group(2)) |
| | if m.group(3): |
| | tol = float(m.group(3)) |
| | out.append((ax, ay, approx or tol > 0.0, tol)) |
| | return out |
| |
|
| | def filter_catalog(catalog: List[Tuple[int, int]], |
| | min_width: int, max_width: int, |
| | min_height: int, max_height: int, |
| | min_mp: float, max_mp: float, |
| | multiple: int, |
| | orientation: str, |
| | aspect_str: str, |
| | limit: int, |
| | sort_key: str, |
| | sort_desc: bool) -> List[Dict]: |
| | aspect_tokens = _parse_aspect_tokens(aspect_str) |
| |
|
| | rows: List[Dict] = [] |
| | for (w, h) in catalog: |
| | if w < min_width or w > max_width: |
| | continue |
| | if h < min_height or h > max_height: |
| | continue |
| | if multiple > 1 and (w % multiple != 0 or h % multiple != 0): |
| | continue |
| | mp = (w * h) / 1_000_000.0 |
| | if mp < min_mp or mp > max_mp: |
| | continue |
| | ori = orientation_of(w, h) |
| | if orientation != "any" and ori != orientation: |
| | continue |
| |
|
| | |
| | if aspect_tokens: |
| | w0, h0 = aspect_tuple(w, h) |
| | ok = False |
| | for ax, ay, approx, tol in aspect_tokens: |
| | if approx: |
| | if abs((w / h) - (ax / ay)) <= (tol if tol > 0 else 0.02): |
| | ok = True |
| | break |
| | else: |
| | if (w0, h0) == (ax, ay): |
| | ok = True |
| | break |
| | if not ok: |
| | continue |
| |
|
| | rows.append({ |
| | "Width": w, |
| | "Height": h, |
| | "Aspect": f"{aspect_tuple(w,h)[0]}:{aspect_tuple(w,h)[1]}", |
| | "Orientation": ori, |
| | "MP": round(mp, 3) |
| | }) |
| |
|
| | |
| | key = { |
| | "MP": lambda r: r["MP"], |
| | "Width": lambda r: r["Width"], |
| | "Height": lambda r: r["Height"], |
| | }.get(sort_key, lambda r: (r["MP"], r["Width"], r["Height"])) |
| | rows.sort(key=key, reverse=sort_desc) |
| |
|
| | return rows[:limit] |
| |
|
| | def stringify_wh_list(rows: List[Dict]) -> str: |
| | return "\n".join(f"{r['Width']}x{r['Height']}" for r in rows) |
| |
|
| | |
| | |
| | |
| |
|
| | DEFAULT_SHORT_PRESETS = ["512", "768", "896"] |
| | DEFAULT_PIXEL_BASES = ["512", "640", "768", "832", "896", "1024", "1152", "1216", "1344", "1536"] |
| |
|
| | ROUNDING_CHOICES: List[RoundingMode] = ["round", "floor", "ceil"] |
| |
|
| | def _parse_int_list(str_list: List[str]) -> List[int]: |
| | out: List[int] = [] |
| | for s in str_list or []: |
| | m = re.search(r"\d+", s) |
| | if m: |
| | out.append(int(m.group(0))) |
| | return out |
| |
|
| | |
| |
|
| | def calculate_all( |
| | image: Image.Image, |
| | shorters_raw: List[str], |
| | bases_raw: List[str], |
| | use_autopick: bool, |
| | model_family: ModelFamily, |
| | diffusion_tile: int, |
| | vae_tile: int, |
| | manual_multiple: int, |
| | rounding_mode: RoundingMode, |
| | ): |
| | if image is None: |
| | raise gr.Error("Загрузите изображение слева.") |
| |
|
| | w, h = image.size |
| |
|
| | if use_autopick: |
| | m_auto, reason = autopick_multiple(model_family, diffusion_tile, vae_tile, w, h) |
| | rounding_multiple = m_auto |
| | reason_text = f"Auto multiple = **{m_auto}** — {reason}" |
| | else: |
| | rounding_multiple = manual_multiple |
| | reason_text = f"Manual multiple = **{manual_multiple}**" |
| |
|
| | shorters = _parse_int_list(shorters_raw) or _parse_int_list(DEFAULT_SHORT_PRESETS) |
| | bases = _parse_int_list(bases_raw) or _parse_int_list(DEFAULT_PIXEL_BASES) |
| |
|
| | rows = [] |
| |
|
| | |
| | for s in shorters: |
| | nw, nh = resize_by_shorter_side(image, s, rounding_multiple, rounding_mode) |
| | rows.append({ |
| | "Preset": f"short={s}", |
| | "Width": nw, |
| | "Height": nh, |
| | "Aspect": simplified_ratio(nw, nh), |
| | "Pixels": nw * nh, |
| | "MP": megapixels(nw, nh), |
| | }) |
| |
|
| | |
| | for base in bases: |
| | target_pixels = base * base |
| | nw, nh = resize_to_pixel_count(image, target_pixels, rounding_multiple, rounding_mode) |
| | rows.append({ |
| | "Preset": f"{base}² ({target_pixels:,})", |
| | "Width": nw, |
| | "Height": nh, |
| | "Aspect": simplified_ratio(nw, nh), |
| | "Pixels": nw * nh, |
| | "MP": megapixels(nw, nh), |
| | }) |
| |
|
| | original_info = f"Original: {w}x{h} | Aspect {simplified_ratio(w, h)} | {megapixels(w, h)} MP" |
| | return rows, stringify_wh_list(rows), original_info, reason_text |
| |
|
| | |
| |
|
| | CATALOG_PATH = os.path.join(os.getcwd(), "sdxl_resolutions_by_aspect.txt") |
| | _LOADED_CATALOG: Optional[List[Tuple[int, int]]] = None |
| |
|
| | def _load_or_generate(default_step: int) -> Tuple[List[Tuple[int, int]], str]: |
| | global _LOADED_CATALOG |
| | if _LOADED_CATALOG is None: |
| | candidates = [ |
| | CATALOG_PATH, |
| | os.path.join(os.getcwd(), "data", "sdxl_resolutions_by_aspect.txt"), |
| | "/mnt/data/sdxl_resolutions_by_aspect.txt", |
| | ] |
| | for p in candidates: |
| | cat = load_catalog_from_file(p) |
| | if cat: |
| | _LOADED_CATALOG = cat |
| | return _LOADED_CATALOG, f"Catalog: loaded from file ({len(cat)} items)." |
| | _LOADED_CATALOG = [] |
| | return _LOADED_CATALOG, f"Catalog: no file, you can GENERATE grid (step {default_step})." |
| |
|
| | def catalog_filter_action( |
| | use_file_catalog: bool, |
| | generate_min: int, |
| | generate_max: int, |
| | generate_step: int, |
| | filter_min_w: int, |
| | filter_max_w: int, |
| | filter_min_h: int, |
| | filter_max_h: int, |
| | filter_min_mp: float, |
| | filter_max_mp: float, |
| | filter_multiple: int, |
| | filter_orientation: str, |
| | filter_aspects: str, |
| | filter_limit: int, |
| | sort_key: str, |
| | sort_desc: bool, |
| | ): |
| | base_list, inf = _load_or_generate(generate_step) |
| | if use_file_catalog and base_list: |
| | catalog = base_list |
| | source = inf.replace("Catalog:", "Source:") |
| | else: |
| | |
| | generate_min = max(128, generate_min) |
| | generate_max = min(4096, max(generate_min, generate_max)) |
| | generate_step = max(8, generate_step) |
| | sizes = list(range(generate_min, generate_max + 1, generate_step)) |
| | est = len(sizes) ** 2 |
| | if est > 20000: |
| | |
| | mid = (generate_min + generate_max) // 2 |
| | half = max(generate_step * 5, (generate_max - generate_min) // 6) |
| | generate_min = max(128, mid - half) |
| | generate_max = min(4096, mid + half) |
| | catalog = generate_grid_catalog(generate_min, generate_max, generate_step) |
| | source = f"Source: generated grid {generate_min}..{generate_max} step={generate_step} ({len(catalog)} combos)" |
| |
|
| | rows = filter_catalog( |
| | catalog=catalog, |
| | min_width=filter_min_w, max_width=filter_max_w, |
| | min_height=filter_min_h, max_height=filter_max_h, |
| | min_mp=filter_min_mp, max_mp=filter_max_mp, |
| | multiple=filter_multiple, |
| | orientation=filter_orientation, |
| | aspect_str=filter_aspects, |
| | limit=filter_limit, |
| | sort_key=sort_key, |
| | sort_desc=sort_desc, |
| | ) |
| | return rows, stringify_wh_list(rows), source |
| |
|
| | def _rows_to_csv_bytes(rows: List[Dict]) -> bytes: |
| | import csv |
| | from io import StringIO |
| | buf = StringIO() |
| | w = csv.writer(buf) |
| | w.writerow(["Width", "Height", "Aspect", "Orientation", "MP"]) |
| | for r in rows: |
| | w.writerow([r["Width"], r["Height"], r["Aspect"], r["Orientation"], r["MP"]]) |
| | return buf.getvalue().encode("utf-8") |
| |
|
| | def _rows_to_json_bytes(rows: List[Dict]) -> bytes: |
| | import json |
| | return json.dumps(rows, ensure_ascii=False, indent=2).encode("utf-8") |
| |
|
| | def export_rows(rows: List[Dict], kind: str): |
| | """Возвращает tuple(filename, bytes) для gr.File()""" |
| | if not rows: |
| | raise gr.Error("Нет данных для экспорта — сначала примените фильтр.") |
| | if kind == "csv": |
| | data = _rows_to_csv_bytes(rows) |
| | name = "filtered_catalog.csv" |
| | else: |
| | data = _rows_to_json_bytes(rows) |
| | name = "filtered_catalog.json" |
| | path = os.path.join(os.getcwd(), name) |
| | with open(path, "wb") as f: |
| | f.write(data) |
| | return path |
| |
|
| | |
| | |
| | |
| |
|
| | def on_ui_tab_called(): |
| | with gr.Blocks() as ui: |
| | gr.Markdown("### 📐 Image Ratio & Resolution Catalog Pro \n" |
| | "Используйте файл SDXL пресетов, либо генерируйте сетку. " |
| | "Аспекты поддерживают токены `16:9, ~3:2, 21:9@0.03, ~9:16@0.015`.") |
| |
|
| | with gr.Row(): |
| | with gr.Column(scale=1): |
| | image = gr.Image(type="pil", source="upload", label="Изображение") |
| | original_info = gr.Markdown("") |
| |
|
| | with gr.Column(scale=1): |
| | |
| | use_autopick = gr.Checkbox(value=True, label="Auto multiple (рекомендуется)") |
| | model_family = gr.Radio( |
| | choices=["SDXL (native~1024)", "SD 1.x (native~512)", "SD 2.x (native~768)"], |
| | value=DEFAULT_MODEL_FAMILY, |
| | label="Model family (ручной выбор)" |
| | ) |
| | with gr.Row(): |
| | diffusion_tile = gr.Number(value=0, precision=0, label="Diffusion tile (px, 0=нет)") |
| | vae_tile = gr.Number(value=0, precision=0, label="VAE tile (px, 0=нет)") |
| | manual_multiple = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Manual multiple") |
| | rounding_mode = gr.Radio(choices=["round", "floor", "ceil"], value="round", label="Режим округления") |
| | auto_reason = gr.Markdown("") |
| |
|
| | with gr.Row(): |
| | with gr.Column(): |
| | shorters = gr.CheckboxGroup( |
| | choices=DEFAULT_SHORT_PRESETS, |
| | value=DEFAULT_SHORT_PRESETS, |
| | label="Цели по короткой стороне (px)", |
| | ) |
| | pixel_bases = gr.CheckboxGroup( |
| | choices=DEFAULT_PIXEL_BASES, |
| | value=DEFAULT_PIXEL_BASES, |
| | label="Цели по общему числу пикселей (берётся N²)", |
| | ) |
| | run_btn = gr.Button("Рассчитать", variant="primary") |
| |
|
| | with gr.Column(): |
| | results = gr.Dataframe( |
| | headers=["Preset", "Width", "Height", "Aspect", "Pixels", "MP"], |
| | datatype=["str", "number", "number", "str", "number", "number"], |
| | label="Результаты", |
| | interactive=False, |
| | wrap=True, |
| | overflow_row_behaviour="paginate", |
| | ) |
| | copy_box = gr.Textbox(label="Список WxH (для копирования)", lines=8, interactive=False) |
| |
|
| | |
| | gr.Markdown("---") |
| | gr.Markdown("#### Каталог разрешений (импорт из файла или генерация сетки)") |
| |
|
| | with gr.Row(): |
| | use_file_catalog = gr.Checkbox(value=True, label="Использовать файл, если найден (SDXL пресеты)") |
| | generate_min = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="Generate: min") |
| | generate_max = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="Generate: max") |
| | generate_step = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Generate: step") |
| |
|
| | with gr.Row(): |
| | filter_min_w = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="min Width") |
| | filter_max_w = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="max Width") |
| | filter_min_h = gr.Slider(minimum=128, maximum=4096, step=8, value=512, label="min Height") |
| | filter_max_h = gr.Slider(minimum=128, maximum=4096, step=8, value=2048, label="max Height") |
| |
|
| | with gr.Row(): |
| | filter_min_mp = gr.Number(value=0.0, label="min MP") |
| | filter_max_mp = gr.Number(value=8.0, label="max MP") |
| | filter_multiple = gr.Slider(minimum=8, maximum=256, step=8, value=64, label="Требуемая кратность") |
| | filter_orientation = gr.Dropdown(choices=["any", "square", "landscape", "portrait"], value="any", label="Ориентация") |
| | filter_aspects = gr.Textbox(value="", label="Аспекты (пример: '16:9, ~3:2, 21:9@0.03')") |
| |
|
| | with gr.Row(): |
| | filter_limit = gr.Slider(minimum=10, maximum=5000, step=10, value=500, label="Лимит результатов") |
| | sort_key = gr.Dropdown(choices=["MP", "Width", "Height"], value="MP", label="Сортировать по") |
| | sort_desc = gr.Checkbox(value=True, label="По убыванию") |
| | apply_filters = gr.Button("Применить фильтры", variant="primary") |
| |
|
| | catalog_df = gr.Dataframe( |
| | headers=["Width", "Height", "Aspect", "Orientation", "MP"], |
| | datatype=["number", "number", "str", "str", "number"], |
| | label="Каталог (фильтрованный)", |
| | interactive=False, |
| | wrap=True, |
| | overflow_row_behaviour="paginate", |
| | ) |
| | catalog_copy = gr.Textbox(label="Список WxH (для копирования)", lines=12, interactive=False) |
| | catalog_source = gr.Markdown("") |
| |
|
| | with gr.Row(): |
| | export_csv_btn = gr.Button("Скачать CSV") |
| | export_json_btn = gr.Button("Скачать JSON") |
| | exported_file = gr.File(label="Экспорт", visible=True) |
| |
|
| | |
| | def _toggle_manual(m_use_auto: bool): |
| | return gr.update(interactive=not m_use_auto) |
| |
|
| | use_autopick.change(fn=_toggle_manual, inputs=[use_autopick], outputs=[manual_multiple]) |
| |
|
| | for trigger in (image.upload, run_btn.click): |
| | trigger( |
| | fn=calculate_all, |
| | inputs=[image, shorters, pixel_bases, use_autopick, model_family, diffusion_tile, vae_tile, manual_multiple, rounding_mode], |
| | outputs=[results, copy_box, original_info, auto_reason], |
| | show_progress=False, |
| | ) |
| |
|
| | apply_filters.click( |
| | fn=catalog_filter_action, |
| | inputs=[ |
| | use_file_catalog, generate_min, generate_max, generate_step, |
| | filter_min_w, filter_max_w, filter_min_h, filter_max_h, |
| | filter_min_mp, filter_max_mp, filter_multiple, |
| | filter_orientation, filter_aspects, filter_limit, |
| | sort_key, sort_desc |
| | ], |
| | outputs=[catalog_df, catalog_copy, catalog_source], |
| | show_progress=False |
| | ) |
| |
|
| | export_csv_btn.click(lambda rows: export_rows(rows, "csv"), inputs=[catalog_df], outputs=[exported_file]) |
| | export_json_btn.click(lambda rows: export_rows(rows, "json"), inputs=[catalog_df], outputs=[exported_file]) |
| |
|
| | return (ui, "calculator+", "calculator_plus_interface"), |
| |
|
| |
|
| | |
| | |
| | |
| | try: |
| | from modules import script_callbacks |
| | script_callbacks.on_ui_tabs(on_ui_tab_called) |
| | except (ImportError, ModuleNotFoundError): |
| | if __name__ == "__main__": |
| | interface, _, _ = on_ui_tab_called()[0] |
| | interface.launch() |
| |
|
