From b10c00d6bf9f6dc8e8d471d0d3e0ec34ed2e744e Mon Sep 17 00:00:00 2001 From: pax Date: Sat, 4 Apr 2026 06:00:50 -0500 Subject: [PATCH] =?UTF-8?q?Initial=20release=20=E2=80=94=20booru=20image?= =?UTF-8?q?=20viewer=20with=20Qt6=20GUI=20and=20Textual=20TUI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Supports Danbooru, Gelbooru, Moebooru, and e621. Features include tag search with autocomplete, favorites with folders, save-to-library, video playback, drag-and-drop, multi-select, custom CSS theming, and cross-platform support. --- .gitignore | 11 + LICENSE | 21 + README.md | 91 ++ booru-viewer.spec | 59 ++ booru_viewer/__init__.py | 0 booru_viewer/core/__init__.py | 0 booru_viewer/core/api/__init__.py | 16 + booru_viewer/core/api/base.py | 85 ++ booru_viewer/core/api/danbooru.py | 107 ++ booru_viewer/core/api/detect.py | 119 +++ booru_viewer/core/api/e621.py | 175 ++++ booru_viewer/core/api/gelbooru.py | 132 +++ booru_viewer/core/api/moebooru.py | 92 ++ booru_viewer/core/cache.py | 207 ++++ booru_viewer/core/config.py | 74 ++ booru_viewer/core/db.py | 450 +++++++++ booru_viewer/core/images.py | 31 + booru_viewer/gui/__init__.py | 0 booru_viewer/gui/app.py | 1320 +++++++++++++++++++++++++ booru_viewer/gui/custom_css_guide.txt | 138 +++ booru_viewer/gui/dialogs.py | 101 ++ booru_viewer/gui/favorites.py | 301 ++++++ booru_viewer/gui/grid.py | 380 +++++++ booru_viewer/gui/preview.py | 487 +++++++++ booru_viewer/gui/search.py | 157 +++ booru_viewer/gui/settings.py | 620 ++++++++++++ booru_viewer/gui/sites.py | 297 ++++++ booru_viewer/gui/theme.py | 222 +++++ booru_viewer/main_gui.py | 36 + booru_viewer/main_tui.py | 10 + booru_viewer/tui/__init__.py | 0 booru_viewer/tui/app.py | 511 ++++++++++ booru_viewer/tui/favorites.py | 42 + booru_viewer/tui/grid.py | 143 +++ booru_viewer/tui/preview.py | 92 ++ booru_viewer/tui/search.py | 12 + booru_viewer/tui/sites.py | 46 + icon.ico | Bin 0 -> 137629 bytes icon.png | Bin 0 -> 816544 bytes pyproject.toml | 28 + 40 files changed, 6613 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 booru-viewer.spec create mode 100644 booru_viewer/__init__.py create mode 100644 booru_viewer/core/__init__.py create mode 100644 booru_viewer/core/api/__init__.py create mode 100644 booru_viewer/core/api/base.py create mode 100644 booru_viewer/core/api/danbooru.py create mode 100644 booru_viewer/core/api/detect.py create mode 100644 booru_viewer/core/api/e621.py create mode 100644 booru_viewer/core/api/gelbooru.py create mode 100644 booru_viewer/core/api/moebooru.py create mode 100644 booru_viewer/core/cache.py create mode 100644 booru_viewer/core/config.py create mode 100644 booru_viewer/core/db.py create mode 100644 booru_viewer/core/images.py create mode 100644 booru_viewer/gui/__init__.py create mode 100644 booru_viewer/gui/app.py create mode 100644 booru_viewer/gui/custom_css_guide.txt create mode 100644 booru_viewer/gui/dialogs.py create mode 100644 booru_viewer/gui/favorites.py create mode 100644 booru_viewer/gui/grid.py create mode 100644 booru_viewer/gui/preview.py create mode 100644 booru_viewer/gui/search.py create mode 100644 booru_viewer/gui/settings.py create mode 100644 booru_viewer/gui/sites.py create mode 100644 booru_viewer/gui/theme.py create mode 100644 booru_viewer/main_gui.py create mode 100644 booru_viewer/main_tui.py create mode 100644 booru_viewer/tui/__init__.py create mode 100644 booru_viewer/tui/app.py create mode 100644 booru_viewer/tui/favorites.py create mode 100644 booru_viewer/tui/grid.py create mode 100644 booru_viewer/tui/preview.py create mode 100644 booru_viewer/tui/search.py create mode 100644 booru_viewer/tui/sites.py create mode 100644 icon.ico create mode 100644 icon.png create mode 100644 pyproject.toml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dc20fdc --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +__pycache__/ +*.py[cod] +*.egg-info/ +dist/ +build/ +.eggs/ +*.egg +.venv/ +venv/ +project.md +*.bak/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0c08a73 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 pax + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..63e1723 --- /dev/null +++ b/README.md @@ -0,0 +1,91 @@ +# booru-viewer + +Local desktop application for browsing, searching, and favoriting images from booru-style imageboards. + +Dual interface — **Qt6 GUI** and **Textual TUI**. Green-on-black theme. + +## Features + +- Tag-based search across multiple booru sites (Danbooru, Gelbooru, Moebooru) +- Auto-detect site API type — just paste the URL +- Thumbnail grid with full image preview (zoom/pan) +- Favorites system with local download cache and offline browsing +- Tag autocomplete +- Per-site API key support + +## Install + +```sh +pip install -e ".[all]" +``` + +Or install only what you need: + +```sh +pip install -e ".[gui]" # Qt6 GUI only +pip install -e ".[tui]" # Textual TUI only +``` + +### Dependencies + +- **GUI**: PySide6 (Qt6) +- **TUI**: Textual +- **Core**: httpx, Pillow, SQLite (stdlib) + +## Usage + +```sh +# Qt6 GUI +booru-gui + +# Terminal TUI +booru-tui +``` + +### TUI Keybinds + +| Key | Action | +|-----|--------| +| `/` | Focus search | +| `Enter` | Preview selected | +| `f` | Toggle favorite | +| `j`/`k` | Navigate down/up | +| `n`/`p` | Next/previous page | +| `1`/`2`/`3` | Browse / Favorites / Sites | +| `Escape` | Close preview | +| `q` | Quit | + +### GUI Keybinds + +| Key | Action | +|-----|--------| +| `F` | Toggle favorite on selected | +| `Ctrl+S` | Manage sites | +| `Ctrl+Q` | Quit | +| Scroll wheel | Zoom in preview | +| Right click | Close preview | +| `0` | Fit to view | +| `+`/`-` | Zoom in/out | + +## Adding Sites + +Open the site manager (GUI: `Ctrl+S`, or in the Sites tab). Enter a URL and click Auto-Detect — the app probes for Danbooru, Gelbooru, and Moebooru APIs automatically. + +Or via Python: + +```python +from booru_viewer.core.db import Database +db = Database() +db.add_site("Danbooru", "https://danbooru.donmai.us", "danbooru") +db.add_site("Gelbooru", "https://gelbooru.com", "gelbooru") +``` + +## Data + +- Database: `~/.local/share/booru-viewer/booru.db` +- Image cache: `~/.local/share/booru-viewer/cache/` +- Thumbnails: `~/.local/share/booru-viewer/thumbnails/` + +## License + +MIT diff --git a/booru-viewer.spec b/booru-viewer.spec new file mode 100644 index 0000000..8020404 --- /dev/null +++ b/booru-viewer.spec @@ -0,0 +1,59 @@ +# -*- mode: python ; coding: utf-8 -*- + +import sys +from PyInstaller.utils.hooks import collect_data_files, collect_submodules + +block_cipher = None + +hiddenimports = [ + *collect_submodules('booru_viewer'), + 'httpx', + 'httpx._transports', + 'httpx._transports.default', + 'h2', + 'hpack', + 'hyperframe', + 'PIL', + 'PIL.Image', + 'PIL.JpegImagePlugin', + 'PIL.PngImagePlugin', + 'PIL.GifImagePlugin', + 'PIL.WebPImagePlugin', + 'PIL.BmpImagePlugin', +] + +a = Analysis( + ['booru_viewer/main_gui.py'], + pathex=[], + binaries=[], + datas=[('icon.png', '.'), ('booru_viewer/gui/custom_css_guide.txt', 'booru_viewer/gui')], + hiddenimports=hiddenimports, + hookspath=[], + hooksconfig={}, + runtime_hooks=[], + excludes=['textual', 'tkinter', 'unittest'], + noarchive=False, + optimize=0, + cipher=block_cipher, +) + +pyz = PYZ(a.pure, cipher=block_cipher) + +exe = EXE( + pyz, + a.scripts, + a.binaries, + a.datas, + [], + name='booru-viewer', + debug=False, + bootloader_ignore_signals=False, + strip=False, + upx=True, + upx_exclude=[], + runtime_tmpdir=None, + console=False, + disable_windowed_traceback=False, + argv_emulation=False, + icon='icon.ico', +) diff --git a/booru_viewer/__init__.py b/booru_viewer/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/booru_viewer/core/__init__.py b/booru_viewer/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/booru_viewer/core/api/__init__.py b/booru_viewer/core/api/__init__.py new file mode 100644 index 0000000..1512d2a --- /dev/null +++ b/booru_viewer/core/api/__init__.py @@ -0,0 +1,16 @@ +from .base import BooruClient, Post +from .danbooru import DanbooruClient +from .gelbooru import GelbooruClient +from .moebooru import MoebooruClient +from .e621 import E621Client +from .detect import detect_site_type + +__all__ = [ + "BooruClient", + "Post", + "DanbooruClient", + "GelbooruClient", + "MoebooruClient", + "E621Client", + "detect_site_type", +] diff --git a/booru_viewer/core/api/base.py b/booru_viewer/core/api/base.py new file mode 100644 index 0000000..8ea114a --- /dev/null +++ b/booru_viewer/core/api/base.py @@ -0,0 +1,85 @@ +"""Abstract booru client and shared Post dataclass.""" + +from __future__ import annotations + +import logging +from abc import ABC, abstractmethod +from dataclasses import dataclass, field + +import httpx + +from ..config import USER_AGENT, DEFAULT_PAGE_SIZE + +log = logging.getLogger("booru") + + +@dataclass +class Post: + id: int + file_url: str + preview_url: str | None + tags: str + score: int + rating: str | None + source: str | None + width: int = 0 + height: int = 0 + + @property + def tag_list(self) -> list[str]: + return self.tags.split() + + +class BooruClient(ABC): + """Base class for booru API clients.""" + + api_type: str = "" + + def __init__( + self, + base_url: str, + api_key: str | None = None, + api_user: str | None = None, + ) -> None: + self.base_url = base_url.rstrip("/") + self.api_key = api_key + self.api_user = api_user + self._client: httpx.AsyncClient | None = None + + @property + def client(self) -> httpx.AsyncClient: + if self._client is None or self._client.is_closed: + self._client = httpx.AsyncClient( + headers={"User-Agent": USER_AGENT}, + follow_redirects=True, + timeout=20.0, + ) + return self._client + + async def close(self) -> None: + if self._client and not self._client.is_closed: + await self._client.aclose() + + @abstractmethod + async def search( + self, tags: str = "", page: int = 1, limit: int = DEFAULT_PAGE_SIZE + ) -> list[Post]: + ... + + @abstractmethod + async def get_post(self, post_id: int) -> Post | None: + ... + + async def autocomplete(self, query: str, limit: int = 10) -> list[str]: + """Tag autocomplete. Override in subclasses that support it.""" + return [] + + async def test_connection(self) -> tuple[bool, str]: + """Test connection. Returns (success, detail_message).""" + try: + posts = await self.search(limit=1) + return True, f"OK — got {len(posts)} post(s)" + except httpx.HTTPStatusError as e: + return False, f"HTTP {e.response.status_code}: {e.response.text[:200]}" + except Exception as e: + return False, str(e) diff --git a/booru_viewer/core/api/danbooru.py b/booru_viewer/core/api/danbooru.py new file mode 100644 index 0000000..4d4d832 --- /dev/null +++ b/booru_viewer/core/api/danbooru.py @@ -0,0 +1,107 @@ +"""Danbooru-style API client (Danbooru, Safebooru, Szurubooru variants).""" + +from __future__ import annotations + +import logging + +from ..config import DEFAULT_PAGE_SIZE +from .base import BooruClient, Post + +log = logging.getLogger("booru") + + +class DanbooruClient(BooruClient): + api_type = "danbooru" + + async def search( + self, tags: str = "", page: int = 1, limit: int = DEFAULT_PAGE_SIZE + ) -> list[Post]: + params: dict = {"tags": tags, "page": page, "limit": limit} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["api_key"] = self.api_key + + url = f"{self.base_url}/posts.json" + log.info(f"GET {url}") + log.debug(f" params: {params}") + resp = await self.client.get(url, params=params) + log.info(f" -> {resp.status_code}") + if resp.status_code != 200: + log.warning(f" body: {resp.text[:500]}") + resp.raise_for_status() + data = resp.json() + + # Some Danbooru forks wrap in {"posts": [...]} + if isinstance(data, dict): + data = data.get("posts", []) + + posts = [] + for item in data: + file_url = item.get("file_url") or item.get("large_file_url") or "" + if not file_url: + continue + posts.append( + Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_file_url") or item.get("preview_url"), + tags=self._extract_tags(item), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("image_width", 0), + height=item.get("image_height", 0), + ) + ) + return posts + + async def get_post(self, post_id: int) -> Post | None: + params: dict = {} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["api_key"] = self.api_key + + resp = await self.client.get( + f"{self.base_url}/posts/{post_id}.json", params=params + ) + if resp.status_code == 404: + return None + resp.raise_for_status() + item = resp.json() + file_url = item.get("file_url") or item.get("large_file_url") or "" + if not file_url: + return None + return Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_file_url") or item.get("preview_url"), + tags=self._extract_tags(item), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("image_width", 0), + height=item.get("image_height", 0), + ) + + async def autocomplete(self, query: str, limit: int = 10) -> list[str]: + try: + resp = await self.client.get( + f"{self.base_url}/autocomplete.json", + params={"search[query]": query, "search[type]": "tag_query", "limit": limit}, + ) + resp.raise_for_status() + return [item.get("value", item.get("label", "")) for item in resp.json()] + except Exception: + return [] + + @staticmethod + def _extract_tags(item: dict) -> str: + """Pull tags from Danbooru's split tag fields or a single tag_string.""" + if "tag_string" in item: + return item["tag_string"] + parts = [] + for key in ("tag_string_general", "tag_string_character", + "tag_string_copyright", "tag_string_artist", "tag_string_meta"): + if key in item and item[key]: + parts.append(item[key]) + return " ".join(parts) if parts else "" diff --git a/booru_viewer/core/api/detect.py b/booru_viewer/core/api/detect.py new file mode 100644 index 0000000..c34c995 --- /dev/null +++ b/booru_viewer/core/api/detect.py @@ -0,0 +1,119 @@ +"""Auto-detect which API type a booru site uses.""" + +from __future__ import annotations + +import httpx + +from ..config import USER_AGENT +from .danbooru import DanbooruClient +from .gelbooru import GelbooruClient +from .moebooru import MoebooruClient +from .e621 import E621Client +from .base import BooruClient + + +async def detect_site_type( + url: str, + api_key: str | None = None, + api_user: str | None = None, +) -> str | None: + """ + Probe a URL and return the API type string: 'danbooru', 'gelbooru', or 'moebooru'. + Returns None if detection fails. + """ + url = url.rstrip("/") + + async with httpx.AsyncClient( + headers={"User-Agent": USER_AGENT}, + follow_redirects=True, + timeout=10.0, + ) as client: + # Try Danbooru / e621 first — /posts.json is a definitive endpoint + try: + params: dict = {"limit": 1} + if api_key and api_user: + params["login"] = api_user + params["api_key"] = api_key + resp = await client.get(f"{url}/posts.json", params=params) + if resp.status_code == 200: + data = resp.json() + if isinstance(data, dict) and "posts" in data: + # e621/e926 wraps in {"posts": [...]}, with nested file/tags dicts + posts = data["posts"] + if isinstance(posts, list) and posts: + p = posts[0] + if isinstance(p.get("file"), dict) and isinstance(p.get("tags"), dict): + return "e621" + return "danbooru" + elif isinstance(data, list) and data: + # Danbooru returns a flat list of post objects + if isinstance(data[0], dict) and any( + k in data[0] for k in ("tag_string", "image_width", "large_file_url") + ): + return "danbooru" + elif resp.status_code in (401, 403): + if "e621" in url or "e926" in url: + return "e621" + return "danbooru" + except Exception: + pass + + # Try Gelbooru — /index.php?page=dapi + try: + params = { + "page": "dapi", "s": "post", "q": "index", "json": "1", "limit": 1, + } + if api_key and api_user: + params["api_key"] = api_key + params["user_id"] = api_user + resp = await client.get(f"{url}/index.php", params=params) + if resp.status_code == 200: + data = resp.json() + if isinstance(data, list) and data and isinstance(data[0], dict): + if any(k in data[0] for k in ("file_url", "preview_url", "directory")): + return "gelbooru" + elif isinstance(data, dict): + if "post" in data or "@attributes" in data: + return "gelbooru" + elif resp.status_code in (401, 403): + if "gelbooru" in url or "safebooru.org" in url or "rule34" in url: + return "gelbooru" + except Exception: + pass + + # Try Moebooru — /post.json (singular) + try: + params = {"limit": 1} + if api_key and api_user: + params["login"] = api_user + params["password_hash"] = api_key + resp = await client.get(f"{url}/post.json", params=params) + if resp.status_code == 200: + data = resp.json() + if isinstance(data, list) or (isinstance(data, dict) and "posts" in data): + return "moebooru" + elif resp.status_code in (401, 403): + return "moebooru" + except Exception: + pass + + return None + + +def client_for_type( + api_type: str, + base_url: str, + api_key: str | None = None, + api_user: str | None = None, +) -> BooruClient: + """Return the appropriate client class for an API type string.""" + clients = { + "danbooru": DanbooruClient, + "gelbooru": GelbooruClient, + "moebooru": MoebooruClient, + "e621": E621Client, + } + cls = clients.get(api_type) + if cls is None: + raise ValueError(f"Unknown API type: {api_type}") + return cls(base_url, api_key=api_key, api_user=api_user) diff --git a/booru_viewer/core/api/e621.py b/booru_viewer/core/api/e621.py new file mode 100644 index 0000000..d0142a9 --- /dev/null +++ b/booru_viewer/core/api/e621.py @@ -0,0 +1,175 @@ +"""e621 API client — Danbooru fork with different response structure.""" + +from __future__ import annotations + +import logging + +import httpx + +from ..config import DEFAULT_PAGE_SIZE, USER_AGENT +from .base import BooruClient, Post + +log = logging.getLogger("booru") + + +class E621Client(BooruClient): + api_type = "e621" + + @property + def client(self) -> httpx.AsyncClient: + if self._client is None or self._client.is_closed: + # e621 requires a descriptive User-Agent with username + ua = USER_AGENT + if self.api_user: + ua = f"{USER_AGENT} (by {self.api_user} on e621)" + self._client = httpx.AsyncClient( + headers={"User-Agent": ua}, + follow_redirects=True, + timeout=20.0, + ) + return self._client + + async def search( + self, tags: str = "", page: int = 1, limit: int = DEFAULT_PAGE_SIZE + ) -> list[Post]: + params: dict = {"tags": tags, "page": page, "limit": min(limit, 320)} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["api_key"] = self.api_key + + url = f"{self.base_url}/posts.json" + log.info(f"GET {url}") + log.debug(f" params: {params}") + resp = await self.client.get(url, params=params) + log.info(f" -> {resp.status_code}") + if resp.status_code != 200: + log.warning(f" body: {resp.text[:500]}") + resp.raise_for_status() + data = resp.json() + + # e621 wraps posts in {"posts": [...]} + if isinstance(data, dict): + data = data.get("posts", []) + + posts = [] + for item in data: + file_url = self._get_file_url(item) + if not file_url: + continue + posts.append( + Post( + id=item["id"], + file_url=file_url, + preview_url=self._get_nested(item, "preview", "url"), + tags=self._extract_tags(item), + score=self._get_score(item), + rating=item.get("rating"), + source=self._get_source(item), + width=self._get_nested(item, "file", "width") or 0, + height=self._get_nested(item, "file", "height") or 0, + ) + ) + return posts + + async def get_post(self, post_id: int) -> Post | None: + params: dict = {} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["api_key"] = self.api_key + + resp = await self.client.get( + f"{self.base_url}/posts/{post_id}.json", params=params + ) + if resp.status_code == 404: + return None + resp.raise_for_status() + data = resp.json() + item = data.get("post", data) if isinstance(data, dict) else data + + file_url = self._get_file_url(item) + if not file_url: + return None + return Post( + id=item["id"], + file_url=file_url, + preview_url=self._get_nested(item, "preview", "url"), + tags=self._extract_tags(item), + score=self._get_score(item), + rating=item.get("rating"), + source=self._get_source(item), + width=self._get_nested(item, "file", "width") or 0, + height=self._get_nested(item, "file", "height") or 0, + ) + + async def autocomplete(self, query: str, limit: int = 10) -> list[str]: + try: + resp = await self.client.get( + f"{self.base_url}/tags.json", + params={ + "search[name_matches]": f"{query}*", + "search[order]": "count", + "limit": limit, + }, + ) + resp.raise_for_status() + return [item.get("name", "") for item in resp.json() if item.get("name")] + except Exception: + return [] + + @staticmethod + def _get_file_url(item: dict) -> str: + """Extract file URL from e621's nested structure.""" + # e621: item["file"]["url"], fallback to item["sample"]["url"] + f = item.get("file") + if isinstance(f, dict) and f.get("url"): + return f["url"] + s = item.get("sample") + if isinstance(s, dict) and s.get("url"): + return s["url"] + # Some posts have null URLs (deleted/flagged) + return "" + + @staticmethod + def _get_nested(item: dict, *keys) -> str | int | None: + """Safely get nested dict value.""" + current = item + for key in keys: + if isinstance(current, dict): + current = current.get(key) + else: + return None + return current + + @staticmethod + def _extract_tags(item: dict) -> str: + """e621 tags are a dict of category -> list[str].""" + tags_obj = item.get("tags") + if isinstance(tags_obj, dict): + all_tags = [] + for category in ("general", "artist", "copyright", "character", + "species", "meta", "lore"): + tag_list = tags_obj.get(category, []) + if isinstance(tag_list, list): + all_tags.extend(tag_list) + return " ".join(all_tags) + if isinstance(tags_obj, str): + return tags_obj + return "" + + @staticmethod + def _get_score(item: dict) -> int: + """e621 score is a dict with up/down/total.""" + score = item.get("score") + if isinstance(score, dict): + return score.get("total", 0) + if isinstance(score, int): + return score + return 0 + + @staticmethod + def _get_source(item: dict) -> str | None: + """e621 sources is a list.""" + sources = item.get("sources") + if isinstance(sources, list) and sources: + return sources[0] + return item.get("source") diff --git a/booru_viewer/core/api/gelbooru.py b/booru_viewer/core/api/gelbooru.py new file mode 100644 index 0000000..6eb63f8 --- /dev/null +++ b/booru_viewer/core/api/gelbooru.py @@ -0,0 +1,132 @@ +"""Gelbooru-style API client.""" + +from __future__ import annotations + +import logging + +from ..config import DEFAULT_PAGE_SIZE +from .base import BooruClient, Post + +log = logging.getLogger("booru") + + +class GelbooruClient(BooruClient): + api_type = "gelbooru" + + async def search( + self, tags: str = "", page: int = 1, limit: int = DEFAULT_PAGE_SIZE + ) -> list[Post]: + # Gelbooru uses pid (0-indexed page) not page number + params: dict = { + "page": "dapi", + "s": "post", + "q": "index", + "json": "1", + "tags": tags, + "limit": limit, + "pid": page - 1, + } + if self.api_key and self.api_user: + # Only send if they look like real values, not leftover URL fragments + key = self.api_key.strip().lstrip("&") + user = self.api_user.strip().lstrip("&") + if key and not key.startswith("api_key="): + params["api_key"] = key + if user and not user.startswith("user_id="): + params["user_id"] = user + + url = f"{self.base_url}/index.php" + log.info(f"GET {url}") + log.debug(f" params: {params}") + resp = await self.client.get(url, params=params) + log.info(f" -> {resp.status_code}") + if resp.status_code != 200: + log.warning(f" body: {resp.text[:500]}") + resp.raise_for_status() + + data = resp.json() + log.debug(f" json type: {type(data).__name__}, keys: {list(data.keys()) if isinstance(data, dict) else f'list[{len(data)}]'}") + # Gelbooru wraps posts in {"post": [...]} or returns {"post": []} + if isinstance(data, dict): + data = data.get("post", []) + if not isinstance(data, list): + return [] + + posts = [] + for item in data: + file_url = item.get("file_url", "") + if not file_url: + continue + posts.append( + Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_url"), + tags=item.get("tags", ""), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("width", 0), + height=item.get("height", 0), + ) + ) + return posts + + async def get_post(self, post_id: int) -> Post | None: + params: dict = { + "page": "dapi", + "s": "post", + "q": "index", + "json": "1", + "id": post_id, + } + if self.api_key and self.api_user: + params["api_key"] = self.api_key + params["user_id"] = self.api_user + + resp = await self.client.get(f"{self.base_url}/index.php", params=params) + if resp.status_code == 404: + return None + resp.raise_for_status() + data = resp.json() + if isinstance(data, dict): + data = data.get("post", []) + if not data: + return None + item = data[0] + file_url = item.get("file_url", "") + if not file_url: + return None + return Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_url"), + tags=item.get("tags", ""), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("width", 0), + height=item.get("height", 0), + ) + + async def autocomplete(self, query: str, limit: int = 10) -> list[str]: + try: + resp = await self.client.get( + f"{self.base_url}/index.php", + params={ + "page": "dapi", + "s": "tag", + "q": "index", + "json": "1", + "name_pattern": f"%{query}%", + "limit": limit, + "orderby": "count", + }, + ) + resp.raise_for_status() + data = resp.json() + if isinstance(data, dict): + data = data.get("tag", []) + return [t.get("name", "") for t in data if t.get("name")] + except Exception: + return [] diff --git a/booru_viewer/core/api/moebooru.py b/booru_viewer/core/api/moebooru.py new file mode 100644 index 0000000..12fb19c --- /dev/null +++ b/booru_viewer/core/api/moebooru.py @@ -0,0 +1,92 @@ +"""Moebooru-style API client (Yande.re, Konachan, etc.).""" + +from __future__ import annotations + +import logging + +from ..config import DEFAULT_PAGE_SIZE +from .base import BooruClient, Post + +log = logging.getLogger("booru") + + +class MoebooruClient(BooruClient): + api_type = "moebooru" + + async def search( + self, tags: str = "", page: int = 1, limit: int = DEFAULT_PAGE_SIZE + ) -> list[Post]: + params: dict = {"tags": tags, "page": page, "limit": limit} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["password_hash"] = self.api_key + + resp = await self.client.get(f"{self.base_url}/post.json", params=params) + resp.raise_for_status() + data = resp.json() + if isinstance(data, dict): + data = data.get("posts", data.get("post", [])) + if not isinstance(data, list): + return [] + + posts = [] + for item in data: + file_url = item.get("file_url") or item.get("jpeg_url") or "" + if not file_url: + continue + posts.append( + Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_url") or item.get("actual_preview_url"), + tags=item.get("tags", ""), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("width", 0), + height=item.get("height", 0), + ) + ) + return posts + + async def get_post(self, post_id: int) -> Post | None: + params: dict = {"tags": f"id:{post_id}"} + if self.api_key and self.api_user: + params["login"] = self.api_user + params["password_hash"] = self.api_key + + resp = await self.client.get(f"{self.base_url}/post.json", params=params) + if resp.status_code == 404: + return None + resp.raise_for_status() + data = resp.json() + if isinstance(data, dict): + data = data.get("posts", data.get("post", [])) + if not data: + return None + item = data[0] + file_url = item.get("file_url") or item.get("jpeg_url") or "" + if not file_url: + return None + return Post( + id=item["id"], + file_url=file_url, + preview_url=item.get("preview_url") or item.get("actual_preview_url"), + tags=item.get("tags", ""), + score=item.get("score", 0), + rating=item.get("rating"), + source=item.get("source"), + width=item.get("width", 0), + height=item.get("height", 0), + ) + + async def autocomplete(self, query: str, limit: int = 10) -> list[str]: + try: + resp = await self.client.get( + f"{self.base_url}/tag.json", + params={"name": f"*{query}*", "order": "count", "limit": limit}, + ) + resp.raise_for_status() + return [t["name"] for t in resp.json() if "name" in t] + except Exception: + return [] diff --git a/booru_viewer/core/cache.py b/booru_viewer/core/cache.py new file mode 100644 index 0000000..341f6cb --- /dev/null +++ b/booru_viewer/core/cache.py @@ -0,0 +1,207 @@ +"""Download manager and local file cache.""" + +from __future__ import annotations + +import hashlib +from pathlib import Path + +import httpx + +from .config import cache_dir, thumbnails_dir, USER_AGENT + + +def _url_hash(url: str) -> str: + return hashlib.sha256(url.encode()).hexdigest()[:16] + + +_IMAGE_MAGIC = { + b'\x89PNG': True, + b'\xff\xd8\xff': True, # JPEG + b'GIF8': True, + b'RIFF': True, # WebP + b'\x00\x00\x00': True, # MP4/MOV + b'\x1aE\xdf\xa3': True, # WebM/MKV +} + + +def _is_valid_media(path: Path) -> bool: + """Check if a file looks like actual media, not an HTML error page.""" + try: + with open(path, "rb") as f: + header = f.read(16) + if not header or header.startswith(b'<') or header.startswith(b' str: + path = url.split("?")[0] + if "." in path.split("/")[-1]: + return "." + path.split("/")[-1].rsplit(".", 1)[-1] + return ".jpg" + + +async def download_image( + url: str, + client: httpx.AsyncClient | None = None, + dest_dir: Path | None = None, + progress_callback=None, +) -> Path: + """Download an image to the cache, returning the local path. Skips if already cached. + + progress_callback: optional callable(bytes_downloaded, total_bytes) + """ + dest_dir = dest_dir or cache_dir() + filename = _url_hash(url) + _ext_from_url(url) + local = dest_dir / filename + + # Validate cached file isn't corrupt (e.g. HTML error page saved as image) + if local.exists(): + if _is_valid_media(local): + return local + else: + local.unlink() # Remove corrupt cache entry + + # Extract referer from URL domain (needed for Gelbooru CDN etc.) + from urllib.parse import urlparse + parsed = urlparse(url) + # Map CDN hostnames back to the main site + referer_host = parsed.netloc + if referer_host.startswith("img") and "gelbooru" in referer_host: + referer_host = "gelbooru.com" + elif referer_host.startswith("cdn") and "donmai" in referer_host: + referer_host = "danbooru.donmai.us" + referer = f"{parsed.scheme}://{referer_host}/" + + own_client = client is None + if own_client: + client = httpx.AsyncClient( + headers={ + "User-Agent": USER_AGENT, + "Referer": referer, + "Accept": "image/*,video/*,*/*", + }, + follow_redirects=True, + timeout=60.0, + ) + try: + if progress_callback: + async with client.stream("GET", url) as resp: + resp.raise_for_status() + content_type = resp.headers.get("content-type", "") + if "text/html" in content_type: + raise ValueError(f"Server returned HTML instead of media (possible captcha/block)") + total = int(resp.headers.get("content-length", 0)) + downloaded = 0 + chunks = [] + async for chunk in resp.aiter_bytes(8192): + chunks.append(chunk) + downloaded += len(chunk) + progress_callback(downloaded, total) + data = b"".join(chunks) + local.write_bytes(data) + else: + resp = await client.get(url) + resp.raise_for_status() + content_type = resp.headers.get("content-type", "") + if "text/html" in content_type: + raise ValueError(f"Server returned HTML instead of media (possible captcha/block)") + local.write_bytes(resp.content) + + # Verify the downloaded file + if not _is_valid_media(local): + local.unlink() + raise ValueError("Downloaded file is not valid media") + finally: + if own_client: + await client.aclose() + return local + + +async def download_thumbnail( + url: str, + client: httpx.AsyncClient | None = None, +) -> Path: + """Download a thumbnail preview image.""" + return await download_image(url, client, thumbnails_dir()) + + +def cached_path_for(url: str, dest_dir: Path | None = None) -> Path: + """Return the expected cache path for a URL (may not exist yet).""" + dest_dir = dest_dir or cache_dir() + return dest_dir / (_url_hash(url) + _ext_from_url(url)) + + +def is_cached(url: str, dest_dir: Path | None = None) -> bool: + return cached_path_for(url, dest_dir).exists() + + +def delete_from_library(post_id: int, folder: str | None = None) -> bool: + """Delete a saved image from the library. Returns True if a file was deleted.""" + from .config import saved_dir, saved_folder_dir + search_dir = saved_folder_dir(folder) if folder else saved_dir() + from .config import MEDIA_EXTENSIONS + for ext in MEDIA_EXTENSIONS: + path = search_dir / f"{post_id}{ext}" + if path.exists(): + path.unlink() + return True + return False + + +def cache_size_bytes(include_thumbnails: bool = True) -> int: + """Total size of all cached files in bytes.""" + total = sum(f.stat().st_size for f in cache_dir().iterdir() if f.is_file()) + if include_thumbnails: + total += sum(f.stat().st_size for f in thumbnails_dir().iterdir() if f.is_file()) + return total + + +def cache_file_count(include_thumbnails: bool = True) -> tuple[int, int]: + """Return (image_count, thumbnail_count).""" + images = sum(1 for f in cache_dir().iterdir() if f.is_file()) + thumbs = sum(1 for f in thumbnails_dir().iterdir() if f.is_file()) if include_thumbnails else 0 + return images, thumbs + + +def evict_oldest(max_bytes: int, protected_paths: set[str] | None = None) -> int: + """Delete oldest non-protected cached images until under max_bytes. Returns count deleted.""" + protected = protected_paths or set() + files = sorted(cache_dir().iterdir(), key=lambda f: f.stat().st_mtime) + deleted = 0 + current = cache_size_bytes(include_thumbnails=False) + + for f in files: + if current <= max_bytes: + break + if not f.is_file() or str(f) in protected: + continue + size = f.stat().st_size + f.unlink() + current -= size + deleted += 1 + + return deleted + + +def clear_cache(clear_images: bool = True, clear_thumbnails: bool = True) -> int: + """Delete all cached files. Returns count deleted.""" + deleted = 0 + if clear_images: + for f in cache_dir().iterdir(): + if f.is_file(): + f.unlink() + deleted += 1 + if clear_thumbnails: + for f in thumbnails_dir().iterdir(): + if f.is_file(): + f.unlink() + deleted += 1 + return deleted diff --git a/booru_viewer/core/config.py b/booru_viewer/core/config.py new file mode 100644 index 0000000..c9852ca --- /dev/null +++ b/booru_viewer/core/config.py @@ -0,0 +1,74 @@ +"""Settings, paths, constants, platform detection.""" + +from __future__ import annotations + +import platform +import sys +from pathlib import Path + +APPNAME = "booru-viewer" +IS_WINDOWS = sys.platform == "win32" + + +def data_dir() -> Path: + """Return the platform-appropriate data/cache directory.""" + if IS_WINDOWS: + base = Path.home() / "AppData" / "Roaming" + else: + base = Path( + __import__("os").environ.get( + "XDG_DATA_HOME", str(Path.home() / ".local" / "share") + ) + ) + path = base / APPNAME + path.mkdir(parents=True, exist_ok=True) + return path + + +def cache_dir() -> Path: + """Return the image cache directory.""" + path = data_dir() / "cache" + path.mkdir(parents=True, exist_ok=True) + return path + + +def thumbnails_dir() -> Path: + """Return the thumbnail cache directory.""" + path = data_dir() / "thumbnails" + path.mkdir(parents=True, exist_ok=True) + return path + + +def saved_dir() -> Path: + """Return the saved images directory.""" + path = data_dir() / "saved" + path.mkdir(parents=True, exist_ok=True) + return path + + +def saved_folder_dir(folder: str) -> Path: + """Return a subfolder inside saved images.""" + path = saved_dir() / folder + path.mkdir(parents=True, exist_ok=True) + return path + + +def db_path() -> Path: + """Return the path to the SQLite database.""" + return data_dir() / "booru.db" + + +# Green-on-black palette +GREEN = "#00ff00" +DARK_GREEN = "#00cc00" +DIM_GREEN = "#009900" +BG = "#000000" +BG_LIGHT = "#111111" +BG_LIGHTER = "#1a1a1a" +BORDER = "#333333" + +# Defaults +DEFAULT_THUMBNAIL_SIZE = (200, 200) +DEFAULT_PAGE_SIZE = 40 +USER_AGENT = f"booru-viewer/0.1 ({platform.system()})" +MEDIA_EXTENSIONS = (".jpg", ".jpeg", ".png", ".gif", ".webp", ".mp4", ".webm", ".mkv", ".avi", ".mov") diff --git a/booru_viewer/core/db.py b/booru_viewer/core/db.py new file mode 100644 index 0000000..124595d --- /dev/null +++ b/booru_viewer/core/db.py @@ -0,0 +1,450 @@ +"""SQLite database for favorites, sites, and cache metadata.""" + +from __future__ import annotations + +import sqlite3 +from contextlib import contextmanager +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Generator + +from .config import db_path + +_SCHEMA = """ +CREATE TABLE IF NOT EXISTS sites ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL UNIQUE, + url TEXT NOT NULL, + api_type TEXT NOT NULL, -- danbooru | gelbooru | moebooru + api_key TEXT, + api_user TEXT, + enabled INTEGER NOT NULL DEFAULT 1, + added_at TEXT NOT NULL +); + +CREATE TABLE IF NOT EXISTS favorites ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + site_id INTEGER NOT NULL REFERENCES sites(id), + post_id INTEGER NOT NULL, + file_url TEXT NOT NULL, + preview_url TEXT, + tags TEXT NOT NULL DEFAULT '', + rating TEXT, + score INTEGER, + source TEXT, + cached_path TEXT, + folder TEXT, + favorited_at TEXT NOT NULL, + UNIQUE(site_id, post_id) +); + +CREATE INDEX IF NOT EXISTS idx_favorites_tags ON favorites(tags); +CREATE INDEX IF NOT EXISTS idx_favorites_site ON favorites(site_id); + +CREATE TABLE IF NOT EXISTS favorite_folders ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL UNIQUE +); + +CREATE TABLE IF NOT EXISTS blacklisted_tags ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + tag TEXT NOT NULL UNIQUE +); + +CREATE TABLE IF NOT EXISTS settings ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL +); + +CREATE TABLE IF NOT EXISTS search_history ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + query TEXT NOT NULL, + site_id INTEGER, + searched_at TEXT NOT NULL +); + +CREATE TABLE IF NOT EXISTS saved_searches ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT NOT NULL, + query TEXT NOT NULL, + site_id INTEGER +); +""" + +_DEFAULTS = { + "max_cache_mb": "2048", + "auto_evict": "1", + "thumbnail_size": "180", + "page_size": "40", + "default_rating": "all", + "default_score": "0", + "confirm_favorites": "0", + "preload_thumbnails": "1", + "file_dialog_platform": "qt", +} + + +@dataclass +class Site: + id: int + name: str + url: str + api_type: str + api_key: str | None = None + api_user: str | None = None + enabled: bool = True + + +@dataclass +class Favorite: + id: int + site_id: int + post_id: int + file_url: str + preview_url: str | None + tags: str + rating: str | None + score: int | None + source: str | None + cached_path: str | None + folder: str | None + favorited_at: str + + +class Database: + def __init__(self, path: Path | None = None) -> None: + self._path = path or db_path() + self._conn: sqlite3.Connection | None = None + + @property + def conn(self) -> sqlite3.Connection: + if self._conn is None: + self._conn = sqlite3.connect(str(self._path), check_same_thread=False) + self._conn.row_factory = sqlite3.Row + self._conn.execute("PRAGMA journal_mode=WAL") + self._conn.execute("PRAGMA foreign_keys=ON") + self._conn.executescript(_SCHEMA) + self._migrate() + return self._conn + + def _migrate(self) -> None: + """Add columns that may not exist in older databases.""" + cur = self._conn.execute("PRAGMA table_info(favorites)") + cols = {row[1] for row in cur.fetchall()} + if "folder" not in cols: + self._conn.execute("ALTER TABLE favorites ADD COLUMN folder TEXT") + self._conn.commit() + self._conn.execute("CREATE INDEX IF NOT EXISTS idx_favorites_folder ON favorites(folder)") + + def close(self) -> None: + if self._conn: + self._conn.close() + self._conn = None + + # -- Sites -- + + def add_site( + self, + name: str, + url: str, + api_type: str, + api_key: str | None = None, + api_user: str | None = None, + ) -> Site: + now = datetime.now(timezone.utc).isoformat() + cur = self.conn.execute( + "INSERT INTO sites (name, url, api_type, api_key, api_user, added_at) " + "VALUES (?, ?, ?, ?, ?, ?)", + (name, url.rstrip("/"), api_type, api_key, api_user, now), + ) + self.conn.commit() + return Site( + id=cur.lastrowid, # type: ignore[arg-type] + name=name, + url=url.rstrip("/"), + api_type=api_type, + api_key=api_key, + api_user=api_user, + ) + + def get_sites(self, enabled_only: bool = True) -> list[Site]: + q = "SELECT * FROM sites" + if enabled_only: + q += " WHERE enabled = 1" + q += " ORDER BY name" + rows = self.conn.execute(q).fetchall() + return [ + Site( + id=r["id"], + name=r["name"], + url=r["url"], + api_type=r["api_type"], + api_key=r["api_key"], + api_user=r["api_user"], + enabled=bool(r["enabled"]), + ) + for r in rows + ] + + def delete_site(self, site_id: int) -> None: + self.conn.execute("DELETE FROM favorites WHERE site_id = ?", (site_id,)) + self.conn.execute("DELETE FROM sites WHERE id = ?", (site_id,)) + self.conn.commit() + + def update_site(self, site_id: int, **fields: str | None) -> None: + allowed = {"name", "url", "api_type", "api_key", "api_user", "enabled"} + sets = [] + vals = [] + for k, v in fields.items(): + if k not in allowed: + continue + sets.append(f"{k} = ?") + vals.append(v) + if not sets: + return + vals.append(site_id) + self.conn.execute( + f"UPDATE sites SET {', '.join(sets)} WHERE id = ?", vals + ) + self.conn.commit() + + # -- Favorites -- + + def add_favorite( + self, + site_id: int, + post_id: int, + file_url: str, + preview_url: str | None, + tags: str, + rating: str | None = None, + score: int | None = None, + source: str | None = None, + cached_path: str | None = None, + folder: str | None = None, + ) -> Favorite: + now = datetime.now(timezone.utc).isoformat() + cur = self.conn.execute( + "INSERT OR IGNORE INTO favorites " + "(site_id, post_id, file_url, preview_url, tags, rating, score, source, cached_path, folder, favorited_at) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", + (site_id, post_id, file_url, preview_url, tags, rating, score, source, cached_path, folder, now), + ) + self.conn.commit() + return Favorite( + id=cur.lastrowid, # type: ignore[arg-type] + site_id=site_id, + post_id=post_id, + file_url=file_url, + preview_url=preview_url, + tags=tags, + rating=rating, + score=score, + source=source, + cached_path=cached_path, + folder=folder, + favorited_at=now, + ) + + def remove_favorite(self, site_id: int, post_id: int) -> None: + self.conn.execute( + "DELETE FROM favorites WHERE site_id = ? AND post_id = ?", + (site_id, post_id), + ) + self.conn.commit() + + def is_favorited(self, site_id: int, post_id: int) -> bool: + row = self.conn.execute( + "SELECT 1 FROM favorites WHERE site_id = ? AND post_id = ?", + (site_id, post_id), + ).fetchone() + return row is not None + + def get_favorites( + self, + search: str | None = None, + site_id: int | None = None, + folder: str | None = None, + limit: int = 100, + offset: int = 0, + ) -> list[Favorite]: + q = "SELECT * FROM favorites WHERE 1=1" + params: list = [] + if site_id is not None: + q += " AND site_id = ?" + params.append(site_id) + if folder is not None: + q += " AND folder = ?" + params.append(folder) + if search: + for tag in search.strip().split(): + q += " AND tags LIKE ?" + params.append(f"%{tag}%") + q += " ORDER BY favorited_at DESC LIMIT ? OFFSET ?" + params.extend([limit, offset]) + rows = self.conn.execute(q, params).fetchall() + return [self._row_to_favorite(r) for r in rows] + + @staticmethod + def _row_to_favorite(r) -> Favorite: + return Favorite( + id=r["id"], + site_id=r["site_id"], + post_id=r["post_id"], + file_url=r["file_url"], + preview_url=r["preview_url"], + tags=r["tags"], + rating=r["rating"], + score=r["score"], + source=r["source"], + cached_path=r["cached_path"], + folder=r["folder"] if "folder" in r.keys() else None, + favorited_at=r["favorited_at"], + ) + + def update_favorite_cache_path(self, fav_id: int, cached_path: str) -> None: + self.conn.execute( + "UPDATE favorites SET cached_path = ? WHERE id = ?", + (cached_path, fav_id), + ) + self.conn.commit() + + def favorite_count(self) -> int: + row = self.conn.execute("SELECT COUNT(*) FROM favorites").fetchone() + return row[0] + + # -- Folders -- + + def get_folders(self) -> list[str]: + rows = self.conn.execute("SELECT name FROM favorite_folders ORDER BY name").fetchall() + return [r["name"] for r in rows] + + def add_folder(self, name: str) -> None: + self.conn.execute( + "INSERT OR IGNORE INTO favorite_folders (name) VALUES (?)", (name.strip(),) + ) + self.conn.commit() + + def remove_folder(self, name: str) -> None: + self.conn.execute( + "UPDATE favorites SET folder = NULL WHERE folder = ?", (name,) + ) + self.conn.execute("DELETE FROM favorite_folders WHERE name = ?", (name,)) + self.conn.commit() + + def rename_folder(self, old: str, new: str) -> None: + self.conn.execute( + "UPDATE favorites SET folder = ? WHERE folder = ?", (new.strip(), old) + ) + self.conn.execute( + "UPDATE favorite_folders SET name = ? WHERE name = ?", (new.strip(), old) + ) + self.conn.commit() + + def move_favorite_to_folder(self, fav_id: int, folder: str | None) -> None: + self.conn.execute( + "UPDATE favorites SET folder = ? WHERE id = ?", (folder, fav_id) + ) + self.conn.commit() + + # -- Blacklist -- + + def add_blacklisted_tag(self, tag: str) -> None: + self.conn.execute( + "INSERT OR IGNORE INTO blacklisted_tags (tag) VALUES (?)", + (tag.strip().lower(),), + ) + self.conn.commit() + + def remove_blacklisted_tag(self, tag: str) -> None: + self.conn.execute( + "DELETE FROM blacklisted_tags WHERE tag = ?", + (tag.strip().lower(),), + ) + self.conn.commit() + + def get_blacklisted_tags(self) -> list[str]: + rows = self.conn.execute("SELECT tag FROM blacklisted_tags ORDER BY tag").fetchall() + return [r["tag"] for r in rows] + + # -- Settings -- + + def get_setting(self, key: str) -> str: + row = self.conn.execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone() + if row: + return row["value"] + return _DEFAULTS.get(key, "") + + def get_setting_int(self, key: str) -> int: + return int(self.get_setting(key) or "0") + + def get_setting_bool(self, key: str) -> bool: + return self.get_setting(key) == "1" + + def set_setting(self, key: str, value: str) -> None: + self.conn.execute( + "INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", + (key, str(value)), + ) + self.conn.commit() + + def get_all_settings(self) -> dict[str, str]: + result = dict(_DEFAULTS) + rows = self.conn.execute("SELECT key, value FROM settings").fetchall() + for r in rows: + result[r["key"]] = r["value"] + return result + + # -- Search History -- + + def add_search_history(self, query: str, site_id: int | None = None) -> None: + if not query.strip(): + return + now = datetime.now(timezone.utc).isoformat() + # Remove duplicate if exists, keep latest + self.conn.execute( + "DELETE FROM search_history WHERE query = ? AND (site_id = ? OR (site_id IS NULL AND ? IS NULL))", + (query.strip(), site_id, site_id), + ) + self.conn.execute( + "INSERT INTO search_history (query, site_id, searched_at) VALUES (?, ?, ?)", + (query.strip(), site_id, now), + ) + # Keep only last 50 + self.conn.execute( + "DELETE FROM search_history WHERE id NOT IN " + "(SELECT id FROM search_history ORDER BY searched_at DESC LIMIT 50)" + ) + self.conn.commit() + + def get_search_history(self, limit: int = 20) -> list[str]: + rows = self.conn.execute( + "SELECT DISTINCT query FROM search_history ORDER BY searched_at DESC LIMIT ?", + (limit,), + ).fetchall() + return [r["query"] for r in rows] + + def clear_search_history(self) -> None: + self.conn.execute("DELETE FROM search_history") + self.conn.commit() + + # -- Saved Searches -- + + def add_saved_search(self, name: str, query: str, site_id: int | None = None) -> None: + self.conn.execute( + "INSERT OR REPLACE INTO saved_searches (name, query, site_id) VALUES (?, ?, ?)", + (name.strip(), query.strip(), site_id), + ) + self.conn.commit() + + def get_saved_searches(self) -> list[tuple[int, str, str]]: + """Returns list of (id, name, query).""" + rows = self.conn.execute( + "SELECT id, name, query FROM saved_searches ORDER BY name" + ).fetchall() + return [(r["id"], r["name"], r["query"]) for r in rows] + + def remove_saved_search(self, search_id: int) -> None: + self.conn.execute("DELETE FROM saved_searches WHERE id = ?", (search_id,)) + self.conn.commit() diff --git a/booru_viewer/core/images.py b/booru_viewer/core/images.py new file mode 100644 index 0000000..3e12175 --- /dev/null +++ b/booru_viewer/core/images.py @@ -0,0 +1,31 @@ +"""Image thumbnailing and format helpers.""" + +from __future__ import annotations + +from pathlib import Path + +from PIL import Image + +from .config import DEFAULT_THUMBNAIL_SIZE, thumbnails_dir + + +def make_thumbnail( + source: Path, + size: tuple[int, int] = DEFAULT_THUMBNAIL_SIZE, + dest: Path | None = None, +) -> Path: + """Create a thumbnail, returning its path. Returns existing if already made.""" + dest = dest or thumbnails_dir() / f"thumb_{source.stem}_{size[0]}x{size[1]}.jpg" + if dest.exists(): + return dest + with Image.open(source) as img: + img.thumbnail(size, Image.Resampling.LANCZOS) + if img.mode in ("RGBA", "P"): + img = img.convert("RGB") + img.save(dest, "JPEG", quality=85) + return dest + + +def image_dimensions(path: Path) -> tuple[int, int]: + with Image.open(path) as img: + return img.size diff --git a/booru_viewer/gui/__init__.py b/booru_viewer/gui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/booru_viewer/gui/app.py b/booru_viewer/gui/app.py new file mode 100644 index 0000000..9f6569f --- /dev/null +++ b/booru_viewer/gui/app.py @@ -0,0 +1,1320 @@ +"""Main Qt6 application window.""" + +from __future__ import annotations + +import asyncio +import logging +import os +import subprocess +import sys +import threading +from pathlib import Path + +from PySide6.QtCore import Qt, QTimer, Signal, Slot, QObject, QUrl +from PySide6.QtGui import QPixmap, QAction, QKeySequence, QDesktopServices, QShortcut +from PySide6.QtWidgets import ( + QApplication, + QMainWindow, + QWidget, + QVBoxLayout, + QHBoxLayout, + QStackedWidget, + QComboBox, + QLabel, + QPushButton, + QStatusBar, + QSplitter, + QMessageBox, + QTextEdit, + QMenu, + QFileDialog, + QSpinBox, + QScrollArea, + QProgressBar, +) + +from ..core.db import Database, Site +from ..core.api.base import BooruClient, Post +from ..core.api.detect import client_for_type +from ..core.cache import download_image, download_thumbnail, cache_size_bytes, evict_oldest +from ..core.config import MEDIA_EXTENSIONS + +from .grid import ThumbnailGrid +from .preview import ImagePreview +from .search import SearchBar +from .sites import SiteManagerDialog +from .favorites import FavoritesView +from .settings import SettingsDialog + +log = logging.getLogger("booru") + + +class LogHandler(logging.Handler, QObject): + """Logging handler that emits to a QTextEdit.""" + + log_signal = Signal(str) + + def __init__(self, widget: QTextEdit) -> None: + logging.Handler.__init__(self) + QObject.__init__(self) + self._widget = widget + self.log_signal.connect(self._append) + self.setFormatter(logging.Formatter("%(asctime)s %(levelname)-5s %(message)s", datefmt="%H:%M:%S")) + + def emit(self, record: logging.LogRecord) -> None: + msg = self.format(record) + self.log_signal.emit(msg) + + def _append(self, msg: str) -> None: + self._widget.append(msg) + sb = self._widget.verticalScrollBar() + sb.setValue(sb.maximum()) + + +class AsyncSignals(QObject): + """Signals for async worker results.""" + search_done = Signal(list) + search_error = Signal(str) + thumb_done = Signal(int, str) + image_done = Signal(str, str) + image_error = Signal(str) + fav_done = Signal(int, str) + fav_error = Signal(str) + autocomplete_done = Signal(list) + batch_progress = Signal(int, int) # current, total + batch_done = Signal(str) + download_progress = Signal(int, int) # bytes_downloaded, total_bytes + + +# -- Info Panel -- + +class InfoPanel(QWidget): + """Toggleable panel showing post details.""" + + tag_clicked = Signal(str) + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + layout = QVBoxLayout(self) + layout.setContentsMargins(6, 6, 6, 6) + + self._title = QLabel("No post selected") + self._title.setStyleSheet("font-weight: bold;") + layout.addWidget(self._title) + + self._details = QLabel() + self._details.setWordWrap(True) + self._details.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse) + layout.addWidget(self._details) + + self._tags_label = QLabel("Tags:") + self._tags_label.setStyleSheet("font-weight: bold; margin-top: 8px;") + layout.addWidget(self._tags_label) + + self._tags_scroll = QScrollArea() + self._tags_scroll.setWidgetResizable(True) + self._tags_scroll.setStyleSheet("QScrollArea { border: none; }") + self._tags_widget = QWidget() + self._tags_flow = QVBoxLayout(self._tags_widget) + self._tags_flow.setContentsMargins(0, 0, 0, 0) + self._tags_flow.setSpacing(2) + self._tags_scroll.setWidget(self._tags_widget) + layout.addWidget(self._tags_scroll, stretch=1) + + def set_post(self, post: Post) -> None: + self._title.setText(f"Post #{post.id}") + self._details.setText( + f"Size: {post.width}x{post.height}\n" + f"Score: {post.score}\n" + f"Rating: {post.rating or 'unknown'}\n" + f"Source: {post.source or 'none'}" + ) + # Clear old tags + while self._tags_flow.count(): + item = self._tags_flow.takeAt(0) + if item.widget(): + item.widget().deleteLater() + # Add clickable tags + for tag in post.tag_list[:100]: + btn = QPushButton(tag) + btn.setFlat(True) + btn.setCursor(Qt.CursorShape.PointingHandCursor) + btn.setStyleSheet( + "QPushButton { text-align: left; padding: 1px 4px; border: none; }" + ) + btn.clicked.connect(lambda checked, t=tag: self.tag_clicked.emit(t)) + self._tags_flow.addWidget(btn) + self._tags_flow.addStretch() + + def clear(self) -> None: + self._title.setText("No post selected") + self._details.setText("") + while self._tags_flow.count(): + item = self._tags_flow.takeAt(0) + if item.widget(): + item.widget().deleteLater() + + + +# -- Main App -- + +class BooruApp(QMainWindow): + def __init__(self) -> None: + super().__init__() + self.setWindowTitle("booru-viewer") + self.setMinimumSize(900, 600) + self.resize(1200, 800) + + self._db = Database() + self._current_site: Site | None = None + self._posts: list[Post] = [] + self._current_page = 1 + self._current_tags = "" + self._current_rating = "all" + self._min_score = 0 + self._loading = False + self._last_scroll_page = 0 + self._signals = AsyncSignals() + + self._setup_signals() + self._setup_ui() + self._setup_menu() + self._load_sites() + + def _setup_signals(self) -> None: + Q = Qt.ConnectionType.QueuedConnection + s = self._signals + s.search_done.connect(self._on_search_done, Q) + s.search_error.connect(self._on_search_error, Q) + s.thumb_done.connect(self._on_thumb_done, Q) + s.image_done.connect(self._on_image_done, Q) + s.image_error.connect(self._on_image_error, Q) + s.fav_done.connect(self._on_fav_done, Q) + s.fav_error.connect(self._on_fav_error, Q) + s.autocomplete_done.connect(self._on_autocomplete_done, Q) + s.batch_progress.connect(self._on_batch_progress, Q) + s.batch_done.connect(lambda m: self._status.showMessage(m), Q) + s.download_progress.connect(self._on_download_progress, Q) + + def _clear_loading(self) -> None: + self._loading = False + + def _on_search_error(self, e: str) -> None: + self._loading = False + self._status.showMessage(f"Error: {e}") + + def _on_image_error(self, e: str) -> None: + self._dl_progress.hide() + self._status.showMessage(f"Error: {e}") + + def _on_fav_error(self, e: str) -> None: + self._status.showMessage(f"Error: {e}") + + def _run_async(self, coro_func, *args): + def _worker(): + try: + asyncio.run(coro_func(*args)) + except Exception as e: + log.error(f"Async worker failed: {e}") + threading.Thread(target=_worker, daemon=True).start() + + def _setup_ui(self) -> None: + central = QWidget() + self.setCentralWidget(central) + layout = QVBoxLayout(central) + layout.setContentsMargins(8, 8, 8, 8) + layout.setSpacing(6) + + # Top bar: site selector + rating + search + top = QHBoxLayout() + + self._site_combo = QComboBox() + self._site_combo.setMinimumWidth(150) + self._site_combo.currentIndexChanged.connect(self._on_site_changed) + top.addWidget(self._site_combo) + + # Rating filter + self._rating_combo = QComboBox() + self._rating_combo.addItems(["All", "General", "Sensitive", "Questionable", "Explicit"]) + self._rating_combo.setMinimumWidth(100) + self._rating_combo.currentTextChanged.connect(self._on_rating_changed) + top.addWidget(self._rating_combo) + + # Score filter + score_label = QLabel("Score≥") + top.addWidget(score_label) + self._score_spin = QSpinBox() + self._score_spin.setRange(0, 99999) + self._score_spin.setValue(0) + self._score_spin.setFixedWidth(70) + top.addWidget(self._score_spin) + + self._search_bar = SearchBar(db=self._db) + self._search_bar.search_requested.connect(self._on_search) + self._search_bar.autocomplete_requested.connect(self._request_autocomplete) + top.addWidget(self._search_bar, stretch=1) + + layout.addLayout(top) + + # Nav bar + nav = QHBoxLayout() + self._browse_btn = QPushButton("Browse") + self._browse_btn.setCheckable(True) + self._browse_btn.setChecked(True) + self._browse_btn.clicked.connect(lambda: self._switch_view(0)) + nav.addWidget(self._browse_btn) + + self._fav_btn = QPushButton("Favorites") + self._fav_btn.setCheckable(True) + self._fav_btn.clicked.connect(lambda: self._switch_view(1)) + nav.addWidget(self._fav_btn) + + nav.addStretch() + + self._page_label = QLabel("Page 1") + nav.addWidget(self._page_label) + + prev_btn = QPushButton("Prev") + prev_btn.setFixedWidth(60) + prev_btn.clicked.connect(self._prev_page) + nav.addWidget(prev_btn) + + next_btn = QPushButton("Next") + next_btn.setFixedWidth(60) + next_btn.clicked.connect(self._next_page) + nav.addWidget(next_btn) + + layout.addLayout(nav) + + # Main content + self._splitter = QSplitter(Qt.Orientation.Horizontal) + + # Left: stacked views + self._stack = QStackedWidget() + + self._grid = ThumbnailGrid() + self._grid.post_selected.connect(self._on_post_selected) + self._grid.post_activated.connect(self._on_post_activated) + self._grid.context_requested.connect(self._on_context_menu) + self._grid.multi_context_requested.connect(self._on_multi_context_menu) + self._grid.reached_bottom.connect(self._scroll_next_page) + self._grid.reached_top.connect(self._scroll_prev_page) + self._stack.addWidget(self._grid) + + self._favorites_view = FavoritesView(self._db) + self._favorites_view.favorite_activated.connect(self._on_favorite_activated) + self._stack.addWidget(self._favorites_view) + + self._splitter.addWidget(self._stack) + + # Right: preview + info (vertical split) + right = QSplitter(Qt.Orientation.Vertical) + + self._preview = ImagePreview() + self._preview.close_requested.connect(self._close_preview) + self._preview.open_in_default.connect(self._open_preview_in_default) + self._preview.open_in_browser.connect(self._open_preview_in_browser) + self._preview.favorite_requested.connect(self._favorite_from_preview) + self._preview.save_to_folder.connect(self._save_from_preview) + self._preview.navigate.connect(self._navigate_preview) + self._preview.set_folders_callback(self._db.get_folders) + self._preview.setMinimumWidth(300) + right.addWidget(self._preview) + + self._dl_progress = QProgressBar() + self._dl_progress.setMaximumHeight(6) + self._dl_progress.setTextVisible(False) + self._dl_progress.hide() + right.addWidget(self._dl_progress) + + self._info_panel = InfoPanel() + self._info_panel.tag_clicked.connect(self._on_tag_clicked) + self._info_panel.setMinimumHeight(100) + self._info_panel.hide() + right.addWidget(self._info_panel) + + right.setSizes([500, 0, 200]) + self._splitter.addWidget(right) + + self._splitter.setSizes([600, 500]) + layout.addWidget(self._splitter, stretch=1) + + # Log panel + self._log_text = QTextEdit() + self._log_text.setReadOnly(True) + self._log_text.setMaximumHeight(150) + self._log_text.setStyleSheet("font-family: monospace; font-size: 11px;") + self._log_text.hide() + layout.addWidget(self._log_text) + + # Hook up logging + self._log_handler = LogHandler(self._log_text) + self._log_handler.setLevel(logging.DEBUG) + logging.getLogger("booru").addHandler(self._log_handler) + logging.getLogger("booru").setLevel(logging.DEBUG) + + # Status bar + self._status = QStatusBar() + self.setStatusBar(self._status) + self._status.showMessage("Ready") + + # Global shortcuts for preview navigation + QShortcut(QKeySequence("Ctrl+Left"), self, lambda: self._navigate_preview(-1)) + QShortcut(QKeySequence("Ctrl+Right"), self, lambda: self._navigate_preview(1)) + + def _setup_menu(self) -> None: + menu = self.menuBar() + file_menu = menu.addMenu("&File") + + sites_action = QAction("&Manage Sites...", self) + sites_action.setShortcut(QKeySequence("Ctrl+S")) + sites_action.triggered.connect(self._open_site_manager) + file_menu.addAction(sites_action) + + settings_action = QAction("Se&ttings...", self) + settings_action.setShortcut(QKeySequence("Ctrl+,")) + settings_action.triggered.connect(self._open_settings) + file_menu.addAction(settings_action) + + file_menu.addSeparator() + + batch_action = QAction("Batch &Download Page...", self) + batch_action.setShortcut(QKeySequence("Ctrl+D")) + batch_action.triggered.connect(self._batch_download) + file_menu.addAction(batch_action) + + file_menu.addSeparator() + + quit_action = QAction("&Quit", self) + quit_action.setShortcut(QKeySequence("Ctrl+Q")) + quit_action.triggered.connect(self.close) + file_menu.addAction(quit_action) + + view_menu = menu.addMenu("&View") + + info_action = QAction("Toggle &Info Panel", self) + info_action.setShortcut(QKeySequence("Ctrl+I")) + info_action.triggered.connect(self._toggle_info) + view_menu.addAction(info_action) + + log_action = QAction("Toggle &Log", self) + log_action.setShortcut(QKeySequence("Ctrl+L")) + log_action.triggered.connect(self._toggle_log) + view_menu.addAction(log_action) + + view_menu.addSeparator() + + fullscreen_action = QAction("&Fullscreen", self) + fullscreen_action.setShortcut(QKeySequence("F11")) + fullscreen_action.triggered.connect(self._toggle_fullscreen) + view_menu.addAction(fullscreen_action) + + privacy_action = QAction("&Privacy Screen", self) + privacy_action.setShortcut(QKeySequence("Ctrl+P")) + privacy_action.triggered.connect(self._toggle_privacy) + view_menu.addAction(privacy_action) + + def _load_sites(self) -> None: + self._site_combo.clear() + for site in self._db.get_sites(): + self._site_combo.addItem(site.name, site.id) + + def _make_client(self) -> BooruClient | None: + if not self._current_site: + return None + s = self._current_site + return client_for_type(s.api_type, s.url, s.api_key, s.api_user) + + def _on_site_changed(self, index: int) -> None: + if index < 0: + self._current_site = None + return + site_id = self._site_combo.currentData() + sites = self._db.get_sites() + site = next((s for s in sites if s.id == site_id), None) + if not site: + return + self._current_site = site + self._status.showMessage(f"Connected to {site.name}") + + def _on_rating_changed(self, text: str) -> None: + self._current_rating = text.lower() + + def _switch_view(self, index: int) -> None: + self._stack.setCurrentIndex(index) + self._browse_btn.setChecked(index == 0) + self._fav_btn.setChecked(index == 1) + if index == 1: + self._favorites_view.refresh() + + def _on_tag_clicked(self, tag: str) -> None: + self._search_bar.set_text(tag) + self._on_search(tag) + + # -- Search -- + + def _on_search(self, tags: str) -> None: + self._current_tags = tags + self._current_page = 1 + self._min_score = self._score_spin.value() + self._do_search() + + def _prev_page(self) -> None: + if self._current_page > 1: + self._current_page -= 1 + self._do_search() + + def _next_page(self) -> None: + if self._loading: + return + self._current_page += 1 + self._do_search() + + def _scroll_next_page(self) -> None: + if self._loading: + return + self._current_page += 1 + self._do_search() + + def _scroll_prev_page(self) -> None: + if self._loading or self._current_page <= 1: + return + self._current_page -= 1 + self._do_search() + + def _build_search_tags(self) -> str: + """Build tag string with rating filter and negative tags.""" + parts = [] + if self._current_tags: + parts.append(self._current_tags) + + # Rating filter — site-specific syntax + # Danbooru/Gelbooru: 4-tier (general, sensitive, questionable, explicit) + # Moebooru/e621: 3-tier (safe, questionable, explicit) + rating = self._current_rating + if rating != "all" and self._current_site: + api = self._current_site.api_type + if api == "danbooru": + # Danbooru accepts both full words and single letters + danbooru_map = { + "general": "g", "sensitive": "s", + "questionable": "q", "explicit": "e", + } + if rating in danbooru_map: + parts.append(f"rating:{danbooru_map[rating]}") + elif api == "gelbooru": + # Gelbooru requires full words, no abbreviations + gelbooru_map = { + "general": "general", "sensitive": "sensitive", + "questionable": "questionable", "explicit": "explicit", + } + if rating in gelbooru_map: + parts.append(f"rating:{gelbooru_map[rating]}") + elif api == "e621": + # e621: 3-tier (s/q/e), accepts both full words and letters + e621_map = { + "general": "s", "sensitive": "s", + "questionable": "q", "explicit": "e", + } + if rating in e621_map: + parts.append(f"rating:{e621_map[rating]}") + else: + # Moebooru (yande.re, konachan) — 3-tier, full words work + # "general" and "sensitive" don't exist, map to "safe" + moebooru_map = { + "general": "safe", "sensitive": "safe", + "questionable": "questionable", "explicit": "explicit", + } + if rating in moebooru_map: + parts.append(f"rating:{moebooru_map[rating]}") + + # Append blacklisted tags as negatives + for tag in self._db.get_blacklisted_tags(): + parts.append(f"-{tag}") + + return " ".join(parts) + + def _do_search(self) -> None: + if not self._current_site: + self._status.showMessage("No site selected") + return + self._loading = True + self._page_label.setText(f"Page {self._current_page}") + self._status.showMessage("Searching...") + + search_tags = self._build_search_tags() + log.info(f"Search: tags='{search_tags}' rating={self._current_rating}") + page = self._current_page + min_score = self._min_score + limit = self._db.get_setting_int("page_size") or 40 + + async def _search(): + client = self._make_client() + try: + posts = await client.search(tags=search_tags, page=page, limit=limit) + # Client-side score filter + if min_score > 0: + posts = [p for p in posts if p.score >= min_score] + self._signals.search_done.emit(posts) + except Exception as e: + self._signals.search_error.emit(str(e)) + finally: + await client.close() + + self._run_async(_search) + + def _on_search_done(self, posts: list) -> None: + self._posts = posts + self._status.showMessage(f"{len(posts)} results") + thumbs = self._grid.set_posts(len(posts)) + self._grid.scroll_to_top() + # Clear loading after a brief delay so scroll signals don't re-trigger + QTimer.singleShot(100, self._clear_loading) + + from ..core.config import saved_dir, saved_folder_dir + site_id = self._site_combo.currentData() + for i, (post, thumb) in enumerate(zip(posts, thumbs)): + if site_id and self._db.is_favorited(site_id, post.id): + thumb.set_favorited(True) + # Check if saved to library (not just cached) + saved = any( + (saved_dir() / f"{post.id}{ext}").exists() + for ext in MEDIA_EXTENSIONS + ) + if not saved: + # Check folders + favs = self._db.get_favorites(site_id=site_id) + for f in favs: + if f.post_id == post.id and f.folder: + saved = any( + (saved_folder_dir(f.folder) / f"{post.id}{ext}").exists() + for ext in MEDIA_EXTENSIONS + ) + break + thumb.set_saved_locally(saved) + # Set drag path from cache + from ..core.cache import cached_path_for + cached = cached_path_for(post.file_url) + if cached.exists(): + thumb._cached_path = str(cached) + + if post.preview_url: + self._fetch_thumbnail(i, post.preview_url) + + self._grid.setFocus() + + def _fetch_thumbnail(self, index: int, url: str) -> None: + async def _download(): + try: + path = await download_thumbnail(url) + self._signals.thumb_done.emit(index, str(path)) + except Exception as e: + log.warning(f"Thumb #{index} failed: {e}") + self._run_async(_download) + + def _on_thumb_done(self, index: int, path: str) -> None: + thumbs = self._grid._thumbs + if 0 <= index < len(thumbs): + pix = QPixmap(path) + if not pix.isNull(): + thumbs[index].set_pixmap(pix) + + # -- Autocomplete -- + + def _request_autocomplete(self, query: str) -> None: + if not self._current_site or len(query) < 2: + return + + async def _ac(): + client = self._make_client() + try: + results = await client.autocomplete(query) + self._signals.autocomplete_done.emit(results) + except Exception: + pass + finally: + await client.close() + + self._run_async(_ac) + + def _on_autocomplete_done(self, suggestions: list) -> None: + self._search_bar.set_suggestions(suggestions) + + # -- Post selection / preview -- + + def _on_post_selected(self, index: int) -> None: + multi = self._grid.selected_indices + if len(multi) > 1: + self._status.showMessage(f"{len(multi)} posts selected") + return + if 0 <= index < len(self._posts): + post = self._posts[index] + self._status.showMessage( + f"#{post.id} {post.width}x{post.height} score:{post.score} [{post.rating}]" + ) + if self._info_panel.isVisible(): + self._info_panel.set_post(post) + self._on_post_activated(index) + + def _on_post_activated(self, index: int) -> None: + if 0 <= index < len(self._posts): + post = self._posts[index] + log.info(f"Preview: #{post.id} -> {post.file_url}") + self._status.showMessage(f"Loading #{post.id}...") + self._dl_progress.show() + self._dl_progress.setRange(0, 0) + + def _progress(downloaded, total): + self._signals.download_progress.emit(downloaded, total) + + async def _load(): + try: + path = await download_image(post.file_url, progress_callback=_progress) + info = f"#{post.id} {post.width}x{post.height} score:{post.score} [{post.rating}]" + self._signals.image_done.emit(str(path), info) + except Exception as e: + log.error(f"Image download failed: {e}") + self._signals.image_error.emit(str(e)) + + self._run_async(_load) + + def _on_download_progress(self, downloaded: int, total: int) -> None: + if total > 0: + self._dl_progress.setRange(0, total) + self._dl_progress.setValue(downloaded) + self._dl_progress.show() + mb = downloaded / (1024 * 1024) + total_mb = total / (1024 * 1024) + self._status.showMessage(f"Downloading... {mb:.1f}/{total_mb:.1f} MB") + else: + self._dl_progress.setRange(0, 0) # indeterminate + self._dl_progress.show() + + def _on_image_done(self, path: str, info: str) -> None: + self._dl_progress.hide() + self._preview.set_media(path, info) + self._status.showMessage("Loaded") + # Update drag path on the selected thumbnail + idx = self._grid.selected_index + if 0 <= idx < len(self._grid._thumbs): + self._grid._thumbs[idx]._cached_path = path + + def _on_favorite_activated(self, fav) -> None: + info = f"Favorite #{fav.post_id}" + + # Try local cache first + if fav.cached_path and Path(fav.cached_path).exists(): + self._preview.set_media(fav.cached_path, info) + return + + # Try saved library + from ..core.config import saved_dir, saved_folder_dir + search_dirs = [saved_dir()] + if fav.folder: + search_dirs.insert(0, saved_folder_dir(fav.folder)) + for d in search_dirs: + for ext in MEDIA_EXTENSIONS: + path = d / f"{fav.post_id}{ext}" + if path.exists(): + self._preview.set_media(str(path), info) + return + + # Download it + self._status.showMessage(f"Downloading #{fav.post_id}...") + + async def _dl(): + try: + path = await download_image(fav.file_url) + # Update cached_path in DB + self._db.update_favorite_cache_path(fav.id, str(path)) + info = f"Favorite #{fav.post_id}" + self._signals.image_done.emit(str(path), info) + except Exception as e: + self._signals.image_error.emit(str(e)) + + self._run_async(_dl) + + def _open_preview_in_default(self) -> None: + # Try the currently selected post first + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + self._open_in_default(self._posts[idx]) + return + # Fall back to finding any cached image that matches the preview + from ..core.cache import cache_dir + from PySide6.QtGui import QDesktopServices + # Open the most recently modified file in cache + cache = cache_dir() + files = sorted(cache.iterdir(), key=lambda f: f.stat().st_mtime, reverse=True) + for f in files: + if f.is_file() and f.suffix in ('.jpg', '.jpeg', '.png', '.gif', '.webp'): + QDesktopServices.openUrl(QUrl.fromLocalFile(str(f))) + return + + def _open_preview_in_browser(self) -> None: + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + self._open_in_browser(self._posts[idx]) + + def _navigate_preview(self, direction: int) -> None: + """Navigate to prev/next post in the preview. direction: -1 or +1.""" + idx = self._grid.selected_index + direction + log.info(f"Navigate: direction={direction} current={self._grid.selected_index} next={idx} total={len(self._posts)}") + if 0 <= idx < len(self._posts): + self._grid._select(idx) + self._on_post_activated(idx) + + def _favorite_from_preview(self) -> None: + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + self._toggle_favorite(idx) + + def _save_from_preview(self, folder: str) -> None: + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + target = folder if folder else None + if folder and folder not in self._db.get_folders(): + self._db.add_folder(folder) + self._save_to_library(self._posts[idx], target) + + def _close_preview(self) -> None: + self._preview.clear() + + # -- Context menu -- + + def _on_context_menu(self, index: int, pos) -> None: + if index < 0 or index >= len(self._posts): + return + post = self._posts[index] + menu = QMenu(self) + + open_browser = menu.addAction("Open in Browser") + open_default = menu.addAction("Open in Default App") + menu.addSeparator() + save_as = menu.addAction("Save As...") + + # Save to Library submenu + save_lib_menu = menu.addMenu("Save to Library") + save_lib_unsorted = save_lib_menu.addAction("Unsorted") + save_lib_menu.addSeparator() + save_lib_folders = {} + for folder in self._db.get_folders(): + a = save_lib_menu.addAction(folder) + save_lib_folders[id(a)] = folder + save_lib_menu.addSeparator() + save_lib_new = save_lib_menu.addAction("+ New Folder...") + + copy_url = menu.addAction("Copy Image URL") + copy_tags = menu.addAction("Copy Tags") + menu.addSeparator() + fav_action = menu.addAction("Unfavorite" if self._is_current_favorited(index) else "Favorite") + menu.addSeparator() + bl_menu = menu.addMenu("Blacklist Tag") + for tag in post.tag_list[:20]: + bl_menu.addAction(tag) + + action = menu.exec(pos) + if not action: + return + + if action == open_browser: + self._open_in_browser(post) + elif action == open_default: + self._open_in_default(post) + elif action == save_as: + self._save_as(post) + elif action == save_lib_unsorted: + self._save_to_library(post, None) + elif action == save_lib_new: + from PySide6.QtWidgets import QInputDialog + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self._db.add_folder(name.strip()) + self._save_to_library(post, name.strip()) + elif id(action) in save_lib_folders: + self._save_to_library(post, save_lib_folders[id(action)]) + elif action == copy_url: + QApplication.clipboard().setText(post.file_url) + self._status.showMessage("URL copied") + elif action == copy_tags: + QApplication.clipboard().setText(post.tags) + self._status.showMessage("Tags copied") + elif action == fav_action: + self._toggle_favorite(index) + elif action.parent() == bl_menu: + tag = action.text() + self._db.add_blacklisted_tag(tag) + self._status.showMessage(f"Blacklisted: {tag}") + + def _on_multi_context_menu(self, indices: list, pos) -> None: + """Context menu for multi-selected posts.""" + posts = [self._posts[i] for i in indices if 0 <= i < len(self._posts)] + if not posts: + return + count = len(posts) + + menu = QMenu(self) + fav_all = menu.addAction(f"Favorite All ({count})") + + save_menu = menu.addMenu(f"Save All to Library ({count})") + save_unsorted = save_menu.addAction("Unsorted") + save_folder_actions = {} + for folder in self._db.get_folders(): + a = save_menu.addAction(folder) + save_folder_actions[id(a)] = folder + save_menu.addSeparator() + save_new = save_menu.addAction("+ New Folder...") + + menu.addSeparator() + unfav_all = menu.addAction(f"Unfavorite All ({count})") + menu.addSeparator() + batch_dl = menu.addAction(f"Download All ({count})...") + copy_urls = menu.addAction("Copy All URLs") + + action = menu.exec(pos) + if not action: + return + + if action == fav_all: + self._bulk_favorite(indices, posts) + elif action == save_unsorted: + self._bulk_save(indices, posts, None) + elif action == save_new: + from PySide6.QtWidgets import QInputDialog + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self._db.add_folder(name.strip()) + self._bulk_save(indices, posts, name.strip()) + elif id(action) in save_folder_actions: + self._bulk_save(indices, posts, save_folder_actions[id(action)]) + elif action == batch_dl: + from .dialogs import select_directory + dest = select_directory(self, "Download to folder") + if dest: + self._batch_download_posts(posts, dest) + elif action == unfav_all: + site_id = self._site_combo.currentData() + if site_id: + from ..core.cache import delete_from_library + from ..core.config import saved_dir, saved_folder_dir + for post in posts: + # Delete from unsorted library + delete_from_library(post.id, None) + # Delete from all folders + for folder in self._db.get_folders(): + delete_from_library(post.id, folder) + self._db.remove_favorite(site_id, post.id) + for idx in indices: + if 0 <= idx < len(self._grid._thumbs): + self._grid._thumbs[idx].set_favorited(False) + self._grid._thumbs[idx].set_saved_locally(False) + self._grid._clear_multi() + self._status.showMessage(f"Unfavorited {count} posts") + elif action == copy_urls: + urls = "\n".join(p.file_url for p in posts) + QApplication.clipboard().setText(urls) + self._status.showMessage(f"Copied {count} URLs") + + def _bulk_favorite(self, indices: list[int], posts: list[Post]) -> None: + site_id = self._site_combo.currentData() + if not site_id: + return + self._status.showMessage(f"Favoriting {len(posts)}...") + + async def _do(): + for i, (idx, post) in enumerate(zip(indices, posts)): + if self._db.is_favorited(site_id, post.id): + continue + try: + path = await download_image(post.file_url) + self._db.add_favorite( + site_id=site_id, post_id=post.id, + file_url=post.file_url, preview_url=post.preview_url, + tags=post.tags, rating=post.rating, score=post.score, + source=post.source, cached_path=str(path), + ) + self._signals.fav_done.emit(idx, f"Favorited {i+1}/{len(posts)}") + except Exception: + pass + self._signals.batch_done.emit(f"Favorited {len(posts)} posts") + + self._run_async(_do) + + def _bulk_save(self, indices: list[int], posts: list[Post], folder: str | None) -> None: + site_id = self._site_combo.currentData() + where = folder or "Unsorted" + self._status.showMessage(f"Saving {len(posts)} to {where}...") + + async def _do(): + from ..core.config import saved_dir, saved_folder_dir + import shutil + for i, (idx, post) in enumerate(zip(indices, posts)): + try: + path = await download_image(post.file_url) + ext = Path(path).suffix + dest_dir = saved_folder_dir(folder) if folder else saved_dir() + dest = dest_dir / f"{post.id}{ext}" + if not dest.exists(): + shutil.copy2(path, dest) + if site_id and not self._db.is_favorited(site_id, post.id): + self._db.add_favorite( + site_id=site_id, post_id=post.id, + file_url=post.file_url, preview_url=post.preview_url, + tags=post.tags, rating=post.rating, score=post.score, + source=post.source, cached_path=str(path), folder=folder, + ) + self._signals.fav_done.emit(idx, f"Saved {i+1}/{len(posts)} to {where}") + except Exception: + pass + self._signals.batch_done.emit(f"Saved {len(posts)} to {where}") + + self._run_async(_do) + + def _toggle_favorite_if_not(self, post: Post) -> None: + """Favorite a post if not already favorited.""" + site_id = self._site_combo.currentData() + if not site_id or self._db.is_favorited(site_id, post.id): + return + + async def _fav(): + try: + path = await download_image(post.file_url) + self._db.add_favorite( + site_id=site_id, + post_id=post.id, + file_url=post.file_url, + preview_url=post.preview_url, + tags=post.tags, + rating=post.rating, + score=post.score, + source=post.source, + cached_path=str(path), + ) + except Exception: + pass + + self._run_async(_fav) + + def _batch_download_posts(self, posts: list, dest: str) -> None: + async def _batch(): + for i, post in enumerate(posts): + try: + path = await download_image(post.file_url) + ext = Path(path).suffix + target = Path(dest) / f"{post.id}{ext}" + if not target.exists(): + import shutil + shutil.copy2(path, target) + self._signals.batch_progress.emit(i + 1, len(posts)) + except Exception as e: + log.warning(f"Batch #{post.id} failed: {e}") + self._signals.batch_done.emit(f"Downloaded {len(posts)} images to {dest}") + + self._run_async(_batch) + + def _is_current_favorited(self, index: int) -> bool: + site_id = self._site_combo.currentData() + if not site_id or index < 0 or index >= len(self._posts): + return False + return self._db.is_favorited(site_id, self._posts[index].id) + + def _open_in_browser(self, post: Post) -> None: + if self._current_site: + base = self._current_site.url + api = self._current_site.api_type + if api == "danbooru" or api == "e621": + url = f"{base}/posts/{post.id}" + elif api == "gelbooru": + url = f"{base}/index.php?page=post&s=view&id={post.id}" + elif api == "moebooru": + url = f"{base}/post/show/{post.id}" + else: + url = f"{base}/posts/{post.id}" + QDesktopServices.openUrl(QUrl(url)) + + def _open_in_default(self, post: Post) -> None: + from ..core.cache import cached_path_for, is_cached + path = cached_path_for(post.file_url) + if path.exists(): + QDesktopServices.openUrl(QUrl.fromLocalFile(str(path))) + else: + self._status.showMessage("Image not cached yet — double-click to download first") + + def _save_to_library(self, post: Post, folder: str | None) -> None: + """Download and save image to the library folder structure.""" + from ..core.config import saved_dir, saved_folder_dir + + self._status.showMessage(f"Saving #{post.id} to library...") + + async def _save(): + try: + path = await download_image(post.file_url) + ext = Path(path).suffix + if folder: + dest_dir = saved_folder_dir(folder) + else: + dest_dir = saved_dir() + dest = dest_dir / f"{post.id}{ext}" + if not dest.exists(): + import shutil + shutil.copy2(path, dest) + + # Also favorite it with the folder + site_id = self._site_combo.currentData() + if site_id and not self._db.is_favorited(site_id, post.id): + self._db.add_favorite( + site_id=site_id, + post_id=post.id, + file_url=post.file_url, + preview_url=post.preview_url, + tags=post.tags, + rating=post.rating, + score=post.score, + source=post.source, + cached_path=str(path), + folder=folder, + ) + elif site_id and folder: + # Already favorited, just update the folder + favs = self._db.get_favorites(site_id=site_id) + for f in favs: + if f.post_id == post.id: + self._db.move_favorite_to_folder(f.id, folder) + break + + where = folder or "Unsorted" + self._signals.fav_done.emit( + self._grid.selected_index, + f"Saved #{post.id} to {where}" + ) + except Exception as e: + self._signals.fav_error.emit(str(e)) + + self._run_async(_save) + + def _save_as(self, post: Post) -> None: + from ..core.cache import cached_path_for + from .dialogs import save_file + src = cached_path_for(post.file_url) + if not src.exists(): + self._status.showMessage("Image not cached — double-click to download first") + return + ext = src.suffix + dest = save_file(self, "Save Image", f"post_{post.id}{ext}", f"Images (*{ext})") + if dest: + import shutil + shutil.copy2(src, dest) + self._status.showMessage(f"Saved to {dest}") + + # -- Batch download -- + + def _batch_download(self) -> None: + if not self._posts: + self._status.showMessage("No posts to download") + return + from .dialogs import select_directory + dest = select_directory(self, "Download to folder") + if not dest: + return + + posts = list(self._posts) + self._status.showMessage(f"Downloading {len(posts)} images...") + + async def _batch(): + for i, post in enumerate(posts): + try: + path = await download_image(post.file_url) + ext = Path(path).suffix + target = Path(dest) / f"{post.id}{ext}" + if not target.exists(): + import shutil + shutil.copy2(path, target) + self._signals.batch_progress.emit(i + 1, len(posts)) + except Exception as e: + log.warning(f"Batch #{post.id} failed: {e}") + self._signals.batch_done.emit(f"Downloaded {len(posts)} images to {dest}") + + self._run_async(_batch) + + def _on_batch_progress(self, current: int, total: int) -> None: + self._status.showMessage(f"Downloading {current}/{total}...") + + # -- Toggles -- + + def _toggle_log(self) -> None: + self._log_text.setVisible(not self._log_text.isVisible()) + + def _toggle_info(self) -> None: + self._info_panel.setVisible(not self._info_panel.isVisible()) + if self._info_panel.isVisible() and 0 <= self._grid.selected_index < len(self._posts): + self._info_panel.set_post(self._posts[self._grid.selected_index]) + + def _open_site_manager(self) -> None: + dlg = SiteManagerDialog(self._db, self) + dlg.sites_changed.connect(self._load_sites) + dlg.exec() + + def _open_settings(self) -> None: + dlg = SettingsDialog(self._db, self) + dlg.settings_changed.connect(self._apply_settings) + self._favorites_imported = False + dlg.favorites_imported.connect(lambda: setattr(self, '_favorites_imported', True)) + dlg.exec() + if self._favorites_imported: + self._switch_view(1) + self._favorites_view.refresh() + + def _apply_settings(self) -> None: + """Re-read settings from DB and apply to UI.""" + rating = self._db.get_setting("default_rating") + idx = self._rating_combo.findText(rating.capitalize() if rating != "all" else "All") + if idx >= 0: + self._rating_combo.setCurrentIndex(idx) + self._score_spin.setValue(self._db.get_setting_int("default_score")) + self._favorites_view.refresh() + self._status.showMessage("Settings applied") + + # -- Fullscreen & Privacy -- + + def _toggle_fullscreen(self) -> None: + if self.isFullScreen(): + self.showNormal() + else: + self.showFullScreen() + + # -- Privacy screen -- + + def _toggle_privacy(self) -> None: + if not hasattr(self, '_privacy_on'): + self._privacy_on = False + self._privacy_overlay = QWidget(self) + self._privacy_overlay.setStyleSheet("background: black;") + self._privacy_overlay.hide() + + self._privacy_on = not self._privacy_on + if self._privacy_on: + self._privacy_overlay.setGeometry(self.rect()) + self._privacy_overlay.raise_() + self._privacy_overlay.show() + self.setWindowTitle("booru-viewer") + else: + self._privacy_overlay.hide() + + def resizeEvent(self, event) -> None: + super().resizeEvent(event) + if hasattr(self, '_privacy_overlay') and self._privacy_on: + self._privacy_overlay.setGeometry(self.rect()) + + # -- Keyboard shortcuts -- + + def keyPressEvent(self, event) -> None: + key = event.key() + # Privacy screen always works + if key == Qt.Key.Key_P and event.modifiers() == Qt.KeyboardModifier.ControlModifier: + self._toggle_privacy() + return + # If privacy is on, only allow toggling it off + if hasattr(self, '_privacy_on') and self._privacy_on: + return + if key == Qt.Key.Key_F and self._posts: + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + self._toggle_favorite(idx) + return + elif key == Qt.Key.Key_I: + self._toggle_info() + return + elif key == Qt.Key.Key_O and self._posts: + idx = self._grid.selected_index + if 0 <= idx < len(self._posts): + self._open_in_default(self._posts[idx]) + return + super().keyPressEvent(event) + + # -- Favorites -- + + def _toggle_favorite(self, index: int) -> None: + post = self._posts[index] + site_id = self._site_combo.currentData() + if not site_id: + return + + if self._db.is_favorited(site_id, post.id): + # Delete from library if saved + favs = self._db.get_favorites(site_id=site_id) + for f in favs: + if f.post_id == post.id: + from ..core.cache import delete_from_library + delete_from_library(post.id, f.folder) + break + self._db.remove_favorite(site_id, post.id) + self._status.showMessage(f"Unfavorited #{post.id}") + thumbs = self._grid._thumbs + if 0 <= index < len(thumbs): + thumbs[index].set_favorited(False) + thumbs[index].set_saved_locally(False) + else: + self._status.showMessage(f"Favoriting #{post.id}...") + + async def _fav(): + try: + path = await download_image(post.file_url) + self._db.add_favorite( + site_id=site_id, + post_id=post.id, + file_url=post.file_url, + preview_url=post.preview_url, + tags=post.tags, + rating=post.rating, + score=post.score, + source=post.source, + cached_path=str(path), + ) + self._signals.fav_done.emit(index, f"Favorited #{post.id}") + except Exception as e: + self._signals.fav_error.emit(str(e)) + + self._run_async(_fav) + + def _on_fav_done(self, index: int, msg: str) -> None: + self._status.showMessage(msg) + thumbs = self._grid._thumbs + if 0 <= index < len(thumbs): + thumbs[index].set_favorited(True) + # Only green if actually saved to library, not just cached + if "Saved" in msg: + thumbs[index].set_saved_locally(True) + + def closeEvent(self, event) -> None: + self._db.close() + super().closeEvent(event) + + +def run() -> None: + from ..core.config import data_dir + + app = QApplication(sys.argv) + + # Load user custom stylesheet if it exists + custom_css = data_dir() / "custom.qss" + if custom_css.exists(): + try: + app.setStyleSheet(custom_css.read_text()) + except Exception: + pass + + # Set app icon (works in taskbar on all platforms) + from PySide6.QtGui import QIcon + # PyInstaller sets _MEIPASS for bundled data + base_dir = Path(getattr(sys, '_MEIPASS', Path(__file__).parent.parent.parent)) + icon_path = base_dir / "icon.png" + if not icon_path.exists(): + icon_path = Path(__file__).parent.parent.parent / "icon.png" + if not icon_path.exists(): + icon_path = data_dir() / "icon.png" + if icon_path.exists(): + app.setWindowIcon(QIcon(str(icon_path))) + + window = BooruApp() + window.show() + sys.exit(app.exec()) diff --git a/booru_viewer/gui/custom_css_guide.txt b/booru_viewer/gui/custom_css_guide.txt new file mode 100644 index 0000000..7ba61d6 --- /dev/null +++ b/booru_viewer/gui/custom_css_guide.txt @@ -0,0 +1,138 @@ +booru-viewer Custom Stylesheet Guide +===================================== + +Place a file named "custom.qss" in your data directory to override styles: + Linux: ~/.local/share/booru-viewer/custom.qss + Windows: %APPDATA%\booru-viewer\custom.qss + +The custom stylesheet is appended AFTER the default theme, so your rules +override the defaults. You can use any Qt stylesheet (QSS) syntax. + +WIDGET REFERENCE +---------------- + +Main window: QMainWindow +Buttons: QPushButton +Text inputs: QLineEdit +Dropdowns: QComboBox +Scroll bars: QScrollBar +Labels: QLabel +Status bar: QStatusBar +Tabs: QTabWidget, QTabBar +Lists: QListWidget +Menus: QMenu, QMenuBar +Tooltips: QToolTip +Dialogs: QDialog +Splitters: QSplitter +Progress bars: QProgressBar +Spin boxes: QSpinBox +Check boxes: QCheckBox +Sliders: QSlider + +EXAMPLES +-------- + +Change accent color from green to cyan: + + QWidget { + color: #00ffff; + } + QPushButton:pressed { + background-color: #009999; + color: #000000; + } + QLineEdit:focus { + border-color: #00ffff; + } + +Bigger font: + + QWidget { + font-size: 15px; + } + +Different background: + + QWidget { + background-color: #1a1a2e; + } + +Custom button style: + + QPushButton { + background-color: #222222; + color: #00ff00; + border: 1px solid #444444; + border-radius: 6px; + padding: 8px 20px; + } + QPushButton:hover { + background-color: #333333; + border-color: #00ff00; + } + +Wider scrollbar: + + QScrollBar:vertical { + width: 14px; + } + QScrollBar::handle:vertical { + min-height: 40px; + border-radius: 7px; + } + +Hide the info overlay on images: + + /* Target the info label in the preview */ + QLabel[objectName="info-label"] { + color: transparent; + } + +VIDEO PLAYER CONTROLS +--------------------- + +The video player controls are standard Qt widgets: + QPushButton - Play/Pause, Mute buttons + QSlider - Seek bar, Volume slider + QLabel - Time display + +Example - style the seek bar: + + QSlider::groove:horizontal { + background: #333333; + height: 6px; + border-radius: 3px; + } + QSlider::handle:horizontal { + background: #00ff00; + width: 14px; + height: 14px; + margin: -4px 0; + border-radius: 7px; + } + QSlider::sub-page:horizontal { + background: #009900; + border-radius: 3px; + } + +DEFAULT COLOR PALETTE +--------------------- + +These are the defaults you can override: + + Green (accent): #00ff00 + Dark green: #00cc00 + Dim green: #009900 + Background: #000000 + Background light: #111111 + Background lighter: #1a1a1a + Border: #333333 + +TIPS +---- + +- Restart the app after editing custom.qss +- Use a text editor to edit QSS - it's similar to CSS +- If something breaks, just delete custom.qss to reset +- Your custom styles override defaults, so you only need to include what you change +- The file is read at startup, not live-reloaded diff --git a/booru_viewer/gui/dialogs.py b/booru_viewer/gui/dialogs.py new file mode 100644 index 0000000..6a616af --- /dev/null +++ b/booru_viewer/gui/dialogs.py @@ -0,0 +1,101 @@ +"""Native file dialog wrappers. Uses zenity on Linux when GTK dialogs are preferred.""" + +from __future__ import annotations + +import subprocess +import sys +from pathlib import Path + +from PySide6.QtWidgets import QFileDialog, QWidget + +from ..core.config import IS_WINDOWS + + +def _use_gtk() -> bool: + if IS_WINDOWS: + return False + try: + from ..core.db import Database + db = Database() + val = db.get_setting("file_dialog_platform") + db.close() + return val == "gtk" + except Exception: + return False + + +def save_file( + parent: QWidget | None, + title: str, + default_name: str, + filter_str: str, +) -> str | None: + """Show a save file dialog. Returns path or None.""" + if _use_gtk(): + try: + result = subprocess.run( + [ + "zenity", "--file-selection", "--save", + "--title", title, + "--filename", default_name, + "--confirm-overwrite", + ], + capture_output=True, text=True, + ) + if result.returncode == 0: + return result.stdout.strip() + return None + except FileNotFoundError: + pass # zenity not installed, fall through to Qt + + path, _ = QFileDialog.getSaveFileName(parent, title, default_name, filter_str) + return path or None + + +def open_file( + parent: QWidget | None, + title: str, + filter_str: str, +) -> str | None: + """Show an open file dialog. Returns path or None.""" + if _use_gtk(): + try: + result = subprocess.run( + [ + "zenity", "--file-selection", + "--title", title, + ], + capture_output=True, text=True, + ) + if result.returncode == 0: + return result.stdout.strip() + return None + except FileNotFoundError: + pass + + path, _ = QFileDialog.getOpenFileName(parent, title, "", filter_str) + return path or None + + +def select_directory( + parent: QWidget | None, + title: str, +) -> str | None: + """Show a directory picker. Returns path or None.""" + if _use_gtk(): + try: + result = subprocess.run( + [ + "zenity", "--file-selection", "--directory", + "--title", title, + ], + capture_output=True, text=True, + ) + if result.returncode == 0: + return result.stdout.strip() + return None + except FileNotFoundError: + pass + + path = QFileDialog.getExistingDirectory(parent, title) + return path or None diff --git a/booru_viewer/gui/favorites.py b/booru_viewer/gui/favorites.py new file mode 100644 index 0000000..8e41108 --- /dev/null +++ b/booru_viewer/gui/favorites.py @@ -0,0 +1,301 @@ +"""Favorites browser widget with folder support.""" + +from __future__ import annotations + +import logging +import threading +import asyncio +from pathlib import Path + +from PySide6.QtCore import Qt, Signal, QObject +from PySide6.QtGui import QPixmap +from PySide6.QtWidgets import ( + QWidget, + QVBoxLayout, + QHBoxLayout, + QLineEdit, + QPushButton, + QLabel, + QComboBox, + QMenu, + QApplication, + QInputDialog, + QMessageBox, +) + +from ..core.db import Database, Favorite +from ..core.cache import download_thumbnail +from .grid import ThumbnailGrid + +log = logging.getLogger("booru") + + +class FavThumbSignals(QObject): + thumb_ready = Signal(int, str) + + +class FavoritesView(QWidget): + """Browse and search local favorites with folder support.""" + + favorite_selected = Signal(object) + favorite_activated = Signal(object) + + def __init__(self, db: Database, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._db = db + self._favorites: list[Favorite] = [] + self._signals = FavThumbSignals() + self._signals.thumb_ready.connect(self._on_thumb_ready, Qt.ConnectionType.QueuedConnection) + + layout = QVBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + + # Top bar: folder selector + search + top = QHBoxLayout() + + self._folder_combo = QComboBox() + self._folder_combo.setMinimumWidth(120) + self._folder_combo.currentTextChanged.connect(lambda _: self.refresh()) + top.addWidget(self._folder_combo) + + manage_btn = QPushButton("+ Folder") + manage_btn.setToolTip("New folder") + manage_btn.setFixedWidth(65) + manage_btn.clicked.connect(self._new_folder) + top.addWidget(manage_btn) + + self._search_input = QLineEdit() + self._search_input.setPlaceholderText("Search favorites by tag...") + self._search_input.returnPressed.connect(self._do_search) + top.addWidget(self._search_input, stretch=1) + + search_btn = QPushButton("Search") + search_btn.clicked.connect(self._do_search) + top.addWidget(search_btn) + + top.setContentsMargins(0, 0, 0, 0) + + layout.addLayout(top) + + # Count label + self._count_label = QLabel() + layout.addWidget(self._count_label) + + # Grid + self._grid = ThumbnailGrid() + self._grid.post_selected.connect(self._on_selected) + self._grid.post_activated.connect(self._on_activated) + self._grid.context_requested.connect(self._on_context_menu) + layout.addWidget(self._grid) + + def _refresh_folders(self) -> None: + current = self._folder_combo.currentText() + self._folder_combo.blockSignals(True) + self._folder_combo.clear() + self._folder_combo.addItem("All Favorites") + self._folder_combo.addItem("Unfiled") + for folder in self._db.get_folders(): + self._folder_combo.addItem(folder) + # Restore selection + idx = self._folder_combo.findText(current) + if idx >= 0: + self._folder_combo.setCurrentIndex(idx) + self._folder_combo.blockSignals(False) + + def refresh(self, search: str | None = None) -> None: + self._refresh_folders() + + folder_text = self._folder_combo.currentText() + folder_filter = None + if folder_text == "Unfiled": + folder_filter = "" # sentinel for NULL folder + elif folder_text not in ("All Favorites", ""): + folder_filter = folder_text + + if folder_filter == "": + # Get unfiled: folder IS NULL + self._favorites = [ + f for f in self._db.get_favorites(search=search, limit=500) + if f.folder is None + ] + elif folder_filter: + self._favorites = self._db.get_favorites(search=search, folder=folder_filter, limit=500) + else: + self._favorites = self._db.get_favorites(search=search, limit=500) + + self._count_label.setText(f"{len(self._favorites)} favorites") + thumbs = self._grid.set_posts(len(self._favorites)) + + from ..core.config import saved_dir, saved_folder_dir, MEDIA_EXTENSIONS + for i, (fav, thumb) in enumerate(zip(self._favorites, thumbs)): + thumb.set_favorited(True) + # Check if saved to library + saved = False + if fav.folder: + saved = any( + (saved_folder_dir(fav.folder) / f"{fav.post_id}{ext}").exists() + for ext in MEDIA_EXTENSIONS + ) + else: + saved = any( + (saved_dir() / f"{fav.post_id}{ext}").exists() + for ext in MEDIA_EXTENSIONS + ) + thumb.set_saved_locally(saved) + if fav.preview_url: + self._load_thumb_async(i, fav.preview_url) + elif fav.cached_path and Path(fav.cached_path).exists(): + pix = QPixmap(fav.cached_path) + if not pix.isNull(): + thumb.set_pixmap(pix) + + def _load_thumb_async(self, index: int, url: str) -> None: + async def _dl(): + try: + path = await download_thumbnail(url) + self._signals.thumb_ready.emit(index, str(path)) + except Exception as e: + log.warning(f"Fav thumb {index} failed: {e}") + threading.Thread(target=lambda: asyncio.run(_dl()), daemon=True).start() + + def _on_thumb_ready(self, index: int, path: str) -> None: + thumbs = self._grid._thumbs + if 0 <= index < len(thumbs): + pix = QPixmap(path) + if not pix.isNull(): + thumbs[index].set_pixmap(pix) + + def _do_search(self) -> None: + text = self._search_input.text().strip() + self.refresh(search=text if text else None) + + def _on_selected(self, index: int) -> None: + if 0 <= index < len(self._favorites): + self.favorite_selected.emit(self._favorites[index]) + + def _on_activated(self, index: int) -> None: + if 0 <= index < len(self._favorites): + self.favorite_activated.emit(self._favorites[index]) + + def _copy_to_library_unsorted(self, fav: Favorite) -> None: + """Copy a favorited image to the unsorted library folder.""" + from ..core.config import saved_dir + if fav.cached_path and Path(fav.cached_path).exists(): + import shutil + src = Path(fav.cached_path) + dest = saved_dir() / f"{fav.post_id}{src.suffix}" + if not dest.exists(): + shutil.copy2(src, dest) + + def _copy_to_library(self, fav: Favorite, folder: str) -> None: + """Copy a favorited image to the library folder on disk.""" + from ..core.config import saved_folder_dir + if fav.cached_path and Path(fav.cached_path).exists(): + import shutil + src = Path(fav.cached_path) + dest = saved_folder_dir(folder) / f"{fav.post_id}{src.suffix}" + if not dest.exists(): + shutil.copy2(src, dest) + + def _new_folder(self) -> None: + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self._db.add_folder(name.strip()) + self._refresh_folders() + + def _on_context_menu(self, index: int, pos) -> None: + if index < 0 or index >= len(self._favorites): + return + fav = self._favorites[index] + + from PySide6.QtGui import QDesktopServices + from PySide6.QtCore import QUrl + from .dialogs import save_file + + menu = QMenu(self) + + open_default = menu.addAction("Open in Default App") + menu.addSeparator() + save_as = menu.addAction("Save As...") + + # Save to Library submenu + save_lib_menu = menu.addMenu("Save to Library") + save_lib_unsorted = save_lib_menu.addAction("Unsorted") + save_lib_menu.addSeparator() + save_lib_folders = {} + for folder in self._db.get_folders(): + a = save_lib_menu.addAction(folder) + save_lib_folders[id(a)] = folder + save_lib_menu.addSeparator() + save_lib_new = save_lib_menu.addAction("+ New Folder...") + + copy_url = menu.addAction("Copy Image URL") + copy_tags = menu.addAction("Copy Tags") + + # Move to folder submenu + menu.addSeparator() + move_menu = menu.addMenu("Move to Folder") + move_none = move_menu.addAction("Unfiled") + move_menu.addSeparator() + folder_actions = {} + for folder in self._db.get_folders(): + a = move_menu.addAction(folder) + folder_actions[id(a)] = folder + move_menu.addSeparator() + move_new = move_menu.addAction("+ New Folder...") + + menu.addSeparator() + unfav = menu.addAction("Unfavorite") + + action = menu.exec(pos) + if not action: + return + + if action == save_lib_unsorted: + self._copy_to_library_unsorted(fav) + self.refresh() + elif action == save_lib_new: + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self._db.add_folder(name.strip()) + self._copy_to_library(fav, name.strip()) + self._db.move_favorite_to_folder(fav.id, name.strip()) + self.refresh() + elif id(action) in save_lib_folders: + folder_name = save_lib_folders[id(action)] + self._copy_to_library(fav, folder_name) + self.refresh() + elif action == open_default: + if fav.cached_path and Path(fav.cached_path).exists(): + QDesktopServices.openUrl(QUrl.fromLocalFile(fav.cached_path)) + elif action == save_as: + if fav.cached_path and Path(fav.cached_path).exists(): + src = Path(fav.cached_path) + dest = save_file(self, "Save Image", f"post_{fav.post_id}{src.suffix}", f"Images (*{src.suffix})") + if dest: + import shutil + shutil.copy2(src, dest) + elif action == copy_url: + QApplication.clipboard().setText(fav.file_url) + elif action == copy_tags: + QApplication.clipboard().setText(fav.tags) + elif action == move_none: + self._db.move_favorite_to_folder(fav.id, None) + self.refresh() + elif action == move_new: + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self._db.add_folder(name.strip()) + self._db.move_favorite_to_folder(fav.id, name.strip()) + self._copy_to_library(fav, name.strip()) + self.refresh() + elif id(action) in folder_actions: + folder_name = folder_actions[id(action)] + self._db.move_favorite_to_folder(fav.id, folder_name) + self._copy_to_library(fav, folder_name) + self.refresh() + elif action == unfav: + from ..core.cache import delete_from_library + delete_from_library(fav.post_id, fav.folder) + self._db.remove_favorite(fav.site_id, fav.post_id) + self.refresh() diff --git a/booru_viewer/gui/grid.py b/booru_viewer/gui/grid.py new file mode 100644 index 0000000..6e8ba17 --- /dev/null +++ b/booru_viewer/gui/grid.py @@ -0,0 +1,380 @@ +"""Thumbnail grid widget for the Qt6 GUI.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import Qt, Signal, QSize, QRect, QMimeData, QUrl, QPoint +from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QKeyEvent, QDrag +from PySide6.QtWidgets import ( + QWidget, + QScrollArea, + QMenu, + QApplication, +) + +from ..core.api.base import Post + +THUMB_SIZE = 180 +THUMB_SPACING = 8 +BORDER_WIDTH = 2 + + +class ThumbnailWidget(QWidget): + """Single clickable thumbnail cell.""" + + clicked = Signal(int, object) # index, QMouseEvent + double_clicked = Signal(int) + right_clicked = Signal(int, object) # index, QPoint + + def __init__(self, index: int, parent: QWidget | None = None) -> None: + super().__init__(parent) + self.index = index + self._pixmap: QPixmap | None = None + self._selected = False + self._multi_selected = False + self._favorited = False + self._saved_locally = False + self._hover = False + self._drag_start: QPoint | None = None + self._cached_path: str | None = None + self.setFixedSize(THUMB_SIZE, THUMB_SIZE) + self.setCursor(Qt.CursorShape.PointingHandCursor) + self.setMouseTracking(True) + + def set_pixmap(self, pixmap: QPixmap) -> None: + self._pixmap = pixmap.scaled( + THUMB_SIZE - 4, THUMB_SIZE - 4, + Qt.AspectRatioMode.KeepAspectRatio, + Qt.TransformationMode.SmoothTransformation, + ) + self.update() + + def set_selected(self, selected: bool) -> None: + self._selected = selected + self.update() + + def set_multi_selected(self, selected: bool) -> None: + self._multi_selected = selected + self.update() + + def set_favorited(self, favorited: bool) -> None: + self._favorited = favorited + self.update() + + def set_saved_locally(self, saved: bool) -> None: + self._saved_locally = saved + self.update() + + def paintEvent(self, event) -> None: + p = QPainter(self) + p.setRenderHint(QPainter.RenderHint.Antialiasing) + pal = self.palette() + highlight = pal.color(pal.ColorRole.Highlight) + base = pal.color(pal.ColorRole.Base) + mid = pal.color(pal.ColorRole.Mid) + window = pal.color(pal.ColorRole.Window) + + # Background + if self._multi_selected: + bg = highlight.darker(200) + elif self._hover: + bg = window.lighter(130) + else: + bg = window + p.fillRect(self.rect(), bg) + + # Border + if self._selected: + pen = QPen(highlight, BORDER_WIDTH) + elif self._multi_selected: + pen = QPen(highlight.darker(150), BORDER_WIDTH) + else: + pen = QPen(mid, 1) + p.setPen(pen) + p.drawRect(self.rect().adjusted(0, 0, -1, -1)) + + # Thumbnail + if self._pixmap: + x = (self.width() - self._pixmap.width()) // 2 + y = (self.height() - self._pixmap.height()) // 2 + p.drawPixmap(x, y, self._pixmap) + + # Favorite/saved indicator + if self._favorited: + p.setPen(Qt.PenStyle.NoPen) + if self._saved_locally: + p.setBrush(QColor("#22cc22")) + else: + p.setBrush(QColor("#ff4444")) + p.drawEllipse(self.width() - 14, 4, 10, 10) + + # Multi-select checkmark + if self._multi_selected: + p.setPen(Qt.PenStyle.NoPen) + p.setBrush(highlight) + p.drawEllipse(4, 4, 12, 12) + p.setPen(QPen(base, 2)) + p.drawLine(7, 10, 9, 13) + p.drawLine(9, 13, 14, 7) + + p.end() + + def enterEvent(self, event) -> None: + self._hover = True + self.update() + + def leaveEvent(self, event) -> None: + self._hover = False + self.update() + + def mousePressEvent(self, event) -> None: + if event.button() == Qt.MouseButton.LeftButton: + self._drag_start = event.position().toPoint() + self.clicked.emit(self.index, event) + elif event.button() == Qt.MouseButton.RightButton: + self.right_clicked.emit(self.index, event.globalPosition().toPoint()) + + def mouseMoveEvent(self, event) -> None: + if (self._drag_start and self._cached_path + and (event.position().toPoint() - self._drag_start).manhattanLength() > 10): + drag = QDrag(self) + mime = QMimeData() + mime.setUrls([QUrl.fromLocalFile(self._cached_path)]) + drag.setMimeData(mime) + if self._pixmap: + drag.setPixmap(self._pixmap.scaled(64, 64, Qt.AspectRatioMode.KeepAspectRatio)) + drag.exec(Qt.DropAction.CopyAction) + self._drag_start = None + return + super().mouseMoveEvent(event) + + def mouseReleaseEvent(self, event) -> None: + self._drag_start = None + + def mouseDoubleClickEvent(self, event) -> None: + self._drag_start = None + if event.button() == Qt.MouseButton.LeftButton: + self.double_clicked.emit(self.index) + + +class FlowLayout(QWidget): + """A widget that arranges children in a wrapping flow.""" + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._items: list[QWidget] = [] + + def add_widget(self, widget: QWidget) -> None: + widget.setParent(self) + self._items.append(widget) + self._do_layout() + + def clear(self) -> None: + for w in self._items: + w.setParent(None) # type: ignore + w.deleteLater() + self._items.clear() + self.setMinimumHeight(0) + + def resizeEvent(self, event) -> None: + self._do_layout() + + def _do_layout(self) -> None: + if not self._items: + return + x, y = THUMB_SPACING, THUMB_SPACING + row_height = 0 + width = self.width() or 800 + + for widget in self._items: + item_w = widget.width() + THUMB_SPACING + item_h = widget.height() + THUMB_SPACING + if x + item_w > width and x > THUMB_SPACING: + x = THUMB_SPACING + y += row_height + row_height = 0 + widget.move(x, y) + widget.show() + x += item_w + row_height = max(row_height, item_h) + + self.setMinimumHeight(y + row_height + THUMB_SPACING) + + @property + def columns(self) -> int: + if not self._items: + return 1 + w = self.width() or 800 + return max(1, w // (THUMB_SIZE + THUMB_SPACING)) + + +class ThumbnailGrid(QScrollArea): + """Scrollable grid of thumbnail widgets with keyboard nav, context menu, and multi-select.""" + + post_selected = Signal(int) + post_activated = Signal(int) + context_requested = Signal(int, object) # index, QPoint + multi_context_requested = Signal(list, object) # list[int], QPoint + reached_bottom = Signal() # emitted when scrolled to the bottom + reached_top = Signal() # emitted when scrolled to the top + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._flow = FlowLayout() + self.setWidget(self._flow) + self.setWidgetResizable(True) + self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) + self._thumbs: list[ThumbnailWidget] = [] + self._selected_index = -1 + self._multi_selected: set[int] = set() + self._last_click_index = -1 # for shift-click range + self.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + self.verticalScrollBar().valueChanged.connect(self._check_scroll_bottom) + + @property + def selected_index(self) -> int: + return self._selected_index + + @property + def selected_indices(self) -> list[int]: + """Return all multi-selected indices, or just the single selected one.""" + if self._multi_selected: + return sorted(self._multi_selected) + if self._selected_index >= 0: + return [self._selected_index] + return [] + + def set_posts(self, count: int) -> list[ThumbnailWidget]: + self._flow.clear() + self._thumbs.clear() + self._selected_index = -1 + self._multi_selected.clear() + self._last_click_index = -1 + + for i in range(count): + thumb = ThumbnailWidget(i) + thumb.clicked.connect(self._on_thumb_click) + thumb.double_clicked.connect(self._on_thumb_double_click) + thumb.right_clicked.connect(self._on_thumb_right_click) + self._flow.add_widget(thumb) + self._thumbs.append(thumb) + + return self._thumbs + + def _clear_multi(self) -> None: + for idx in self._multi_selected: + if 0 <= idx < len(self._thumbs): + self._thumbs[idx].set_multi_selected(False) + self._multi_selected.clear() + + def _select(self, index: int) -> None: + if index < 0 or index >= len(self._thumbs): + return + self._clear_multi() + if 0 <= self._selected_index < len(self._thumbs): + self._thumbs[self._selected_index].set_selected(False) + self._selected_index = index + self._last_click_index = index + self._thumbs[index].set_selected(True) + self.ensureWidgetVisible(self._thumbs[index]) + self.post_selected.emit(index) + + def _toggle_multi(self, index: int) -> None: + """Ctrl+click: toggle one item in/out of multi-selection.""" + # First ctrl+click: add the currently single-selected item too + if not self._multi_selected and self._selected_index >= 0: + self._multi_selected.add(self._selected_index) + self._thumbs[self._selected_index].set_multi_selected(True) + + if index in self._multi_selected: + self._multi_selected.discard(index) + self._thumbs[index].set_multi_selected(False) + else: + self._multi_selected.add(index) + self._thumbs[index].set_multi_selected(True) + self._last_click_index = index + + def _range_select(self, index: int) -> None: + """Shift+click: select range from last click to this one.""" + start = self._last_click_index if self._last_click_index >= 0 else 0 + lo, hi = min(start, index), max(start, index) + self._clear_multi() + for i in range(lo, hi + 1): + self._multi_selected.add(i) + self._thumbs[i].set_multi_selected(True) + + def _on_thumb_click(self, index: int, event) -> None: + mods = event.modifiers() + if mods & Qt.KeyboardModifier.ControlModifier: + self._toggle_multi(index) + elif mods & Qt.KeyboardModifier.ShiftModifier: + self._range_select(index) + else: + self._select(index) + + def _on_thumb_double_click(self, index: int) -> None: + self._select(index) + self.post_activated.emit(index) + + def _on_thumb_right_click(self, index: int, pos) -> None: + if self._multi_selected and index in self._multi_selected: + # Right-click on multi-selected: bulk context menu + self.multi_context_requested.emit(sorted(self._multi_selected), pos) + else: + self._select(index) + self.context_requested.emit(index, pos) + + def select_all(self) -> None: + self._clear_multi() + for i in range(len(self._thumbs)): + self._multi_selected.add(i) + self._thumbs[i].set_multi_selected(True) + + def keyPressEvent(self, event: QKeyEvent) -> None: + cols = self._flow.columns + idx = self._selected_index + + key = event.key() + mods = event.modifiers() + + # Ctrl+A = select all + if key == Qt.Key.Key_A and mods & Qt.KeyboardModifier.ControlModifier: + self.select_all() + return + + if key in (Qt.Key.Key_Right, Qt.Key.Key_L): + self._select(min(idx + 1, len(self._thumbs) - 1)) + elif key in (Qt.Key.Key_Left, Qt.Key.Key_H): + self._select(max(idx - 1, 0)) + elif key in (Qt.Key.Key_Down, Qt.Key.Key_J): + self._select(min(idx + cols, len(self._thumbs) - 1)) + elif key in (Qt.Key.Key_Up, Qt.Key.Key_K): + self._select(max(idx - cols, 0)) + elif key == Qt.Key.Key_Return or key == Qt.Key.Key_Enter: + if 0 <= idx < len(self._thumbs): + self.post_activated.emit(idx) + elif key == Qt.Key.Key_Home: + self._select(0) + elif key == Qt.Key.Key_End: + self._select(len(self._thumbs) - 1) + else: + super().keyPressEvent(event) + + def scroll_to_top(self) -> None: + self.verticalScrollBar().setValue(0) + + def scroll_to_bottom(self) -> None: + self.verticalScrollBar().setValue(self.verticalScrollBar().maximum()) + + def _check_scroll_bottom(self, value: int) -> None: + sb = self.verticalScrollBar() + if sb.maximum() > 0 and value >= sb.maximum() - 10: + self.reached_bottom.emit() + if value <= 0 and sb.maximum() > 0: + self.reached_top.emit() + + def resizeEvent(self, event) -> None: + super().resizeEvent(event) + if self._flow: + self._flow.resize(self.viewport().size().width(), self._flow.minimumHeight()) diff --git a/booru_viewer/gui/preview.py b/booru_viewer/gui/preview.py new file mode 100644 index 0000000..7de0426 --- /dev/null +++ b/booru_viewer/gui/preview.py @@ -0,0 +1,487 @@ +"""Full media preview — image viewer with zoom/pan and video player.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import Qt, QPoint, QPointF, Signal, QUrl +from PySide6.QtGui import QPixmap, QPainter, QWheelEvent, QMouseEvent, QKeyEvent, QColor, QMovie +from PySide6.QtWidgets import ( + QWidget, QVBoxLayout, QHBoxLayout, QLabel, QMainWindow, + QStackedWidget, QPushButton, QSlider, QMenu, QInputDialog, +) +from PySide6.QtMultimedia import QMediaPlayer, QAudioOutput +from PySide6.QtMultimediaWidgets import QVideoWidget + +from ..core.config import MEDIA_EXTENSIONS + +VIDEO_EXTENSIONS = (".mp4", ".webm", ".mkv", ".avi", ".mov") + + +def _is_video(path: str) -> bool: + return Path(path).suffix.lower() in VIDEO_EXTENSIONS + + +class FullscreenPreview(QMainWindow): + """Fullscreen image viewer window.""" + + def __init__(self, pixmap: QPixmap, info: str = "", parent=None) -> None: + super().__init__(parent) + self.setWindowTitle("booru-viewer — Fullscreen") + self._preview = ImageViewer() + self._preview.set_image(pixmap, info) + self._preview.close_requested.connect(self.close) + self.setCentralWidget(self._preview) + if parent: + screen = parent.screen() + else: + from PySide6.QtWidgets import QApplication + screen = QApplication.primaryScreen() + if screen: + self.setGeometry(screen.geometry()) + self.showFullScreen() + + def keyPressEvent(self, event: QKeyEvent) -> None: + if event.key() in (Qt.Key.Key_Escape, Qt.Key.Key_Q, Qt.Key.Key_F): + self.close() + else: + super().keyPressEvent(event) + + +# -- Image Viewer (zoom/pan) -- + +class ImageViewer(QWidget): + """Zoomable, pannable image viewer.""" + + close_requested = Signal() + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._pixmap: QPixmap | None = None + self._movie: QMovie | None = None + self._zoom = 1.0 + self._offset = QPointF(0, 0) + self._drag_start: QPointF | None = None + self._drag_offset = QPointF(0, 0) + self.setMouseTracking(True) + self.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + self._info_text = "" + + def set_image(self, pixmap: QPixmap, info: str = "") -> None: + self._stop_movie() + self._pixmap = pixmap + self._zoom = 1.0 + self._offset = QPointF(0, 0) + self._info_text = info + self._fit_to_view() + self.update() + + def set_gif(self, path: str, info: str = "") -> None: + self._stop_movie() + self._movie = QMovie(path) + self._movie.frameChanged.connect(self._on_gif_frame) + self._movie.start() + self._info_text = info + # Set initial pixmap from first frame + self._pixmap = self._movie.currentPixmap() + self._zoom = 1.0 + self._offset = QPointF(0, 0) + self._fit_to_view() + self.update() + + def _on_gif_frame(self) -> None: + if self._movie: + self._pixmap = self._movie.currentPixmap() + self.update() + + def _stop_movie(self) -> None: + if self._movie: + self._movie.stop() + self._movie = None + + def clear(self) -> None: + self._stop_movie() + self._pixmap = None + self._info_text = "" + self.update() + + def _fit_to_view(self) -> None: + if not self._pixmap: + return + vw, vh = self.width(), self.height() + pw, ph = self._pixmap.width(), self._pixmap.height() + if pw == 0 or ph == 0: + return + scale_w = vw / pw + scale_h = vh / ph + self._zoom = min(scale_w, scale_h, 1.0) + self._offset = QPointF( + (vw - pw * self._zoom) / 2, + (vh - ph * self._zoom) / 2, + ) + + def paintEvent(self, event) -> None: + p = QPainter(self) + pal = self.palette() + p.fillRect(self.rect(), pal.color(pal.ColorRole.Window)) + if self._pixmap: + p.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform) + p.translate(self._offset) + p.scale(self._zoom, self._zoom) + p.drawPixmap(0, 0, self._pixmap) + p.resetTransform() + p.end() + + def wheelEvent(self, event: QWheelEvent) -> None: + if not self._pixmap: + return + mouse_pos = event.position() + old_zoom = self._zoom + delta = event.angleDelta().y() + factor = 1.15 if delta > 0 else 1 / 1.15 + self._zoom = max(0.1, min(self._zoom * factor, 20.0)) + ratio = self._zoom / old_zoom + self._offset = mouse_pos - ratio * (mouse_pos - self._offset) + self.update() + + def mousePressEvent(self, event: QMouseEvent) -> None: + if event.button() == Qt.MouseButton.MiddleButton: + self._fit_to_view() + self.update() + elif event.button() == Qt.MouseButton.LeftButton: + self._drag_start = event.position() + self._drag_offset = QPointF(self._offset) + self.setCursor(Qt.CursorShape.ClosedHandCursor) + + def mouseMoveEvent(self, event: QMouseEvent) -> None: + if self._drag_start is not None: + delta = event.position() - self._drag_start + self._offset = self._drag_offset + delta + self.update() + + def mouseReleaseEvent(self, event: QMouseEvent) -> None: + self._drag_start = None + self.setCursor(Qt.CursorShape.ArrowCursor) + + def keyPressEvent(self, event: QKeyEvent) -> None: + if event.key() in (Qt.Key.Key_Escape, Qt.Key.Key_Q): + self.close_requested.emit() + elif event.key() == Qt.Key.Key_0: + self._fit_to_view() + self.update() + elif event.key() in (Qt.Key.Key_Plus, Qt.Key.Key_Equal): + self._zoom = min(self._zoom * 1.2, 20.0) + self.update() + elif event.key() == Qt.Key.Key_Minus: + self._zoom = max(self._zoom / 1.2, 0.1) + self.update() + + def resizeEvent(self, event) -> None: + if self._pixmap: + self._fit_to_view() + self.update() + + +# -- Video Player -- + +class VideoPlayer(QWidget): + """Video player with transport controls.""" + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + layout = QVBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.setSpacing(0) + + # Video surface + self._video_widget = QVideoWidget() + self._video_widget.setAutoFillBackground(True) + layout.addWidget(self._video_widget, stretch=1) + + # Player + self._player = QMediaPlayer() + self._audio = QAudioOutput() + self._player.setAudioOutput(self._audio) + self._player.setVideoOutput(self._video_widget) + self._audio.setVolume(0.5) + + # Controls bar + controls = QHBoxLayout() + controls.setContentsMargins(4, 2, 4, 2) + + self._play_btn = QPushButton("Play") + self._play_btn.setFixedWidth(65) + self._play_btn.clicked.connect(self._toggle_play) + controls.addWidget(self._play_btn) + + self._time_label = QLabel("0:00") + self._time_label.setFixedWidth(45) + controls.addWidget(self._time_label) + + self._seek_slider = QSlider(Qt.Orientation.Horizontal) + self._seek_slider.setRange(0, 0) + self._seek_slider.sliderMoved.connect(self._seek) + controls.addWidget(self._seek_slider, stretch=1) + + self._duration_label = QLabel("0:00") + self._duration_label.setFixedWidth(45) + controls.addWidget(self._duration_label) + + self._vol_slider = QSlider(Qt.Orientation.Horizontal) + self._vol_slider.setRange(0, 100) + self._vol_slider.setValue(50) + self._vol_slider.setFixedWidth(80) + self._vol_slider.valueChanged.connect(self._set_volume) + controls.addWidget(self._vol_slider) + + self._mute_btn = QPushButton("Mute") + self._mute_btn.setFixedWidth(80) + self._mute_btn.clicked.connect(self._toggle_mute) + controls.addWidget(self._mute_btn) + + self._autoplay = True + self._autoplay_btn = QPushButton("Auto") + self._autoplay_btn.setFixedWidth(50) + self._autoplay_btn.setCheckable(True) + self._autoplay_btn.setChecked(True) + self._autoplay_btn.setToolTip("Auto-play videos when selected") + self._autoplay_btn.clicked.connect(self._toggle_autoplay) + controls.addWidget(self._autoplay_btn) + + layout.addLayout(controls) + + # Signals + self._player.positionChanged.connect(self._on_position) + self._player.durationChanged.connect(self._on_duration) + self._player.playbackStateChanged.connect(self._on_state) + self._player.mediaStatusChanged.connect(self._on_media_status) + self._player.errorOccurred.connect(self._on_error) + self._current_file: str | None = None + self._error_fired = False + + def play_file(self, path: str, info: str = "") -> None: + self._current_file = path + self._error_fired = False + self._player.setSource(QUrl.fromLocalFile(path)) + if self._autoplay: + self._player.play() + else: + self._player.pause() + + def _toggle_autoplay(self, checked: bool = True) -> None: + self._autoplay = self._autoplay_btn.isChecked() + self._autoplay_btn.setText("Auto" if self._autoplay else "Man.") + + def stop(self) -> None: + self._player.stop() + self._player.setSource(QUrl()) + + def _toggle_play(self) -> None: + if self._player.playbackState() == QMediaPlayer.PlaybackState.PlayingState: + self._player.pause() + else: + self._player.play() + + def _seek(self, pos: int) -> None: + self._player.setPosition(pos) + + def _set_volume(self, val: int) -> None: + self._audio.setVolume(val / 100.0) + + def _toggle_mute(self) -> None: + self._audio.setMuted(not self._audio.isMuted()) + self._mute_btn.setText("Unmute" if self._audio.isMuted() else "Mute") + + def _on_position(self, pos: int) -> None: + if not self._seek_slider.isSliderDown(): + self._seek_slider.setValue(pos) + self._time_label.setText(self._fmt(pos)) + + def _on_duration(self, dur: int) -> None: + self._seek_slider.setRange(0, dur) + self._duration_label.setText(self._fmt(dur)) + + def _on_state(self, state) -> None: + if state == QMediaPlayer.PlaybackState.PlayingState: + self._play_btn.setText("Pause") + else: + self._play_btn.setText("Play") + + def _on_media_status(self, status) -> None: + # Manual loop: when video ends, restart it + if status == QMediaPlayer.MediaStatus.EndOfMedia: + self._player.setPosition(0) + self._player.play() + + def _on_error(self, error, msg: str = "") -> None: + if self._current_file and not self._error_fired: + self._error_fired = True + from PySide6.QtGui import QDesktopServices + QDesktopServices.openUrl(QUrl.fromLocalFile(self._current_file)) + + @staticmethod + def _fmt(ms: int) -> str: + s = ms // 1000 + m = s // 60 + return f"{m}:{s % 60:02d}" + + +# -- Combined Preview (image + video) -- + +class ImagePreview(QWidget): + """Combined media preview — auto-switches between image and video.""" + + close_requested = Signal() + open_in_default = Signal() + open_in_browser = Signal() + save_to_folder = Signal(str) + favorite_requested = Signal() + navigate = Signal(int) # -1 = prev, +1 = next + + def __init__(self, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._folders_callback = None + self._current_path: str | None = None + + layout = QVBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.setSpacing(0) + + self._stack = QStackedWidget() + layout.addWidget(self._stack) + + # Image viewer (index 0) + self._image_viewer = ImageViewer() + self._image_viewer.close_requested.connect(self.close_requested) + self._stack.addWidget(self._image_viewer) + + # Video player (index 1) + self._video_player = VideoPlayer() + self._stack.addWidget(self._video_player) + + # Info label + self._info_label = QLabel() + self._info_label.setStyleSheet("padding: 2px 6px;") + layout.addWidget(self._info_label) + + self.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) + self.customContextMenuRequested.connect(self._on_context_menu) + + # Keep these for compatibility with app.py accessing them + @property + def _pixmap(self): + return self._image_viewer._pixmap + + @property + def _info_text(self): + return self._image_viewer._info_text + + def set_folders_callback(self, callback) -> None: + self._folders_callback = callback + + def set_image(self, pixmap: QPixmap, info: str = "") -> None: + self._video_player.stop() + self._image_viewer.set_image(pixmap, info) + self._stack.setCurrentIndex(0) + self._info_label.setText(info) + self._current_path = None + + def set_media(self, path: str, info: str = "") -> None: + """Auto-detect and show image or video.""" + self._current_path = path + ext = Path(path).suffix.lower() + if _is_video(path): + self._image_viewer.clear() + self._video_player.stop() + self._video_player.play_file(path, info) + self._stack.setCurrentIndex(1) + self._info_label.setText(info) + elif ext == ".gif": + self._video_player.stop() + self._image_viewer.set_gif(path, info) + self._stack.setCurrentIndex(0) + self._info_label.setText(info) + else: + self._video_player.stop() + pix = QPixmap(path) + if not pix.isNull(): + self._image_viewer.set_image(pix, info) + self._stack.setCurrentIndex(0) + self._info_label.setText(info) + + def clear(self) -> None: + self._video_player.stop() + self._image_viewer.clear() + self._info_label.setText("") + self._current_path = None + + def _on_context_menu(self, pos) -> None: + menu = QMenu(self) + fav_action = menu.addAction("Favorite") + + save_menu = menu.addMenu("Save to Library") + save_unsorted = save_menu.addAction("Unsorted") + save_menu.addSeparator() + save_folder_actions = {} + if self._folders_callback: + for folder in self._folders_callback(): + a = save_menu.addAction(folder) + save_folder_actions[id(a)] = folder + save_menu.addSeparator() + save_new = save_menu.addAction("+ New Folder...") + + menu.addSeparator() + copy_image = None + if self._stack.currentIndex() == 0 and self._image_viewer._pixmap: + copy_image = menu.addAction("Copy Image to Clipboard") + open_action = menu.addAction("Open in Default App") + browser_action = menu.addAction("Open in Browser") + + # Image-specific + reset_action = None + if self._stack.currentIndex() == 0: + reset_action = menu.addAction("Reset View") + + clear_action = menu.addAction("Clear Preview") + + action = menu.exec(self.mapToGlobal(pos)) + if not action: + return + if action == fav_action: + self.favorite_requested.emit() + elif action == save_unsorted: + self.save_to_folder.emit("") + elif action == save_new: + name, ok = QInputDialog.getText(self, "New Folder", "Folder name:") + if ok and name.strip(): + self.save_to_folder.emit(name.strip()) + elif id(action) in save_folder_actions: + self.save_to_folder.emit(save_folder_actions[id(action)]) + elif action == copy_image: + from PySide6.QtWidgets import QApplication + QApplication.clipboard().setPixmap(self._image_viewer._pixmap) + elif action == open_action: + self.open_in_default.emit() + elif action == browser_action: + self.open_in_browser.emit() + elif action == reset_action: + self._image_viewer._fit_to_view() + self._image_viewer.update() + elif action == clear_action: + self.close_requested.emit() + + def mousePressEvent(self, event: QMouseEvent) -> None: + if event.button() == Qt.MouseButton.RightButton: + event.ignore() + else: + super().mousePressEvent(event) + + def keyPressEvent(self, event: QKeyEvent) -> None: + if self._stack.currentIndex() == 0: + self._image_viewer.keyPressEvent(event) + elif event.key() == Qt.Key.Key_Space: + self._video_player._toggle_play() + + def resizeEvent(self, event) -> None: + super().resizeEvent(event) diff --git a/booru_viewer/gui/search.py b/booru_viewer/gui/search.py new file mode 100644 index 0000000..6578014 --- /dev/null +++ b/booru_viewer/gui/search.py @@ -0,0 +1,157 @@ +"""Search bar with tag autocomplete, history, and saved searches.""" + +from __future__ import annotations + +from PySide6.QtCore import Qt, Signal, QTimer, QStringListModel +from PySide6.QtWidgets import ( + QWidget, + QHBoxLayout, + QLineEdit, + QPushButton, + QCompleter, + QMenu, + QInputDialog, +) + +from ..core.db import Database + + +class SearchBar(QWidget): + """Tag search bar with autocomplete, history dropdown, and saved searches.""" + + search_requested = Signal(str) + autocomplete_requested = Signal(str) + + def __init__(self, db: Database | None = None, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._db = db + layout = QHBoxLayout(self) + layout.setContentsMargins(0, 0, 0, 0) + layout.setSpacing(6) + + # History button + self._history_btn = QPushButton("v") + self._history_btn.setFixedWidth(30) + self._history_btn.setToolTip("Search history & saved searches") + self._history_btn.clicked.connect(self._show_history_menu) + layout.addWidget(self._history_btn) + + self._input = QLineEdit() + self._input.setPlaceholderText("Search tags... (supports -negatives)") + self._input.returnPressed.connect(self._do_search) + layout.addWidget(self._input, stretch=1) + + # Save search button + self._save_btn = QPushButton("Save") + self._save_btn.setFixedWidth(40) + self._save_btn.setToolTip("Save current search") + self._save_btn.clicked.connect(self._save_current_search) + layout.addWidget(self._save_btn) + + self._btn = QPushButton("Search") + self._btn.clicked.connect(self._do_search) + layout.addWidget(self._btn) + + # Autocomplete + self._completer_model = QStringListModel() + self._completer = QCompleter(self._completer_model) + self._completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive) + self._completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion) + self._input.setCompleter(self._completer) + + # Debounce + self._ac_timer = QTimer() + self._ac_timer.setSingleShot(True) + self._ac_timer.setInterval(300) + self._ac_timer.timeout.connect(self._request_autocomplete) + self._input.textChanged.connect(self._on_text_changed) + + def _on_text_changed(self, text: str) -> None: + self._ac_timer.start() + + def _request_autocomplete(self) -> None: + text = self._input.text().strip() + if not text: + return + last_tag = text.split()[-1] if text.split() else "" + query = last_tag.lstrip("-") + if len(query) >= 2: + self.autocomplete_requested.emit(query) + + def set_suggestions(self, suggestions: list[str]) -> None: + self._completer_model.setStringList(suggestions) + + def _do_search(self) -> None: + query = self._input.text().strip() + if self._db and query: + self._db.add_search_history(query) + self.search_requested.emit(query) + + def _show_history_menu(self) -> None: + if not self._db: + return + + menu = QMenu(self) + + # Saved searches + saved = self._db.get_saved_searches() + if saved: + saved_header = menu.addAction("-- Saved Searches --") + saved_header.setEnabled(False) + saved_actions = {} + for sid, name, query in saved: + a = menu.addAction(f" {name} ({query})") + saved_actions[id(a)] = (sid, query) + menu.addSeparator() + + # History + history = self._db.get_search_history() + if history: + hist_header = menu.addAction("-- Recent --") + hist_header.setEnabled(False) + hist_actions = {} + for query in history: + a = menu.addAction(f" {query}") + hist_actions[id(a)] = query + menu.addSeparator() + clear_action = menu.addAction("Clear History") + else: + hist_actions = {} + clear_action = None + + if not saved and not history: + empty = menu.addAction("No history yet") + empty.setEnabled(False) + + action = menu.exec(self._history_btn.mapToGlobal(self._history_btn.rect().bottomLeft())) + if not action: + return + + if clear_action and action == clear_action: + self._db.clear_search_history() + elif id(action) in hist_actions: + self._input.setText(hist_actions[id(action)]) + self._do_search() + elif saved and id(action) in saved_actions: + _, query = saved_actions[id(action)] + self._input.setText(query) + self._do_search() + + def _save_current_search(self) -> None: + if not self._db: + return + query = self._input.text().strip() + if not query: + return + name, ok = QInputDialog.getText(self, "Save Search", "Name:", text=query) + if ok and name.strip(): + self._db.add_saved_search(name.strip(), query) + + def text(self) -> str: + return self._input.text().strip() + + def set_text(self, text: str) -> None: + self._input.setText(text) + + def focus(self) -> None: + self._input.setFocus() diff --git a/booru_viewer/gui/settings.py b/booru_viewer/gui/settings.py new file mode 100644 index 0000000..6f0b725 --- /dev/null +++ b/booru_viewer/gui/settings.py @@ -0,0 +1,620 @@ +"""Settings dialog.""" + +from __future__ import annotations + +from pathlib import Path + +from PySide6.QtCore import Qt, Signal +from PySide6.QtWidgets import ( + QDialog, + QVBoxLayout, + QHBoxLayout, + QFormLayout, + QTabWidget, + QWidget, + QLabel, + QPushButton, + QSpinBox, + QComboBox, + QCheckBox, + QLineEdit, + QListWidget, + QMessageBox, + QGroupBox, + QProgressBar, +) + +from ..core.db import Database +from ..core.cache import cache_size_bytes, cache_file_count, clear_cache, evict_oldest +from ..core.config import ( + data_dir, cache_dir, thumbnails_dir, db_path, IS_WINDOWS, +) + + +class SettingsDialog(QDialog): + """Full settings panel with tabs.""" + + settings_changed = Signal() + favorites_imported = Signal() + + def __init__(self, db: Database, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._db = db + self.setWindowTitle("Settings") + self.setMinimumSize(550, 450) + + layout = QVBoxLayout(self) + + self._tabs = QTabWidget() + layout.addWidget(self._tabs) + + self._tabs.addTab(self._build_general_tab(), "General") + self._tabs.addTab(self._build_cache_tab(), "Cache") + self._tabs.addTab(self._build_blacklist_tab(), "Blacklist") + self._tabs.addTab(self._build_paths_tab(), "Paths") + self._tabs.addTab(self._build_theme_tab(), "Theme") + + # Bottom buttons + btns = QHBoxLayout() + btns.addStretch() + + save_btn = QPushButton("Save") + save_btn.clicked.connect(self._save_and_close) + btns.addWidget(save_btn) + + cancel_btn = QPushButton("Cancel") + cancel_btn.clicked.connect(self.reject) + btns.addWidget(cancel_btn) + + layout.addLayout(btns) + + # -- General tab -- + + def _build_general_tab(self) -> QWidget: + w = QWidget() + layout = QVBoxLayout(w) + + form = QFormLayout() + + # Page size + self._page_size = QSpinBox() + self._page_size.setRange(10, 100) + self._page_size.setValue(self._db.get_setting_int("page_size")) + form.addRow("Results per page:", self._page_size) + + # Thumbnail size + self._thumb_size = QSpinBox() + self._thumb_size.setRange(100, 400) + self._thumb_size.setSingleStep(20) + self._thumb_size.setValue(self._db.get_setting_int("thumbnail_size")) + form.addRow("Thumbnail size (px):", self._thumb_size) + + # Default rating + self._default_rating = QComboBox() + self._default_rating.addItems(["all", "general", "sensitive", "questionable", "explicit"]) + current_rating = self._db.get_setting("default_rating") + idx = self._default_rating.findText(current_rating) + if idx >= 0: + self._default_rating.setCurrentIndex(idx) + form.addRow("Default rating filter:", self._default_rating) + + # Default min score + self._default_score = QSpinBox() + self._default_score.setRange(0, 99999) + self._default_score.setValue(self._db.get_setting_int("default_score")) + form.addRow("Default minimum score:", self._default_score) + + # Preload thumbnails + self._preload = QCheckBox("Load thumbnails automatically") + self._preload.setChecked(self._db.get_setting_bool("preload_thumbnails")) + form.addRow("", self._preload) + + # File dialog platform (Linux only) + self._file_dialog_combo = None + if not IS_WINDOWS: + self._file_dialog_combo = QComboBox() + self._file_dialog_combo.addItems(["qt", "gtk"]) + current = self._db.get_setting("file_dialog_platform") + idx = self._file_dialog_combo.findText(current) + if idx >= 0: + self._file_dialog_combo.setCurrentIndex(idx) + form.addRow("File dialog (restart required):", self._file_dialog_combo) + + layout.addLayout(form) + layout.addStretch() + return w + + # -- Cache tab -- + + def _build_cache_tab(self) -> QWidget: + w = QWidget() + layout = QVBoxLayout(w) + + # Cache stats + stats_group = QGroupBox("Cache Statistics") + stats_layout = QFormLayout(stats_group) + + images, thumbs = cache_file_count() + total_bytes = cache_size_bytes() + total_mb = total_bytes / (1024 * 1024) + + self._cache_images_label = QLabel(f"{images}") + stats_layout.addRow("Cached images:", self._cache_images_label) + + self._cache_thumbs_label = QLabel(f"{thumbs}") + stats_layout.addRow("Cached thumbnails:", self._cache_thumbs_label) + + self._cache_size_label = QLabel(f"{total_mb:.1f} MB") + stats_layout.addRow("Total size:", self._cache_size_label) + + self._fav_count_label = QLabel(f"{self._db.favorite_count()}") + stats_layout.addRow("Favorites:", self._fav_count_label) + + layout.addWidget(stats_group) + + # Cache limits + limits_group = QGroupBox("Cache Limits") + limits_layout = QFormLayout(limits_group) + + self._max_cache = QSpinBox() + self._max_cache.setRange(100, 50000) + self._max_cache.setSuffix(" MB") + self._max_cache.setValue(self._db.get_setting_int("max_cache_mb")) + limits_layout.addRow("Max cache size:", self._max_cache) + + self._auto_evict = QCheckBox("Auto-evict oldest when limit reached") + self._auto_evict.setChecked(self._db.get_setting_bool("auto_evict")) + limits_layout.addRow("", self._auto_evict) + + layout.addWidget(limits_group) + + # Cache actions + actions_group = QGroupBox("Actions") + actions_layout = QVBoxLayout(actions_group) + + btn_row1 = QHBoxLayout() + + clear_thumbs_btn = QPushButton("Clear Thumbnails") + clear_thumbs_btn.clicked.connect(self._clear_thumbnails) + btn_row1.addWidget(clear_thumbs_btn) + + clear_cache_btn = QPushButton("Clear Image Cache") + clear_cache_btn.clicked.connect(self._clear_image_cache) + btn_row1.addWidget(clear_cache_btn) + + actions_layout.addLayout(btn_row1) + + btn_row2 = QHBoxLayout() + + clear_all_btn = QPushButton("Clear Everything") + clear_all_btn.setStyleSheet(f"QPushButton {{ color: #ff4444; }}") + clear_all_btn.clicked.connect(self._clear_all) + btn_row2.addWidget(clear_all_btn) + + evict_btn = QPushButton("Evict to Limit Now") + evict_btn.clicked.connect(self._evict_now) + btn_row2.addWidget(evict_btn) + + actions_layout.addLayout(btn_row2) + + layout.addWidget(actions_group) + layout.addStretch() + return w + + # -- Blacklist tab -- + + def _build_blacklist_tab(self) -> QWidget: + w = QWidget() + layout = QVBoxLayout(w) + + layout.addWidget(QLabel("Posts with these tags will be hidden from results:")) + + self._bl_list = QListWidget() + self._refresh_blacklist() + layout.addWidget(self._bl_list) + + add_row = QHBoxLayout() + self._bl_input = QLineEdit() + self._bl_input.setPlaceholderText("Tag to blacklist...") + self._bl_input.returnPressed.connect(self._bl_add) + add_row.addWidget(self._bl_input, stretch=1) + + add_btn = QPushButton("Add") + add_btn.clicked.connect(self._bl_add) + add_row.addWidget(add_btn) + + remove_btn = QPushButton("Remove") + remove_btn.clicked.connect(self._bl_remove) + add_row.addWidget(remove_btn) + + layout.addLayout(add_row) + + io_row = QHBoxLayout() + + export_bl_btn = QPushButton("Export") + export_bl_btn.clicked.connect(self._bl_export) + io_row.addWidget(export_bl_btn) + + import_bl_btn = QPushButton("Import") + import_bl_btn.clicked.connect(self._bl_import) + io_row.addWidget(import_bl_btn) + + clear_bl_btn = QPushButton("Clear All") + clear_bl_btn.clicked.connect(self._bl_clear) + io_row.addWidget(clear_bl_btn) + + layout.addLayout(io_row) + return w + + # -- Paths tab -- + + def _build_paths_tab(self) -> QWidget: + w = QWidget() + layout = QVBoxLayout(w) + + form = QFormLayout() + + data = QLineEdit(str(data_dir())) + data.setReadOnly(True) + form.addRow("Data directory:", data) + + cache = QLineEdit(str(cache_dir())) + cache.setReadOnly(True) + form.addRow("Image cache:", cache) + + thumbs = QLineEdit(str(thumbnails_dir())) + thumbs.setReadOnly(True) + form.addRow("Thumbnails:", thumbs) + + db = QLineEdit(str(db_path())) + db.setReadOnly(True) + form.addRow("Database:", db) + + layout.addLayout(form) + + open_btn = QPushButton("Open Data Folder") + open_btn.clicked.connect(self._open_data_folder) + layout.addWidget(open_btn) + + layout.addStretch() + + # Export / Import + exp_group = QGroupBox("Backup") + exp_layout = QHBoxLayout(exp_group) + + export_btn = QPushButton("Export Favorites") + export_btn.clicked.connect(self._export_favorites) + exp_layout.addWidget(export_btn) + + import_btn = QPushButton("Import Favorites") + import_btn.clicked.connect(self._import_favorites) + exp_layout.addWidget(import_btn) + + layout.addWidget(exp_group) + + return w + + # -- Theme tab -- + + def _build_theme_tab(self) -> QWidget: + w = QWidget() + layout = QVBoxLayout(w) + + layout.addWidget(QLabel( + "Customize the app's appearance with a Qt stylesheet (QSS).\n" + "Place a custom.qss file in your data directory.\n" + "Restart the app after editing." + )) + + css_path = data_dir() / "custom.qss" + path_label = QLineEdit(str(css_path)) + path_label.setReadOnly(True) + layout.addWidget(path_label) + + btn_row = QHBoxLayout() + + edit_btn = QPushButton("Edit custom.qss") + edit_btn.clicked.connect(self._edit_custom_css) + btn_row.addWidget(edit_btn) + + create_btn = QPushButton("Create from Template") + create_btn.clicked.connect(self._create_css_template) + btn_row.addWidget(create_btn) + + guide_btn = QPushButton("View Guide") + guide_btn.clicked.connect(self._view_css_guide) + btn_row.addWidget(guide_btn) + + layout.addLayout(btn_row) + + delete_btn = QPushButton("Delete custom.qss (Reset to Default)") + delete_btn.clicked.connect(self._delete_custom_css) + layout.addWidget(delete_btn) + + layout.addStretch() + return w + + def _edit_custom_css(self) -> None: + from PySide6.QtGui import QDesktopServices + from PySide6.QtCore import QUrl + css_path = data_dir() / "custom.qss" + if not css_path.exists(): + css_path.write_text("/* booru-viewer custom stylesheet */\n\n") + QDesktopServices.openUrl(QUrl.fromLocalFile(str(css_path))) + + def _create_css_template(self) -> None: + css_path = data_dir() / "custom.qss" + if css_path.exists(): + reply = QMessageBox.question( + self, "Confirm", "Overwrite existing custom.qss with template?", + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, + ) + if reply != QMessageBox.StandardButton.Yes: + return + template = ( + "/* booru-viewer custom stylesheet */\n" + "/* Edit and restart the app to apply changes */\n\n" + "/* -- Accent color -- */\n" + "/* QWidget { color: #00ff00; } */\n\n" + "/* -- Background -- */\n" + "/* QWidget { background-color: #000000; } */\n\n" + "/* -- Font -- */\n" + "/* QWidget { font-family: monospace; font-size: 13px; } */\n\n" + "/* -- Buttons -- */\n" + "/* QPushButton { padding: 6px 16px; border-radius: 4px; } */\n" + "/* QPushButton:hover { border-color: #00ff00; } */\n\n" + "/* -- Inputs -- */\n" + "/* QLineEdit { padding: 6px 10px; border-radius: 4px; } */\n" + "/* QLineEdit:focus { border-color: #00ff00; } */\n\n" + "/* -- Scrollbar -- */\n" + "/* QScrollBar:vertical { width: 10px; } */\n\n" + "/* -- Video seek bar -- */\n" + "/* QSlider::groove:horizontal { background: #333; height: 6px; } */\n" + "/* QSlider::handle:horizontal { background: #00ff00; width: 14px; } */\n" + ) + css_path.write_text(template) + QMessageBox.information(self, "Done", f"Template created at:\n{css_path}") + + def _view_css_guide(self) -> None: + from PySide6.QtGui import QDesktopServices + from PySide6.QtCore import QUrl + dest = data_dir() / "custom_css_guide.txt" + # Copy guide to appdata if not already there + if not dest.exists(): + import sys + # Try source tree, then PyInstaller bundle + for candidate in [ + Path(__file__).parent / "custom_css_guide.txt", + Path(getattr(sys, '_MEIPASS', __file__)) / "booru_viewer" / "gui" / "custom_css_guide.txt", + ]: + if candidate.is_file(): + dest.write_text(candidate.read_text()) + break + if dest.exists(): + QDesktopServices.openUrl(QUrl.fromLocalFile(str(dest))) + else: + # Fallback: show in dialog + from PySide6.QtWidgets import QTextEdit, QDialog, QVBoxLayout + dlg = QDialog(self) + dlg.setWindowTitle("Custom CSS Guide") + dlg.resize(600, 500) + layout = QVBoxLayout(dlg) + text = QTextEdit() + text.setReadOnly(True) + text.setPlainText( + "booru-viewer Custom Stylesheet Guide\n" + "=====================================\n\n" + "Place a file named 'custom.qss' in your data directory.\n" + f"Path: {data_dir() / 'custom.qss'}\n\n" + "WIDGET REFERENCE\n" + "----------------\n" + "QMainWindow, QPushButton, QLineEdit, QComboBox, QScrollBar,\n" + "QLabel, QStatusBar, QTabWidget, QTabBar, QListWidget,\n" + "QMenu, QMenuBar, QToolTip, QDialog, QSplitter, QProgressBar,\n" + "QSpinBox, QCheckBox, QSlider\n\n" + "STATES: :hover, :pressed, :focus, :selected, :disabled\n\n" + "PROPERTIES: color, background-color, border, border-radius,\n" + "padding, margin, font-family, font-size\n\n" + "EXAMPLE\n" + "-------\n" + "QPushButton {\n" + " background: #333; color: white;\n" + " border: 1px solid #555; border-radius: 4px;\n" + " padding: 6px 16px;\n" + "}\n" + "QPushButton:hover { background: #555; }\n\n" + "Restart the app after editing custom.qss." + ) + layout.addWidget(text) + dlg.exec() + + def _delete_custom_css(self) -> None: + css_path = data_dir() / "custom.qss" + if css_path.exists(): + css_path.unlink() + QMessageBox.information(self, "Done", "Deleted. Restart to use default theme.") + else: + QMessageBox.information(self, "Info", "No custom.qss found.") + + # -- Actions -- + + def _refresh_stats(self) -> None: + images, thumbs = cache_file_count() + total_bytes = cache_size_bytes() + total_mb = total_bytes / (1024 * 1024) + self._cache_images_label.setText(f"{images}") + self._cache_thumbs_label.setText(f"{thumbs}") + self._cache_size_label.setText(f"{total_mb:.1f} MB") + + def _clear_thumbnails(self) -> None: + count = clear_cache(clear_images=False, clear_thumbnails=True) + QMessageBox.information(self, "Done", f"Deleted {count} thumbnails.") + self._refresh_stats() + + def _clear_image_cache(self) -> None: + reply = QMessageBox.question( + self, "Confirm", + "Delete all cached images? (Favorites stay in the database but cached files are removed.)", + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, + ) + if reply == QMessageBox.StandardButton.Yes: + count = clear_cache(clear_images=True, clear_thumbnails=False) + QMessageBox.information(self, "Done", f"Deleted {count} cached images.") + self._refresh_stats() + + def _clear_all(self) -> None: + reply = QMessageBox.question( + self, "Confirm", + "Delete ALL cached images and thumbnails?", + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, + ) + if reply == QMessageBox.StandardButton.Yes: + count = clear_cache(clear_images=True, clear_thumbnails=True) + QMessageBox.information(self, "Done", f"Deleted {count} files.") + self._refresh_stats() + + def _evict_now(self) -> None: + max_bytes = self._max_cache.value() * 1024 * 1024 + # Protect favorited file paths + protected = set() + for fav in self._db.get_favorites(limit=999999): + if fav.cached_path: + protected.add(fav.cached_path) + count = evict_oldest(max_bytes, protected) + QMessageBox.information(self, "Done", f"Evicted {count} files.") + self._refresh_stats() + + def _refresh_blacklist(self) -> None: + self._bl_list.clear() + for tag in self._db.get_blacklisted_tags(): + self._bl_list.addItem(tag) + + def _bl_add(self) -> None: + tag = self._bl_input.text().strip() + if tag: + self._db.add_blacklisted_tag(tag) + self._bl_input.clear() + self._refresh_blacklist() + + def _bl_remove(self) -> None: + item = self._bl_list.currentItem() + if item: + self._db.remove_blacklisted_tag(item.text()) + self._refresh_blacklist() + + def _bl_export(self) -> None: + from .dialogs import save_file + path = save_file(self, "Export Blacklist", "blacklist.txt", "Text (*.txt)") + if not path: + return + tags = self._db.get_blacklisted_tags() + with open(path, "w") as f: + f.write("\n".join(tags)) + QMessageBox.information(self, "Done", f"Exported {len(tags)} tags.") + + def _bl_import(self) -> None: + from .dialogs import open_file + path = open_file(self, "Import Blacklist", "Text (*.txt)") + if not path: + return + try: + with open(path) as f: + tags = [line.strip() for line in f if line.strip()] + count = 0 + for tag in tags: + self._db.add_blacklisted_tag(tag) + count += 1 + self._refresh_blacklist() + QMessageBox.information(self, "Done", f"Imported {count} tags.") + except Exception as e: + QMessageBox.warning(self, "Error", str(e)) + + def _bl_clear(self) -> None: + reply = QMessageBox.question( + self, "Confirm", "Remove all blacklisted tags?", + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, + ) + if reply == QMessageBox.StandardButton.Yes: + for tag in self._db.get_blacklisted_tags(): + self._db.remove_blacklisted_tag(tag) + self._refresh_blacklist() + + def _open_data_folder(self) -> None: + from PySide6.QtGui import QDesktopServices + from PySide6.QtCore import QUrl + QDesktopServices.openUrl(QUrl.fromLocalFile(str(data_dir()))) + + def _export_favorites(self) -> None: + from .dialogs import save_file + import json + path = save_file(self, "Export Favorites", "favorites.json", "JSON (*.json)") + if not path: + return + favs = self._db.get_favorites(limit=999999) + data = [ + { + "post_id": f.post_id, + "site_id": f.site_id, + "file_url": f.file_url, + "preview_url": f.preview_url, + "tags": f.tags, + "rating": f.rating, + "score": f.score, + "source": f.source, + "folder": f.folder, + "favorited_at": f.favorited_at, + } + for f in favs + ] + with open(path, "w") as fp: + json.dump(data, fp, indent=2) + QMessageBox.information(self, "Done", f"Exported {len(data)} favorites.") + + def _import_favorites(self) -> None: + from .dialogs import open_file + import json + path = open_file(self, "Import Favorites", "JSON (*.json)") + if not path: + return + try: + with open(path) as fp: + data = json.load(fp) + count = 0 + for item in data: + try: + folder = item.get("folder") + self._db.add_favorite( + site_id=item["site_id"], + post_id=item["post_id"], + file_url=item["file_url"], + preview_url=item.get("preview_url"), + tags=item.get("tags", ""), + rating=item.get("rating"), + score=item.get("score"), + source=item.get("source"), + folder=folder, + ) + if folder: + self._db.add_folder(folder) + count += 1 + except Exception: + pass + QMessageBox.information(self, "Done", f"Imported {count} favorites.") + self.favorites_imported.emit() + except Exception as e: + QMessageBox.warning(self, "Error", str(e)) + + # -- Save -- + + def _save_and_close(self) -> None: + self._db.set_setting("page_size", str(self._page_size.value())) + self._db.set_setting("thumbnail_size", str(self._thumb_size.value())) + self._db.set_setting("default_rating", self._default_rating.currentText()) + self._db.set_setting("default_score", str(self._default_score.value())) + self._db.set_setting("preload_thumbnails", "1" if self._preload.isChecked() else "0") + self._db.set_setting("max_cache_mb", str(self._max_cache.value())) + self._db.set_setting("auto_evict", "1" if self._auto_evict.isChecked() else "0") + if self._file_dialog_combo is not None: + self._db.set_setting("file_dialog_platform", self._file_dialog_combo.currentText()) + self.settings_changed.emit() + self.accept() diff --git a/booru_viewer/gui/sites.py b/booru_viewer/gui/sites.py new file mode 100644 index 0000000..24d6035 --- /dev/null +++ b/booru_viewer/gui/sites.py @@ -0,0 +1,297 @@ +"""Site manager dialog.""" + +from __future__ import annotations + +import asyncio +import threading + +from PySide6.QtCore import Qt, Signal, QMetaObject, Q_ARG, Qt as QtNS +from PySide6.QtWidgets import ( + QDialog, + QVBoxLayout, + QHBoxLayout, + QFormLayout, + QLineEdit, + QPushButton, + QListWidget, + QListWidgetItem, + QLabel, + QMessageBox, + QWidget, +) + +from ..core.db import Database, Site +from ..core.api.detect import detect_site_type + + +class SiteDialog(QDialog): + """Dialog to add or edit a booru site.""" + + def __init__(self, parent: QWidget | None = None, site: Site | None = None) -> None: + super().__init__(parent) + self._editing = site is not None + self.setWindowTitle("Edit Site" if self._editing else "Add Site") + self.setMinimumWidth(400) + + layout = QVBoxLayout(self) + + form = QFormLayout() + self._name_input = QLineEdit() + self._name_input.setPlaceholderText("e.g. Danbooru") + form.addRow("Name:", self._name_input) + + self._url_input = QLineEdit() + self._url_input.setPlaceholderText("e.g. https://gelbooru.com or paste a full post URL") + self._url_input.textChanged.connect(self._try_parse_url) + form.addRow("URL:", self._url_input) + + self._key_input = QLineEdit() + self._key_input.setPlaceholderText("(optional — or paste full &api_key=...&user_id=... string)") + self._key_input.textChanged.connect(self._try_parse_credentials) + form.addRow("API Key:", self._key_input) + + self._user_input = QLineEdit() + self._user_input.setPlaceholderText("(optional)") + form.addRow("API User:", self._user_input) + + layout.addLayout(form) + + self._status_label = QLabel("") + layout.addWidget(self._status_label) + + btns = QHBoxLayout() + self._detect_btn = QPushButton("Auto-Detect") + self._detect_btn.clicked.connect(self._on_detect) + btns.addWidget(self._detect_btn) + + self._test_btn = QPushButton("Test") + self._test_btn.clicked.connect(self._on_test) + btns.addWidget(self._test_btn) + + btns.addStretch() + + save_btn = QPushButton("Save" if self._editing else "Add") + save_btn.clicked.connect(self.accept) + btns.addWidget(save_btn) + + cancel_btn = QPushButton("Cancel") + cancel_btn.clicked.connect(self.reject) + btns.addWidget(cancel_btn) + + layout.addLayout(btns) + + self._detected_type: str | None = None + + # Populate fields if editing + if site: + self._name_input.setText(site.name) + self._url_input.setText(site.url) + self._key_input.setText(site.api_key or "") + self._user_input.setText(site.api_user or "") + self._detected_type = site.api_type + self._status_label.setText(f"Type: {site.api_type}") + + def _on_detect(self) -> None: + url = self._url_input.text().strip() + if not url: + self._status_label.setText("Enter a URL first.") + return + self._status_label.setText("Detecting...") + self._detect_btn.setEnabled(False) + + api_key = self._key_input.text().strip() or None + api_user = self._user_input.text().strip() or None + + def _run(): + try: + result = asyncio.run(detect_site_type(url, api_key=api_key, api_user=api_user)) + self._detect_finished(result, None) + except Exception as e: + self._detect_finished(None, e) + + threading.Thread(target=_run, daemon=True).start() + + def _detect_finished(self, result: str | None, error: Exception | None) -> None: + self._detect_btn.setEnabled(True) + if error: + self._status_label.setText(f"Error: {error}") + elif result: + self._detected_type = result + self._status_label.setText(f"Detected: {result}") + else: + self._status_label.setText("Could not detect API type.") + + def _on_test(self) -> None: + url = self._url_input.text().strip() + api_type = self._detected_type or "danbooru" + api_key = self._key_input.text().strip() or None + api_user = self._user_input.text().strip() or None + if not url: + self._status_label.setText("Enter a URL first.") + return + self._status_label.setText("Testing connection...") + self._test_btn.setEnabled(False) + + def _run(): + import asyncio + from ..core.api.detect import client_for_type + try: + client = client_for_type(api_type, url, api_key=api_key, api_user=api_user) + ok, detail = asyncio.run(client.test_connection()) + self._test_finished(ok, detail) + except Exception as e: + self._test_finished(False, str(e)) + + threading.Thread(target=_run, daemon=True).start() + + def _test_finished(self, ok: bool, detail: str) -> None: + self._test_btn.setEnabled(True) + if ok: + self._status_label.setText(f"Connected! {detail}") + else: + self._status_label.setText(f"Failed: {detail}") + + def _try_parse_url(self, text: str) -> None: + """Strip query params from pasted URLs like https://gelbooru.com/index.php?page=post&s=list&tags=all.""" + from urllib.parse import urlparse, parse_qs + text = text.strip() + if "?" not in text: + return + try: + parsed = urlparse(text) + base = f"{parsed.scheme}://{parsed.netloc}" + if not parsed.scheme or not parsed.netloc: + return + self._url_input.blockSignals(True) + self._url_input.setText(base) + self._url_input.blockSignals(False) + self._status_label.setText(f"Extracted base URL: {base}") + except Exception: + pass + + def _try_parse_credentials(self, text: str) -> None: + """Auto-parse combined credential strings like &api_key=XXX&user_id=123.""" + import re + # Match user_id regardless of api_key being present + user_match = re.search(r'user_id=([^&\s]+)', text) + key_match = re.search(r'api_key=([^&\s]+)', text) + if user_match: + self._user_input.setText(user_match.group(1)) + if key_match: + self._key_input.blockSignals(True) + self._key_input.setText(key_match.group(1)) + self._key_input.blockSignals(False) + self._status_label.setText("Parsed api_key and user_id") + else: + # Clear the pasted junk, user needs to enter key separately + self._key_input.blockSignals(True) + self._key_input.clear() + self._key_input.blockSignals(False) + self._status_label.setText("Parsed user_id={}. Paste your API key above.".format(user_match.group(1))) + + @property + def site_data(self) -> dict: + return { + "name": self._name_input.text().strip(), + "url": self._url_input.text().strip(), + "api_type": self._detected_type or "danbooru", + "api_key": self._key_input.text().strip() or None, + "api_user": self._user_input.text().strip() or None, + } + + +class SiteManagerDialog(QDialog): + """Dialog to manage booru sites.""" + + sites_changed = Signal() + + def __init__(self, db: Database, parent: QWidget | None = None) -> None: + super().__init__(parent) + self._db = db + self.setWindowTitle("Manage Sites") + self.setMinimumSize(500, 350) + + layout = QVBoxLayout(self) + + self._list = QListWidget() + layout.addWidget(self._list) + + btns = QHBoxLayout() + add_btn = QPushButton("Add Site") + add_btn.clicked.connect(self._on_add) + btns.addWidget(add_btn) + + edit_btn = QPushButton("Edit") + edit_btn.clicked.connect(self._on_edit) + btns.addWidget(edit_btn) + + remove_btn = QPushButton("Remove") + remove_btn.clicked.connect(self._on_remove) + btns.addWidget(remove_btn) + + btns.addStretch() + + close_btn = QPushButton("Close") + close_btn.clicked.connect(self.accept) + btns.addWidget(close_btn) + + layout.addLayout(btns) + self._list.itemDoubleClicked.connect(lambda _: self._on_edit()) + self._refresh_list() + + def _refresh_list(self) -> None: + self._list.clear() + for site in self._db.get_sites(enabled_only=False): + item = QListWidgetItem(f"{site.name} [{site.api_type}] {site.url}") + item.setData(Qt.ItemDataRole.UserRole, site.id) + self._list.addItem(item) + + def _on_add(self) -> None: + dlg = SiteDialog(self) + if dlg.exec() == QDialog.DialogCode.Accepted: + data = dlg.site_data + if not data["name"] or not data["url"]: + QMessageBox.warning(self, "Error", "Name and URL are required.") + return + try: + self._db.add_site(**data) + self._refresh_list() + self.sites_changed.emit() + except Exception as e: + QMessageBox.warning(self, "Error", str(e)) + + def _on_edit(self) -> None: + item = self._list.currentItem() + if not item: + return + site_id = item.data(Qt.ItemDataRole.UserRole) + sites = self._db.get_sites(enabled_only=False) + site = next((s for s in sites if s.id == site_id), None) + if not site: + return + dlg = SiteDialog(self, site=site) + if dlg.exec() == QDialog.DialogCode.Accepted: + data = dlg.site_data + if not data["name"] or not data["url"]: + QMessageBox.warning(self, "Error", "Name and URL are required.") + return + try: + self._db.update_site(site_id, **data) + self._refresh_list() + self.sites_changed.emit() + except Exception as e: + QMessageBox.warning(self, "Error", str(e)) + + def _on_remove(self) -> None: + item = self._list.currentItem() + if not item: + return + site_id = item.data(Qt.ItemDataRole.UserRole) + reply = QMessageBox.question( + self, "Confirm", "Remove this site and all its favorites?", + QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, + ) + if reply == QMessageBox.StandardButton.Yes: + self._db.delete_site(site_id) + self._refresh_list() + self.sites_changed.emit() diff --git a/booru_viewer/gui/theme.py b/booru_viewer/gui/theme.py new file mode 100644 index 0000000..f288f3a --- /dev/null +++ b/booru_viewer/gui/theme.py @@ -0,0 +1,222 @@ +"""Green-on-black Qt6 stylesheet.""" + +from ..core.config import GREEN, DARK_GREEN, DIM_GREEN, BG, BG_LIGHT, BG_LIGHTER, BORDER + +STYLESHEET = f""" +QMainWindow, QDialog {{ + background-color: {BG}; + color: {GREEN}; +}} + +QWidget {{ + background-color: {BG}; + color: {GREEN}; + font-family: "Terminess Nerd Font Propo", "Hack Nerd Font", monospace; + font-size: 13px; +}} + +QMenuBar {{ + background-color: {BG}; + color: {GREEN}; + border-bottom: 1px solid {BORDER}; +}} + +QMenuBar::item:selected {{ + background-color: {BG_LIGHTER}; +}} + +QMenu {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; +}} + +QMenu::item:selected {{ + background-color: {BG_LIGHTER}; +}} + +QLineEdit {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + border-radius: 4px; + padding: 6px 10px; + selection-background-color: {DIM_GREEN}; + selection-color: {BG}; +}} + +QLineEdit:focus {{ + border-color: {GREEN}; +}} + +QPushButton {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + border-radius: 4px; + padding: 6px 16px; + min-height: 28px; +}} + +QPushButton:hover {{ + background-color: {BG_LIGHTER}; + border-color: {DIM_GREEN}; +}} + +QPushButton:pressed {{ + background-color: {DIM_GREEN}; + color: {BG}; +}} + +QComboBox {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + border-radius: 4px; + padding: 4px 8px; +}} + +QComboBox:hover {{ + border-color: {DIM_GREEN}; +}} + +QComboBox QAbstractItemView {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + selection-background-color: {DIM_GREEN}; + selection-color: {BG}; +}} + +QComboBox::drop-down {{ + border: none; + width: 20px; +}} + +QScrollBar:vertical {{ + background: {BG}; + width: 10px; + margin: 0; +}} + +QScrollBar::handle:vertical {{ + background: {BORDER}; + min-height: 30px; + border-radius: 5px; +}} + +QScrollBar::handle:vertical:hover {{ + background: {DIM_GREEN}; +}} + +QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{ + height: 0; +}} + +QScrollBar:horizontal {{ + background: {BG}; + height: 10px; + margin: 0; +}} + +QScrollBar::handle:horizontal {{ + background: {BORDER}; + min-width: 30px; + border-radius: 5px; +}} + +QScrollBar::handle:horizontal:hover {{ + background: {DIM_GREEN}; +}} + +QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {{ + width: 0; +}} + +QLabel {{ + color: {GREEN}; +}} + +QStatusBar {{ + background-color: {BG}; + color: {DIM_GREEN}; + border-top: 1px solid {BORDER}; +}} + +QTabWidget::pane {{ + border: 1px solid {BORDER}; + background-color: {BG}; +}} + +QTabBar::tab {{ + background-color: {BG_LIGHT}; + color: {DIM_GREEN}; + border: 1px solid {BORDER}; + border-bottom: none; + padding: 6px 16px; + margin-right: 2px; +}} + +QTabBar::tab:selected {{ + color: {GREEN}; + border-color: {GREEN}; + background-color: {BG}; +}} + +QTabBar::tab:hover {{ + color: {GREEN}; + background-color: {BG_LIGHTER}; +}} + +QListWidget {{ + background-color: {BG}; + color: {GREEN}; + border: 1px solid {BORDER}; + outline: none; +}} + +QListWidget::item:selected {{ + background-color: {DIM_GREEN}; + color: {BG}; +}} + +QListWidget::item:hover {{ + background-color: {BG_LIGHTER}; +}} + +QDialogButtonBox QPushButton {{ + min-width: 80px; +}} + +QToolTip {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + padding: 4px; +}} + +QCompleter QAbstractItemView {{ + background-color: {BG_LIGHT}; + color: {GREEN}; + border: 1px solid {BORDER}; + selection-background-color: {DIM_GREEN}; + selection-color: {BG}; +}} + +QSplitter::handle {{ + background-color: {BORDER}; +}} + +QProgressBar {{ + background-color: {BG_LIGHT}; + border: 1px solid {BORDER}; + border-radius: 4px; + text-align: center; + color: {GREEN}; +}} + +QProgressBar::chunk {{ + background-color: {DIM_GREEN}; + border-radius: 3px; +}} +""" diff --git a/booru_viewer/main_gui.py b/booru_viewer/main_gui.py new file mode 100644 index 0000000..f8af79f --- /dev/null +++ b/booru_viewer/main_gui.py @@ -0,0 +1,36 @@ +"""GUI entry point.""" + +import os +import sys + + +def main() -> None: + # Windows: set App User Model ID so taskbar pinning works + if sys.platform == "win32": + try: + import ctypes + ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID( + u"pax.booru-viewer.gui.1" + ) + except Exception: + pass + + # Apply file dialog platform setting before Qt initializes + if sys.platform != "win32": + try: + from booru_viewer.core.db import Database + db = Database() + platform = db.get_setting("file_dialog_platform") + db.close() + if platform == "gtk": + # Use xdg-desktop-portal which routes to GTK portal (Thunar) + os.environ.setdefault("QT_QPA_PLATFORMTHEME", "xdgdesktopportal") + except Exception: + pass + + from booru_viewer.gui.app import run + run() + + +if __name__ == "__main__": + main() diff --git a/booru_viewer/main_tui.py b/booru_viewer/main_tui.py new file mode 100644 index 0000000..4b16e9e --- /dev/null +++ b/booru_viewer/main_tui.py @@ -0,0 +1,10 @@ +"""TUI entry point.""" + + +def main() -> None: + from .tui.app import run + run() + + +if __name__ == "__main__": + main() diff --git a/booru_viewer/tui/__init__.py b/booru_viewer/tui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/booru_viewer/tui/app.py b/booru_viewer/tui/app.py new file mode 100644 index 0000000..7ebafd3 --- /dev/null +++ b/booru_viewer/tui/app.py @@ -0,0 +1,511 @@ +"""Main Textual TUI application.""" + +from __future__ import annotations + +from textual.app import App, ComposeResult +from textual.binding import Binding +from textual.containers import Horizontal, Vertical, ScrollableContainer +from textual.css.query import NoMatches +from textual.message import Message +from textual.widgets import Header, Footer, Static, Input, Label, Button, ListView, ListItem + +from ..core.db import Database +from ..core.api.base import Post +from ..core.api.detect import client_for_type +from ..core.cache import download_image +from ..core.config import GREEN, DIM_GREEN, BG, BG_LIGHT, BG_LIGHTER, BORDER + + +class PostList(ListView): + """Scrollable list of posts with selection.""" + + def __init__(self, **kwargs) -> None: + super().__init__(**kwargs) + self._post_count = 0 + + async def set_posts(self, posts: list[Post], db: Database | None = None, site_id: int | None = None) -> None: + self._post_count = len(posts) + await self.clear() + for i, post in enumerate(posts): + fav = "" + if db and site_id and db.is_favorited(site_id, post.id): + fav = " [*]" + rating = (post.rating or "?")[0].upper() + label = f"#{post.id}{fav} {rating} s:{post.score:>4} {post.width}x{post.height}" + item = ListItem(Label(label), id=f"post-{i}") + await self.append(item) + + @staticmethod + def _get_index(item: ListItem) -> int: + if item and item.id and item.id.startswith("post-"): + return int(item.id.split("-")[1]) + return -1 + + @property + def selected_index(self) -> int: + if self.highlighted_child and self.highlighted_child.id: + return self._get_index(self.highlighted_child) + return -1 + + +class InfoBar(Static): + """Bottom info line showing selected post details.""" + pass + + +class BooruTUI(App): + """Booru viewer TUI application.""" + + TITLE = "booru-viewer" + CSS = f""" + Screen {{ + background: {BG}; + color: {GREEN}; + }} + + Header {{ + background: {BG}; + color: {GREEN}; + }} + + Footer {{ + background: {BG}; + color: {DIM_GREEN}; + }} + + #top-bar {{ + height: 3; + layout: horizontal; + padding: 0 1; + }} + + #top-bar Label {{ + width: auto; + padding: 1 1; + color: {DIM_GREEN}; + }} + + #top-bar Input {{ + width: 1fr; + }} + + #top-bar Button {{ + width: auto; + min-width: 8; + margin-left: 1; + }} + + #nav-bar {{ + height: 3; + layout: horizontal; + padding: 0 1; + }} + + #nav-bar Button {{ + width: auto; + min-width: 10; + margin-right: 1; + }} + + #nav-bar .page-info {{ + width: auto; + padding: 1 1; + color: {DIM_GREEN}; + }} + + #main {{ + height: 1fr; + }} + + #post-list {{ + width: 1fr; + min-width: 40; + border-right: solid {BORDER}; + }} + + #right-panel {{ + width: 1fr; + min-width: 30; + }} + + #preview {{ + height: 1fr; + }} + + #info-bar {{ + height: 3; + padding: 0 1; + color: {DIM_GREEN}; + border-top: solid {BORDER}; + }} + + #status {{ + height: 1; + padding: 0 1; + color: {DIM_GREEN}; + }} + + ListView {{ + background: {BG}; + color: {GREEN}; + }} + + ListView > ListItem {{ + background: {BG}; + color: {DIM_GREEN}; + padding: 0 1; + }} + + ListView > ListItem.--highlight {{ + background: {BG_LIGHTER}; + color: {GREEN}; + }} + + ListItem:hover {{ + background: {BG_LIGHTER}; + }} + + Button {{ + background: {BG_LIGHT}; + color: {GREEN}; + border: solid {BORDER}; + }} + + Button:hover {{ + background: {DIM_GREEN}; + color: {BG}; + }} + + Button.-active {{ + background: {DIM_GREEN}; + color: {BG}; + }} + + Input {{ + background: {BG_LIGHT}; + color: {GREEN}; + border: solid {BORDER}; + }} + + Input:focus {{ + border: solid {GREEN}; + }} + """ + + BINDINGS = [ + Binding("q", "quit", "Quit", show=True), + Binding("slash", "focus_search", "/Search", show=True), + Binding("f", "toggle_favorite", "Fav", show=True, priority=True), + Binding("escape", "unfocus", "Back", show=True), + Binding("n", "next_page", "Next", show=True, priority=True), + Binding("p", "prev_page", "Prev", show=True, priority=True), + Binding("o", "open_in_default", "Open", show=True, priority=True), + Binding("i", "show_info", "Info", show=True, priority=True), + Binding("s", "cycle_site", "Site", show=True, priority=True), + ] + + def __init__(self) -> None: + super().__init__() + self._db = Database() + self._posts: list[Post] = [] + self._current_page = 1 + self._current_tags = "" + self._current_site = None + self._show_info = False + + def compose(self) -> ComposeResult: + yield Header() + with Horizontal(id="top-bar"): + yield Label("No site", id="site-label") + yield Input(placeholder="Search tags... (/)", id="search-input") + yield Button("Go", id="search-btn") + with Horizontal(id="nav-bar"): + yield Label("Page 1", classes="page-info", id="page-info") + yield Button("Prev", id="prev-btn") + yield Button("Next", id="next-btn") + with Horizontal(id="main"): + yield PostList(id="post-list") + with Vertical(id="right-panel"): + yield Static("", id="preview") + yield InfoBar("Select a post", id="info-bar") + yield Label("Ready", id="status") + yield Footer() + + def on_mount(self) -> None: + sites = self._db.get_sites() + if sites: + self._current_site = sites[0] + try: + self.query_one("#site-label", Label).update(f"[{self._current_site.name}]") + except NoMatches: + pass + self._set_status(f"Connected to {self._current_site.name}") + + def _set_status(self, msg: str) -> None: + try: + self.query_one("#status", Label).update(msg) + except NoMatches: + pass + + def _make_client(self): + if not self._current_site: + return None + s = self._current_site + return client_for_type(s.api_type, s.url, s.api_key, s.api_user) + + # -- Events -- + + def on_button_pressed(self, event: Button.Pressed) -> None: + bid = event.button.id + if bid == "search-btn": + self._do_search_from_input() + elif bid == "prev-btn": + self.action_prev_page() + elif bid == "next-btn": + self.action_next_page() + + def on_input_submitted(self, event: Input.Submitted) -> None: + if event.input.id == "search-input": + self._do_search_from_input() + + def on_list_view_highlighted(self, event: ListView.Highlighted) -> None: + """Update info when navigating the list.""" + if event.item: + idx = PostList._get_index(event.item) + if idx >= 0: + self._update_info(idx) + + def on_list_view_selected(self, event: ListView.Selected) -> None: + """Enter key on a list item = load preview.""" + if event.item: + idx = PostList._get_index(event.item) + if 0 <= idx < len(self._posts): + self._load_preview(idx) + + # -- Search -- + + def _do_search_from_input(self) -> None: + try: + inp = self.query_one("#search-input", Input) + self._current_tags = inp.value.strip() + except NoMatches: + return + self._current_page = 1 + self._do_search() + + def _do_search(self) -> None: + if not self._current_site: + self._set_status("No site configured") + return + self._set_status("Searching...") + try: + self.query_one("#page-info", Label).update(f"Page {self._current_page}") + except NoMatches: + pass + + tags = self._current_tags + page = self._current_page + blacklisted = self._db.get_blacklisted_tags() + search_tags = tags + for bt in blacklisted: + search_tags += f" -{bt}" + + async def _search(self=self): + client = self._make_client() + if not client: + return + try: + posts = await client.search(tags=search_tags.strip(), page=page) + self._posts = posts + self._set_status(f"{len(posts)} results") + try: + post_list = self.query_one("#post-list", PostList) + await post_list.set_posts(posts, self._db, self._current_site.id if self._current_site else None) + except NoMatches: + pass + except Exception as e: + self._set_status(f"Error: {e}") + finally: + await client.close() + + self.run_worker(_search(), exclusive=True) + + # -- Info -- + + def _update_info(self, index: int) -> None: + if 0 <= index < len(self._posts): + post = self._posts[index] + status = f"#{post.id} {post.width}x{post.height} score:{post.score} [{post.rating}]" + self._set_status(status) + if self._show_info: + tags_preview = " ".join(post.tag_list[:15]) + if len(post.tag_list) > 15: + tags_preview += "..." + info = ( + f"#{post.id} {post.width}x{post.height} score:{post.score} [{post.rating}]\n" + f"Tags: {tags_preview}" + ) + if post.source: + info += f"\nSource: {post.source}" + try: + self.query_one("#info-bar", InfoBar).update(info) + except NoMatches: + pass + + # -- Preview -- + + def _load_preview(self, index: int) -> None: + if index < 0 or index >= len(self._posts): + return + post = self._posts[index] + self._set_status(f"Loading #{post.id}...") + + async def _load(self=self): + try: + path = await download_image(post.file_url) + try: + from .preview import ImagePreview + preview = self.query_one("#preview", Static) + # Show image info in the preview area + info = ( + f" Post #{post.id}\n" + f" Size: {post.width}x{post.height}\n" + f" Score: {post.score}\n" + f" Rating: {post.rating or '?'}\n" + f" Cached: {path}\n" + ) + if post.source: + info += f" Source: {post.source}\n" + info += f"\n Tags: {' '.join(post.tag_list[:20])}" + preview.update(info) + except NoMatches: + pass + self._set_status(f"Loaded #{post.id}") + except Exception as e: + self._set_status(f"Error: {e}") + + self.run_worker(_load()) + + # -- Actions -- + + def action_focus_search(self) -> None: + try: + self.query_one("#search-input", Input).focus() + except NoMatches: + pass + + def action_unfocus(self) -> None: + try: + self.query_one("#post-list", PostList).focus() + except NoMatches: + pass + + def action_next_page(self) -> None: + self._current_page += 1 + self._do_search() + + def action_prev_page(self) -> None: + if self._current_page > 1: + self._current_page -= 1 + self._do_search() + + async def action_toggle_favorite(self) -> None: + post_list = self.query_one("#post-list", PostList) + idx = post_list.selected_index + if idx < 0 or idx >= len(self._posts) or not self._current_site: + return + post = self._posts[idx] + site_id = self._current_site.id + + if self._db.is_favorited(site_id, post.id): + self._db.remove_favorite(site_id, post.id) + self._set_status(f"Unfavorited #{post.id}") + await post_list.set_posts(self._posts, self._db, site_id) + else: + self._set_status(f"Favoriting #{post.id}...") + + async def _fav(self=self): + try: + path = await download_image(post.file_url) + self._db.add_favorite( + site_id=site_id, + post_id=post.id, + file_url=post.file_url, + preview_url=post.preview_url, + tags=post.tags, + rating=post.rating, + score=post.score, + source=post.source, + cached_path=str(path), + ) + self._set_status(f"Favorited #{post.id}") + try: + post_list = self.query_one("#post-list", PostList) + await post_list.set_posts(self._posts, self._db, site_id) + except NoMatches: + pass + except Exception as e: + self._set_status(f"Error: {e}") + + self.run_worker(_fav()) + + def action_open_in_default(self) -> None: + post_list = self.query_one("#post-list", PostList) + idx = post_list.selected_index + if idx < 0 or idx >= len(self._posts): + return + post = self._posts[idx] + from ..core.cache import cached_path_for + path = cached_path_for(post.file_url) + if path.exists(): + import subprocess, sys + if sys.platform == "linux": + subprocess.Popen(["xdg-open", str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + elif sys.platform == "darwin": + subprocess.Popen(["open", str(path)]) + else: + import os + os.startfile(str(path)) + self._set_status(f"Opened #{post.id}") + else: + self._set_status("Not cached — press Enter to download first") + + def action_show_info(self) -> None: + self._show_info = not self._show_info + if self._show_info: + post_list = self.query_one("#post-list", PostList) + self._update_info(post_list.selected_index) + else: + try: + self.query_one("#info-bar", InfoBar).update("Info hidden (press i)") + except NoMatches: + pass + + def action_cycle_site(self) -> None: + sites = self._db.get_sites() + if not sites: + self._set_status("No sites configured") + return + if self._current_site: + ids = [s.id for s in sites] + try: + idx = ids.index(self._current_site.id) + next_site = sites[(idx + 1) % len(sites)] + except ValueError: + next_site = sites[0] + else: + next_site = sites[0] + self._current_site = next_site + try: + self.query_one("#site-label", Label).update(f"[{next_site.name}]") + except NoMatches: + pass + self._set_status(f"Switched to {next_site.name}") + + def on_unmount(self) -> None: + self._db.close() + + +def run() -> None: + app = BooruTUI() + app.run() diff --git a/booru_viewer/tui/favorites.py b/booru_viewer/tui/favorites.py new file mode 100644 index 0000000..5ebb78f --- /dev/null +++ b/booru_viewer/tui/favorites.py @@ -0,0 +1,42 @@ +"""Favorites browser panel for the TUI.""" + +from __future__ import annotations + +from pathlib import Path + +from textual.widgets import Static, Input +from textual.app import ComposeResult + +from ..core.db import Database, Favorite +from ..core.config import GREEN, DIM_GREEN + + +class FavoritesPanel(Static): + """Browse local favorites.""" + + def __init__(self, db: Database, **kwargs) -> None: + super().__init__(**kwargs) + self._db = db + self._favorites: list[Favorite] = [] + + def on_mount(self) -> None: + self.refresh_list() + + def refresh_list(self, search: str | None = None) -> None: + self._favorites = self._db.get_favorites(search=search, limit=100) + total = self._db.favorite_count() + + if not self._favorites: + self.update(" No favorites yet.\n Press 'f' on a post to favorite it.") + return + + lines = [f" Favorites ({len(self._favorites)}/{total}):\n"] + for fav in self._favorites: + cached = "cached" if fav.cached_path and Path(fav.cached_path).exists() else "remote" + tags_preview = " ".join(fav.tags.split()[:5]) + if len(fav.tags.split()) > 5: + tags_preview += "..." + lines.append( + f" #{fav.post_id} [{cached}] {tags_preview}" + ) + self.update("\n".join(lines)) diff --git a/booru_viewer/tui/grid.py b/booru_viewer/tui/grid.py new file mode 100644 index 0000000..691160f --- /dev/null +++ b/booru_viewer/tui/grid.py @@ -0,0 +1,143 @@ +"""Thumbnail grid widget for the Textual TUI.""" + +from __future__ import annotations + +from textual.binding import Binding +from textual.widgets import Static +from textual.reactive import reactive + +from ..core.api.base import Post +from ..core.db import Database +from ..core.config import GREEN, DIM_GREEN, BG + + +class ThumbnailCell(Static): + """A single post cell in the grid.""" + + def __init__(self, index: int, post: Post, favorited: bool = False) -> None: + self._index = index + self._post = post + self._favorited = favorited + self._selected = False + super().__init__() + + def compose_content(self) -> str: + fav = " *" if self._favorited else "" + rating = self._post.rating or "?" + return ( + f"#{self._post.id}{fav}\n" + f"[{rating}] s:{self._post.score}\n" + f"{self._post.width}x{self._post.height}" + ) + + def on_mount(self) -> None: + self.update(self.compose_content()) + self._apply_style() + + def set_selected(self, selected: bool) -> None: + self._selected = selected + self._apply_style() + + def set_favorited(self, favorited: bool) -> None: + self._favorited = favorited + self.update(self.compose_content()) + + def _apply_style(self) -> None: + if self._selected: + self.styles.background = DIM_GREEN + self.styles.color = BG + self.styles.border = ("solid", GREEN) + else: + self.styles.background = BG + self.styles.color = GREEN if self._favorited else DIM_GREEN + self.styles.border = ("solid", DIM_GREEN) + + def on_click(self) -> None: + self.post_message(CellClicked(self._index)) + + +class CellClicked: + """Message sent when a cell is clicked.""" + def __init__(self, index: int) -> None: + self.index = index + + +class ThumbnailGrid(Static): + """Grid of post cells with keyboard navigation.""" + + BINDINGS = [ + Binding("j", "move_down", "Down", show=False), + Binding("k", "move_up", "Up", show=False), + Binding("h", "move_left", "Left", show=False), + Binding("l", "move_right", "Right", show=False), + Binding("down", "move_down", "Down", show=False), + Binding("up", "move_up", "Up", show=False), + Binding("left", "move_left", "Left", show=False), + Binding("right", "move_right", "Right", show=False), + ] + + selected_index: int = reactive(-1, init=False) + + def __init__(self, **kwargs) -> None: + super().__init__(**kwargs) + self._cells: list[ThumbnailCell] = [] + self._posts: list[Post] = [] + self._cols = 4 + self.can_focus = True + + def set_posts( + self, posts: list[Post], db: Database | None = None, site_id: int | None = None + ) -> None: + self._posts = posts + # Remove old cells + for cell in self._cells: + cell.remove() + self._cells.clear() + + lines = [] + for i, post in enumerate(posts): + fav = False + if db and site_id: + fav = db.is_favorited(site_id, post.id) + + fav_marker = " *" if fav else "" + rating = post.rating or "?" + selected = " >> " if i == 0 else " " + lines.append( + f"{selected}#{post.id}{fav_marker} [{rating}] " + f"s:{post.score} {post.width}x{post.height}" + ) + + self.selected_index = 0 if posts else -1 + self.update("\n".join(lines) if lines else "No results. Search for tags above.") + + def update_favorite_status(self, index: int, favorited: bool) -> None: + """Refresh the display for a single post's favorite status.""" + if 0 <= index < len(self._posts): + self.set_posts(self._posts) # Simple refresh + + def _render_list(self) -> None: + lines = [] + for i, post in enumerate(self._posts): + selected = " >> " if i == self.selected_index else " " + lines.append( + f"{selected}#{post.id} [{post.rating or '?'}] " + f"s:{post.score} {post.width}x{post.height}" + ) + self.update("\n".join(lines) if lines else "No results.") + + def action_move_down(self) -> None: + if self._posts and self.selected_index < len(self._posts) - 1: + self.selected_index += 1 + self._render_list() + + def action_move_up(self) -> None: + if self._posts and self.selected_index > 0: + self.selected_index -= 1 + self._render_list() + + def action_move_right(self) -> None: + self.action_move_down() + + def action_move_left(self) -> None: + self.action_move_up() diff --git a/booru_viewer/tui/preview.py b/booru_viewer/tui/preview.py new file mode 100644 index 0000000..0ac5ee2 --- /dev/null +++ b/booru_viewer/tui/preview.py @@ -0,0 +1,92 @@ +"""Image preview widget with Kitty graphics protocol support.""" + +from __future__ import annotations + +import base64 +import os +import sys +from pathlib import Path + +from textual.widgets import Static + +from ..core.config import GREEN, DIM_GREEN, BG + + +def _supports_kitty() -> bool: + """Check if the terminal likely supports the Kitty graphics protocol.""" + term = os.environ.get("TERM", "") + term_program = os.environ.get("TERM_PROGRAM", "") + return "kitty" in term or "kitty" in term_program + + +def _kitty_display(path: str, cols: int = 80, rows: int = 24) -> str: + """Generate Kitty graphics protocol escape sequence for an image.""" + try: + data = Path(path).read_bytes() + b64 = base64.standard_b64encode(data).decode("ascii") + + # Send in chunks (Kitty protocol requires chunked transfer for large images) + chunks = [b64[i:i + 4096] for i in range(0, len(b64), 4096)] + output = "" + for i, chunk in enumerate(chunks): + is_last = i == len(chunks) - 1 + m = 0 if is_last else 1 + if i == 0: + output += f"\033_Ga=T,f=100,m={m},c={cols},r={rows};{chunk}\033\\" + else: + output += f"\033_Gm={m};{chunk}\033\\" + return output + except Exception: + return "" + + +class ImagePreview(Static): + """Image preview panel. Uses Kitty graphics protocol on supported terminals, + otherwise shows image metadata.""" + + def __init__(self, **kwargs) -> None: + super().__init__(**kwargs) + self._path: str | None = None + self._info: str = "" + self._use_kitty = _supports_kitty() + + def show_image(self, path: str, info: str = "") -> None: + self._path = path + self._info = info + + if self._use_kitty and self._path: + # Write Kitty escape directly to terminal, show info in widget + size = self.size + kitty_seq = _kitty_display(path, cols=size.width, rows=size.height - 2) + if kitty_seq: + sys.stdout.write(kitty_seq) + sys.stdout.flush() + self.update(f"\n{info}") + else: + # Fallback: show file info + try: + from PIL import Image + with Image.open(path) as img: + w, h = img.size + fmt = img.format or "unknown" + size_kb = Path(path).stat().st_size / 1024 + text = ( + f" Image: {Path(path).name}\n" + f" Size: {w}x{h} ({size_kb:.0f} KB)\n" + f" Format: {fmt}\n" + f"\n {info}\n" + f"\n (Kitty graphics protocol not detected;\n" + f" run in Kitty terminal for inline preview)" + ) + except Exception: + text = f" {info}\n\n (Cannot read image)" + self.update(text) + + def clear(self) -> None: + self._path = None + self._info = "" + if self._use_kitty: + # Clear Kitty images + sys.stdout.write("\033_Ga=d;\033\\") + sys.stdout.flush() + self.update("") diff --git a/booru_viewer/tui/search.py b/booru_viewer/tui/search.py new file mode 100644 index 0000000..3c585aa --- /dev/null +++ b/booru_viewer/tui/search.py @@ -0,0 +1,12 @@ +"""Search input widget for the TUI.""" + +from __future__ import annotations + +from textual.widgets import Input + + +class SearchInput(Input): + """Tag search input with styling.""" + + def __init__(self, **kwargs) -> None: + super().__init__(**kwargs) diff --git a/booru_viewer/tui/sites.py b/booru_viewer/tui/sites.py new file mode 100644 index 0000000..0b94572 --- /dev/null +++ b/booru_viewer/tui/sites.py @@ -0,0 +1,46 @@ +"""Site manager panel for the TUI.""" + +from __future__ import annotations + +import asyncio + +from textual.widgets import Static, Input, Button, Label +from textual.containers import Vertical +from textual.app import ComposeResult + +from ..core.db import Database +from ..core.api.detect import detect_site_type +from ..core.config import GREEN, DIM_GREEN, BG + + +class SitePanel(Static): + """Site management panel.""" + + def __init__(self, db: Database, **kwargs) -> None: + super().__init__(**kwargs) + self._db = db + + def on_mount(self) -> None: + self.refresh_list() + + def refresh_list(self) -> None: + sites = self._db.get_sites(enabled_only=False) + if not sites: + self.update( + " No sites configured.\n\n" + " Use the GUI (booru-gui) to add sites,\n" + " or add them via Python:\n\n" + " from booru_viewer.core.db import Database\n" + " db = Database()\n" + " db.add_site('Danbooru', 'https://danbooru.donmai.us', 'danbooru')\n" + ) + return + + lines = [" Sites:\n"] + for site in sites: + status = "ON" if site.enabled else "OFF" + lines.append( + f" [{status}] {site.name} ({site.api_type}) {site.url}" + ) + lines.append("\n (Manage sites via GUI or Python API)") + self.update("\n".join(lines)) diff --git a/icon.ico b/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..43ac92ee8599c7cb8a53df6019f703e248db9414 GIT binary patch literal 137629 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%0D7wEQMkYSU*GfAr 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

H>rt;)vA(s3Q)ezBSgOva()X6mM-X9k`5;!8 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

;&$AwJyd8`3AWn{eAR-zMBL6w>0%Q+?wU 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 literal 0 HcmV?d00001 diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..c88d3b6bb904233ff8578570a3406439a99522b8 GIT binary patch literal 816544 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 z zKC=K`MdO=0_BHKDqM+eGBGRc?+a6D)i81iKEfrC198tG#@-&AQKibo}CvBX}rjYdJ zjkl}r5lz}XtY>j@Xm~>5%bk(goNW&&t%Q8_*~2wMij1^`&YM?a9>-X_TxQIY7iLh+ zu2?Zp8pMv0;+d`Q4bEi`1pGOD>7(RFEp`u0X7FyQhLH5@;x_I!e{ZbU%xH}X-)CKD zjkmEDkU6Scy3MCpQtP?fGa@acJ5D4}QReQey_IR*J2L~5k^sbf7GHKcugLsG&{l(T zO*yx1vvzom@RTgjaSkX8%2Kv$^1m}T?z#5?(b0PD| zdepNM(|p-ZHVc)YMq?pMuH7AKy`x#IA_h1ae_q8~jtVw=&Tc7XlhFqEUc^iLT$kks zKRmzxa}|*rnpyKGT>^JQq(_+DXSpk`kTXJNBe;zA!!NSBj9sez503553cFsGzWZ_B z#^67-4(z4_15+Ja(^=Xy^~SXB7cXM|*jqV#4&;uPfymKl$1}1mfb}e}opCf3aoNn`Rzvwei%y*8Sk>#*f)3f$i zwm|sd1=P5c^4~-s)?18%i_*T13t1E4eW)R9B?JfKZi^<&U*n$lIyul+(-Qt#HZ#{D ztgShnlCzF5>UhFX2 zl{w8OlvCHT*Q*3{S`=^~30F!r+^U55>VIn5h2C9$Mf7XM31M3&FocZUX>91R`|X-` zIJl+IQCi=K5`#d>#RCQ_dsBGeu&&6cuC|ig&AZ1S`r5=Q3z@hWEnbesXBhGSuCoGJ<=2wZ-nE z{mWKd87tqQ(PqYbcBrt&huhI}#;S-a7ECJ+4@n;kvw1Kw!rc4%%<8oo!>{D$+!|c5 zchfH|;(Yt23_kZJyR_2o<4reT9beJ5jUE9>QvL<>jks>8X4sqTHly5^y#QEnlAqstle%ZZf{5_aWXDm5b?}3i=dFX{0BBUv+a3VBVZ%33|fk_-Ca z`25M!2H)fzDVZ-hmE&?-mDiZkgaW^{P*rR(o^!%UG9TBMyvsw&fWN5nq+zVhQ`Zz` zmSWy_i2Q`iJt1MxP<09ZD-qjp6gm0rlz3TdtHU{t^|zw?>Kbv14@=u!i@6T<>BbS4 zZ+$nm`{AwE1eBEI2Y+m?G{v5C`HKUbrEAaw^LOQU@9s$ z3ARUn7+I?%404e1W%C-AM_3-7Bg?4?XrY(!Vxh_N3YP^9z%NQ%+Ha0`TX>3!!ue~A z64Vy0pMwg&@tqI%1;X4GC<&wgPqvPInIF`UI_hFx4}Kys74u;xY+fFy)e+@gpMXhZ^_x|g z{qZ6wo@buo%L9Y}l6$9)iXph5wB7J>&GCbXR<}$aTj@~kNkC@Yp1>?JEtQEoLV&-9 z(&7%KsE`hb+TGK-Dc+2VJVy}#ln%1}461oK9MpRENn%e2GHoO5n*=7yMqO`1uf?yG za9MXwG8-CziQ#((7ob%6-H#$adb!~Gt#>~GjJr8V7!H|brv?A_Ea`!T3D zHS}8h`Tl)7Ha@%}dl*9p>9If0ait(m|1%ziXbGhUR{>C(4D}%l$^tkz$En?Pg?Mp0 z+RMX_`zDvKYpkEZqJW~n^hkd=*)Rn(zwnt{i4O_M|K8jGpq8e0KTKEP{fx1w!Q^?P z<9h8Sv)S0dydQr5d$M;>_>A&y#j_vzJRNJb(bd-=fsP}Bbhe$TkqzliW|S1XaD_8d z)5hAudOyv&5)DK3WKPqbiFe}4~C%}K(jBY2i}TB4#ud$>{nG z8=S-Hy~=I9dwxJ*5|Dl=^?s?0N=8+;p5ODw|8YL~6l#aH)@Lq1)6vc{INH4F$2R3xt5wl9q=@1<)Om53fm}M8TxKOoDxU_p~VNZ9IW#ITT=gm<6fk5N- zKihb?^xDZ)q6_u)HTwYC)?XjH|E12cNQf9XQ7eq4I|wBvPNqWC$77$O=pOa!AaP7} z`U8w+`ls`@uVuV2=KZwdy)I*e(ObqsQf&f7Lr47h@CGX;O?8BjfZYR{M3S3~VL8=D zY(Xd8pnt>H*Q=AH5xihh!svoEUbGS+j90EXk-MT^LX1&6edqTOj6+gRWNA*0X;eii zT`=%HIgto4^GRz*FlynzO}4x}MVch_^B|m9sEj-bMfDs_xf;zgE3Fg5aZpm%(n$zE z52m8KaO)Z%!2AKj5CFM3>*Tsw%s%!%K3Zu+?4~fR3TtEY4LB$!=!$QwB5<)YL_hY^?Kn7kAdm_0QN&Vp|{%qF^?8fSo9Rd(`p&!Ip6lcGu| zAa(Vz6KBtMFZpFVqaL{VUMR?T-~mWi3uD9NB)6mGsrQ!tY6-kBk=wIq6kUn3vNDO) z841{0xi1U>Hc;h4!B^S_zjpi})f#UUz0%#D@w~_3DXtL*ES{vd7%i+PeA%Vg9=~PT z`XaP)+czSzIj>+19;)bt?TpMlbqu57*~8pzZnurDt-KtLI%cfeV)vZ4hesA1oA*>T z%1$mvAk6>LyX)IBMr6*H27q`X5w?2sybVYg9-W5%z%l-{*+~p$ZG5gMvjGmg>RTGZ zTm@!rhvct+e9yIq=2{bP&&QCBE;K)>mz4&|$>7I0M01<~6$y5J5bH8W* z6A_*i)q_hs`i=2al>TpTU~={Vvt@`R2OGQ2&ixucZ%R<6@PS#jkPN#9!*sk_7HbJ7 zTRt|kToD|k+UeHAV{5PNlxkV^h1wE9lxC`oZ~sPBx4!x#XY|6yGM|T;xll&21aED8 zWe?UA*)K1CDQwg~*G7Nzu@%5lEwn+E`@3b@0eWc8(wfTrT$eRBz}AoaV`-5*ECq>- z;mFiDnTysO8iyq_Hn*z}z>(yoACxtY8Q{NDADZ- zkj%REswpLcDljHdIO#-4U~m#X0%T1yqbJ-a@P}K*4~#(_SV&ALA^2O?@F*TwNi;Ad zAu%RC3{1-)OYS0AL8Al4l`?Au{u}Z}^nl#>U-}V7WC{UgfoA6N8%mR3;4RWFET%^Z zgPou1SXhcmA)wM<&kk{jRW|>kIIn>~S~o8-uejlujd$Pukftr75<-p|OJBP;f=%m5 zOmNu}Qk!g5jIl+ot#qNmt*wlMIsP)Dd1_#f9SuzCVQ(@pJ*I-rJOKsdLC^oKoE4Qh z@AJx=#PwpAnl*3T$Pr)VgpDW&Iq)7L*oo<}WO6C~AH3jhcshYXJtpfHuUX8)RI&c< zb#sJdM#7z*B1?nG)6^_$+DvuM@o5^R|A!FX1SUIOY%(Eoe*A+#*8NY8=~^DexC{q~ z{G#T`<0#C#QI@S6EpxjIQOcqloNGR`5#)ETf7 z8qTO}GFbeb<3FX=Y>;W@D()tJnnFOAI+$W)D>k^RZSf~*3#T(^7suXYPl+q-x7Ii| zqFl;xz#5nU#Ue-VDOy)^#Dx{0-e!pJ`wPSQ9U@+P3)bYl$$L*_nfOu1Ttp2q~%89*#bc#y&$h z^R!c(WN>2|?K@(qh8puz`In$DkU#UB)oI48fJJxG1)IhkFT=>o1@H_Xh7R2H4B&mt zSP1|g2F#9~L%8+kQUrZmRtjtYq9~$UE5TNDC*YT;q)5Kfo*c}_-beeNxO%ID8F=tj zdEC`bKml<3SAt?Je&w=2{GT!3**n!_M+%f@IK=xG1`5V|C?Ezv^uAbK~(AukGwAFZ!nK0*b86!Y{T~O4M-sAJn@v z;pO`>Cj4<`;M-4fJ2{{gvd~*J!Q4~MnOdTfQ_ACr7Qr=CREUpqVHQBqhPn^t-CJwo z9IOX*Hf+)~83G zDb8k#2n}WPGkHS`X{}f`E13rCj;NYVyVH;=4#N{6&Dpep(A0LJ?>T!@Oz~fL1Bcho z+%}xP+^cEMw84MpVl0N##8nUvP-cUahTlKMy; zbmLuvF{Q`(!C=kJLaybF?eVSK+8DGLX<-9u^*!m{zquN;_M!)ZnO zI!9vJ7?E19eUjf9vy*LB>F2=FQU>B@Q-ass8DHD2UqW%y92dM%#Fs3BM8<{~x+UM< z;P+0RUx{wfV`aHKHyUi4LwS9|Y;@?=fU9q6WoaH^Xg)Tq(KABt%HHK@VM(5>4w)?N z{G{c`oY*hV&v+T{|1Y=bAYULfOo>ihHu3_NAyH@=iZW+@OeaqO70MJ##uXC2PFY+$ zuKQx5+F?eXBXFvXy#A8Wnq&y|w?o1q!=Ns(L(Tl|M-(r`dky(xljane`z$_Te+N&y!K&PumDXWlRh8fJw6&t}4xxC_lMRb!y zhCjyY02BS#opC0CVg%5=>o2R)%@mrur6VHhio;LCX!zWJg9GD zs;R-pMW)K-lIX)I0|8R2KMgFt{eM7@l$2Dx&{RYT=B&|J7<8t!8d}k$7xD2T*)R)> z2HSJS1L3Abkct7kOzP*%Z3qUrGBWrBIOg4YA{ZZ_kKY>1RKhFU-(hMUyzR(M%g;5w`M2%1;?JIsl1-f&k~*_hkQq^u>H71OI%(F`K4 z5$hWwm$?w+GC&6Z2uZ^Dy4V@(92x*%P9)EjI5vfo0B}K?NDe=Z zsi=C(wQJ9>Z>JZ>hlf3c^5ID|)?Q@z2U-G)$x)mNq53b^JdB@n=FgpiaF7@xJ;VJY z<+3m^KVKMAFYP}Z7Sr^x{h`j|X;#!gCTTv5O?04hnYOARKO1YvPB_c9ACIQ}cnGn?_YuNgycoKz zcXWEKb!pFRfFBrE@LK!PSY5&(13~01&Gi!P#L)660eq@pd8211ZfJH`+mHl0aSa`d zs;=hRl+#Ip4MKm`GSr>jso(xC@7|P1ofg=4y6X+=N25pEKbxOz0#KAv3Rdg zk+u%Fy0J#F7eDh%W307pWxD&W-4Dqcg|Ef+W;v0Gt!8eL`oTI_JT95GxK=kitxL7h zsr#oqLG(5`Ka6kO_vAzP9bAjMFj<$pTC5AACLVbR+`>Yf{WG!l?&yE8$BGNT?Bp={Y0iYwkMkChbYVB!XjSi@ z|Bbi*^awKaVf$3}sb;(7+%b;YUdxX^5iguXHs`Ld=L zQ>zgL{(`+ckm#UNa6oIT?R!5PgUr&wfX>>utWSGtVX~_B);f7Lzj^V#H+E*Pi5lTa zZ0s#N|H=6&~qqt5tXn``?Z&f@NfYP31^y$0pn)S=-{x`W28nC@sX@; zHTA2G)g>JM(^F!fwMUI_rrLt4lHej(!-0d194cveSLx{QxnAe-9O96%ko?d0_XN&o zoU++RBxn)I$fj(ea;E%ZTsahu;s*0i%Qa=`-BoHgOjD=5AP(^|Z#jmKgpm|e^qARF9=FjKayr17t zS0btQhooYk&NpWA<_kZy0{c>0jC^6yb==|LeIggmf2JC2|JRklu^awCS|H=u%2-En z;en(DIgjxCb82QUZM5e&GJF-U1WP6gN8Tl$#yX!-*SPaIvXG2Jv8*6U{KX>p9F~c7 zZm~iF@2-GCXPHhc`)qc$$sUI^GtWQuS&C0#bb94Hz1sr-2#R z%tybe3~jbmY@B=7I)6x6)u{q^c*jnbj2uf0B4Ghva&r1OWgnCKjTZVifO+_TYNEyT z3Z*wuU3b7eId%#PcsLAa?Sx7i${qf!GZutkdBpx#y~PyGmV0@N1TZDRqUug*&2Qlm zUP_6=VvBz}+-vpS#4fyz%yA=@f$OyH=e5~o@KH1?x1NtEe|+ok@eEDv-*!4Xvv52f z1HW@_zPRbYmE2{lhV8hu30*OJEN(s^e5l#NC8rQz(oe`8j*My?OFgo57YAvJ#-$^=e+xppZN?O&W-|yuX1_>T99C0W<>rZZQCX~S!4dXavW5* zT#h8|sNax0zB^a6q-uL}J_rDxkKa|i|9SB=VPL;*KHV$YX6NiohTU)S{1DRqF z^l?Sd!{j$F%V>+&vJB<~dfc^v3k3lte8`EOl!}(8C4$gUjpf?in{3qOZKBlle1oV? z_uPmnct8-y8kjrtr~1K({Lf9tuTXF*i4ILO(nlc+{(?&{6DC78rpLZ{hgdWH69rQW zRE~)md<_~;V<$p#UlP|p^94_|s&O#YSMu?v@4DTr~BsT7hs)2+yuWUC-2jYqXuIPbs1iMSWa`~AQL|H z$fteycypr7>=)`A4kK(RCm(oeEJ=0txH`cu5{ww9Z(t&b_#gP#4$GU-8YZ_?Br)`S z>2S-S4*mfbcw#S{IA@rWgDZ3q&9FK{8#68+XdmX&pOUqMFuM3?k-wZ6Xh0q$|4_0~ zmid`R4`{O8Kab*EgM6}e{>AavXNxPI#XTNXFbh8u2#OrGR51Y{3KTrTyMXByD>%_n zbCrE1bQWoe+x*L$EF=(28psT#>BJ6yQRVv4ssG&)nDpg$FSL#URPX^xlS5-799KLJ zNg9SFS&5-B)vI4_qPO=}e00VkTS(1xV&IIbMVE3*_9TDho|c+R9ZgLFl}g5ViMxVU+e7kOGP3N^nd3%0)iUpe9LH+8o3O^yo#a3C9((GRJx~@hyRu+1 zL4czQ8$ytsvWI?Qf!R!I6cMUFbW8P!)%NjU-OBIwQH_TN5VAd?HWv;+buE22A3E;b zf8T?QfJKFsITLFuTLPJs5;o-K%VPqK>?`-B$NFgUa=LDm*L38q&!WBM9MR!ty^A$Y ze>)7+aR}{B)n<~9`8F?3uWy;1xfd(JzL~jOfuXss{?m&4B}JLf$8{${eYKyh?&2Ra z#rMF_(%X;F8QOO3q5cP}PER~{cI&wTpWA~+Upjx(&Ax?wzBY7jI_=(wu7UBxqc#~ef!kblLQ>l_pKSq{{TIV7B-Uvwsqo9f3?C+6tPEygblG?B5V&C za<_*k$qyxVinI*io7|ZVXnQQ`aXPjpoSKan_yXsdb%2FDshn=L^0$Sf68e zh|P<6+3@nSDS=+ANej;9o>%%Z8F@#SBQhbp1wS(z_8nnG(KSD;SEs~LkrHv_B?4Pr zZuA9v1%kZ?6GvPMoOfCK>yzfiUoAcOa=`bniNaohN-9_(u>!|x4c=f3D*Os;L_u%z z7N3%P6$IVq(+T(V+PNq~(z7AlzL-HJAB@D1QCf558&ef^Ud2T$@07Eu~Qk`)F6@nw-~kF}{z6 zqgK??jxhsFD$#>1o8(Bw*3G_(V=Weg+lmOclnwN>!VLRo`t@u~7Y-7%)NwFIJHQBp zP2`)&4ZsLJ#Pb;$-Ef`^$+Nke>j`8`kHzg(47{OShlcf#;z+$zG;RY#t|-C(Q!DFMNsq#x8uvOftn{N1qOp0;FPH%hRp7 zOgG|^mRBJ5(FJ8x}rFy_KU%f(O1kkv7Awvp+$6oXYjDXhffVskXVQwke!GE*QoIP` zhiUbhHklZwIkTK6IOHltM`~L1TyM`AZ+&!kX*2}t6n6Yj!@FyLcKhE>U|(4M&bN2h z^_|^mdbB*M-1z=?xW4DgV|I5~3o5VS6`k`wzdV6ok*l(lc~i(y7E>%Zk19En5xf|q=1FrZlixWNiG|3V}K4X zJ7mX%cV-4A22(43b92A?%U@d4@Yd8&3wl__xQwK!{+O-lSHEIbWj-rq*(F_ro4=kc z(1r?2R2M$P?L8~X%Nzdk7dZix?xlh`Z}S@=4Q|8vseBY@47ug}nltK&;MX@#g`9&% zJh|u?cVDhtsuZaR&sML6=yC4#Senyn@s2eMcnFrlR<2e{Ps8`@4 zFsB;9xISmsVqF~8(&gJU9tdqC{!x)A2%WkpyZb($0K?PY6W%;S>ilw zE^j(jlB`94H2uRxA#Ot1KHt(cYZ`9;WHw!>T{SK55xq;3k!iMRR-vwLwLaAX>JBG-@=G+4U*3A=&N~ z?!Sj}voIncS)$yPgA$+|ETM4tAsMAf^vL{4iJrIR08UyYM1N94w+-_*&W!*}rQd(<0u zO{wov??|#@xj$@XH<{TXUjESjnR`38pTHl`$Dz+=nSev9!u0A+$(Vx8njJK4K1VFW zON5P8PU0arfUjJmb#4Xb9h1D?rK4hc?DpD~bs;|L$#nYuxP`Rb>GVDdb1zkN^kAJ! z+*P(KooAg7dA{KfMt5dNcP0aW@~>~~Y@+J?;w@kFLK2qX8n?5MfPQjp=ybtTj6zyX3x6Y+PZ3;HBfr z6&w7((vFra3{tgkS+~@l&pAhfc`^JtBbXE zkkJsI#h@|#y?K_VbF3&h$!~nG=<-#Re&x0M@Moto#wMG(4%x)m+CeOS;BDa-f-N16 zA+OgkQq5CQ7)a)$@~<_9gWD={&A0khB9m48}w?86_0vQWmo)oxY?Wd6LS zW$}m4v}OFKV-#xZww@1mRsKFDB08>7+K72hX+~(I<5PPjeZ=KrRhN_irZdJd%yAd6 zKEQg+@>>;&r;^TI}V%PFV|F9MQI8en-;N}X(b0jL) zw_vA5%dmz2!r}%FJ2fp^9kJyv%6zh9f9h#U>-M3n2c)Hk?o{ywLLi8qiRjYv4J0+3 z?&{kLY%>4h|Gzc(Q-0@T#g^Q*)>q%Wd+fk{`C-P|&Of#YLyKHNK0nQnDo;T7C^7sA z@)w?}7JW=M4#`Rs?uwPj9DSG$ipiJy=ppx`QN74&MG~6=6>(_jao>`JC)5^$1&;Ec z+Z4`jTCY1R$G_nZfH-pfEnjHlGw$;05NlbBqxg6r;{WnuE0mLqd8HbCHiX@<-7tMR z;{Rzpe--FWaBpX6b9P@v*U;f+^hfak5P$8Vu$EL2Nr+)Q?%L?1%uwVw0;S1SzH#rI z*ztajquweE-&b4lZtLQg8m-3ybIZyfkGQHGu9FA z0@ewtZzh{YAJ?Mq0O=0FV z*bGC13;Zq8~4;G=-PMS7VSCWrOYd?x`4T^6? zo*_1iKdPg`edB)k_J8u0z7laeTDZ!mc z(;##tr{cLmwvnty_t2&xNt||n@!y(r=zh`2Ke^VRwzp*+!tc42;{f((x}RM>hUka8 zT>)o%YYqR3_|@BEhh4b!JX^Q>(jk6C1KnC#A2crI-=F!4&>$4ylb8oc%~o%14pHHU zVFoP?So+{lG7A(3yx69T0=TpPyAO9&@IT){gW$qA918ko$O4RFsZ|bEbR(Lgw$xY{ z+G&7H^KL|q7+cHq#!dqm{7MfEuB=bv0B`tXIDsoXQPParek_Pvo@?h57UQ|}btRv0 zisKPtq(dQ33=e^p=gxj-*2E)A;tDnp|zV`%KNw|8d0Uz$9* zqGBYICfIZaX1l&%+~lnT6Lx)4P-j(Ce#dXd$#aj!H`4q$?1e%i8sQ7cJ9bZLr6c^c z0}JXJFF<?BICGcP|EGX?c0|`e|XeFhgF10pZ{tvuSJe6H%_8DivMMah)dd> z_9SmQd^RKyMt4ehX9|a*v>z(Dm-ktNx&G_q;SI0tl+N_`Y?V1F3HI=b-wv-vy(j^( zdG1wR%ljWhjD0=3-i9hdN(yTIzpmUy zt=qs_2Y(B|MVtr%54lPAQbTdotxfTPL2 zcIypu;mR4F;j(=DZ{l_-7IKJ=6`t6qjzzBJOlwY2xG*U8;N}~?i2VPGCX>Q@qCcBL z?xlp8YPpf&S=pRJt3eSm)+s(v%3PJ^eAnXy8TfP7sUZuhg8d{A<4!PTF>CcqZ>rV_ z%A~xnilJnD@A1_+{U`5nwdkhA}g)h63BJ==xbn9n^7_lO{QKLH*HH6K%s87Sk zXsFUK;6x|ZOFwM9TO}*U4^Au?WHmhsrbc4KdN;?7BwK+(b2~piGa(^dAW;2mGUWz*6|Jwb3+txoACMnpq_jaRJDc zR_#jm)AH9+Yy@d%eQ#4h2Di!nO!^gx_!#Luvo73n3_fedKRHOIOY(+E+u>I2wN6=h z^5IM{HNZ7#x^P6=!IfxR9-B_K{V}ykRWXs`B@d@g38#7ikKu`rxRJ(L__4N@gmIxD~@~Hn) zH0<(@sS=5L%D#xZOGF>NceLFEzEBI3w}wWIXJ@(Y-r1;LzIaW3JoFcmZ%8eG`F7^z z^fhG6__4jp!Ll5m_K9?2Z>N_uF-BOBtTp2WbPev0e7r^Nq}f?Ss>6OOwCQ46B&va` zsVaVyiKu-qU%p(Gv!n9TPL4{+-iHRP9%Rho><0ojAB)HMcrF8$ZP zb)*Jz`W=qkinaxzU$XRxQ`{J82*NrvD zKxCwJEAQZ-;xPEVc(C?oH`>WN^ns|JBdw9Uz|~3s{?{^5?rYG0MAe zYiH?_Qc)E9C)s?VcgJbF@f2TH@qYEZ>V4djCm5ht>?YcILW>y=zBVNkFQ=-F_trOY z5&Iv^%N}OEc~xB!tc<;jk6guoiyhySf}bZ3^8Ug2C2^{bpA2MfYK^bOAmI&%Yf;ju z!{M8w6ZR!V#i+feiHwQ<9E2dCA|U(XI?Km2Q58bt%x$*vYE~4+y8Y92p&Yafq_Z;J zq`uQw3&9LWmMlrRejln!@By%cC#8>!17=Y%Ya0*P{lDMfuC}dPQy7u)K|OX=aPrQ8 zGxUNln`K&S=m_K_T;BeE)!O_&yhHw8l@alpb0SPC@};E8ml&nyQ3Q?2V0SKE30 zBiRjp%*u1{Wb}!^-91NUI|P}FBEJ8-sZZ+8A^9KMzzhd4G$buDL{}w0Rn^LfEl5GT z=R{aL&u63_4+L`J1X~gW9Fr;^|9pO&l>*kJKaq#BjMQ-K{?YE*_urp&*Ijp6j3Gnl zy!PjRXX)^<`&An-zXgT#n-}hRUz_G;d+OGc&mexM3WhUnxoq$zEI><}p+T|_4Odi${0dS=9gH}Ti%;H{8*F%~!Ogaa zGxQD-h^r5%V|?=Ba>fZDm88Po!^{;4cYsL>T?~EL$IEz3gZX%Js7;z#`1uW8I^Nk{ zP`b z+KuUtQJhQF1^zZ~}=yn`$!>+TNb@X3pdM}H6J zyaO+>3nlOGKka58F(?$rP!y|AKV7c}oD^P$-8^ra+4BNu4lPIRPBmYdoHwCxjG5_8 zp%$4ZSLGx-RwC#NE1i*6qSu!+Zr!N52)ie7Z+5Z&rIe_#GVsN$3nJXg*iFB~zc!+> zU>|H{dPAk;DE@uUwBnYGgo6`gjKM5GQsw%W*R4r=LEUHCdY!O0$+oYR zlRHES^K^LnT+065$Qovd0bq^RW+g5?QmeTs)QK->RDwWe=!sF?9sGB$Sbscf zVfBx$zs*QXI{jw?Rw%2*!Hr2}Scjc{wUo<5z^}bldVA7WTh<mdhW<1dTU!|J!L(4rA*}!^|8C6Lw z=ZC!nZ9H-RoX@80@@03RWbDddxkjqDxT`$f+QG{@Fr8MyY`T9u<~a%81QspL4_F=+ zZQ&>=!%;Ow1`1lYB{N~U^*nX=sjjCN$J|?mw9`+a`?ui` zU-|;Bd*a;?YTz8pUlwL396m9sky_Vk+Ia7?@8ga*jMw)te8q4;hH7Cfd=iQ>*-vB| z92=f%D;}7b!GF-Aqy1zgJ2>Hg_vOqXBPLSmwZ^BzKX55ncaX8SB-EPQRL%U~^m-d( zAS_;gwlsO|zEepxM<*_PC_mN8NexzFHr$h5?G`f*^F^$E%e%U%^~ify-+74%cU*a- z4g&f$+m7{Lio7;Jgc$#fs=j9OlVFONg*nska7AkqAlY!jf3uYYxiz4ZclHOi<*=O7 z7TxU;11`c*?i@(6(P8JIR(uXc)-`=!h)PkPK_bGzIA50G_<5?N7ux8ZNTmP=2IJ?75SHc-hHb_2Ipq-Uk0q;QWj$u@l z=TheLU99?^`-iv@$y3vJFHg1}Z;#LWe>}YnT-0^G_Wzqj6YG1Mwd5lE7xeSC-90a(r>_aK&i>-2gdKI?k0`8x%(`td z6>V6vWyz%Pe$Rbc>|*EeyE_A@%6pLf!eKM`qV^7Kry?R<{%P z&Cfiye3;A5Q6*+i-%_(G?A0fZbEao^hM9hYv}p~Er4Hgq36W>R)cza$j~6q@n&jqS zP^obZLTDy*#ht5^xEqdemP#QzI zr8^(5j(F8ZU+pW~BI;bMKc_9InrfrV@|=%S>@f4bgD}g&Mo4N!h*&)nTv1u^+w&Pz z5u&vxlPFk%ujJ~P5Si4C*AQmHggMcx_qubye`?@Yj)TA@leE|I_yqwr&||lwxK7cZ zYsDR-bzI3W?TxafuD*9jm*3faG|)bM3^8co`6SH+M1ezhoY`8sNeo?wj#Nf4n&yl=Q}(*YlrhNdu}}so|q%VQ&KB;hN_VGhPZ~(jwD|}H!#=Uxysd(YiN*)d_?;7MAEte zFt>Bz#qE~NZPKJi?BnT5&#Amed(*}{+v;3-?A3*bI?zj?j*vj=a6zIMHV+@biW#hA zcuSHrLh5oY6v*p2}LxIZ79^mQ)UWUq(1}FQc&qgt) z=5!)@5`8xu?b)ut^xHA)!N+vYDL+6mwH1ecbtrZ(-b?9Is{D4=Nr1%XmX=Q({MQ}i z%X2pdcTnj)ZwsA%`zPQ0+$_0$zv=qzDW?aQS4di48{+J~Y`Ny?A2s)6nY)+YiH_MQ zwCdFt8JLtCE|sqa{x??Nb4Es!V^wH_3DZMsQNb+n+Gw-sMH676t@PDjo~CN6HF~hc zLVb1*WWwS<;yppL^gST{ocZ?po)U`6Kqxp0H4Dbvl-GZVR|ric?VjTr74Ht!LFUTz;fE6 zt*iypH{>2zVP!8472Mt7>w2`u@xn5yj~(v51K$p!Jk@ zVBFsS$e%D}7dU(V?0ao{3f|=$##Fqsa&PV9-VuSK`Sfbu+-&cjWA!xVvuj`5R>QqH zz+le^mAapN=TTav&YW2vE-Fl}Z1C-xx251CxD_UaPC4QjeB_18rHc{5zj!>|pnQ5};$Z#*^=f3R7pzwg*F05Sy!= zHV^J-8aXl4imP^om^-d=#<`Ky#>W^EJHKL4vX;u_6|o8;0U?3bj6r+){$PIV)0GyL z^1=I=9-_{l7Tv!~RTKZ_=)K=S0W=Hr$~0UE!lk4FFg^ELqoZx6q+YX$4&PU$s6J5K znrjqM=${5z<^7YSj)7&jF?(wohxp#Qw}voq*8r2W`sq(%upTs}Cg>%!bLlG5cicRx z3;5k<|ArehE*y86?qXnmp}of7>*@RVPzi@60*T_=BLb>!H6%K5!QKsPP{klALC0KF z_Zv$Hsr;=S(=1kvh|hw1_p(HkP&S&9lt;p+xSC}YrDY?`2QnS~-QjX;AV=DXsbn-5 zP!k(lVr#j0?c9_k(kEpuj-C2fkcyzw*3LEXwRT!fV-W4Ni|{$JHLh;er)i#a+nku@ z*asV$={RV9r6!Baeq$|*RP1Jk9c_=@Fa2oauSvUa6++VZ2foL1k*%%H{}5=v{MwSH zhvxm%JH$uM*X7-j-Cm*dz=*pnXTRP#gAHBTPcEoE+60`H`o0X z?&9jlAMdz6csO3u^Xr^bH`jWkU>E9mFU>c{MF!!zReGVVFKsGNKB`EYmS(+^$u`u4 z__O&$eDgNFbVKb)8u`|E%WJHsYF2-xI2sw4J>2*8jRj}q|9wnx zWO(OQHmjHOHaGkW$lU~nBYzmVrz48Zut*6gC=&9US<4%o+RsMo%{$d${)_7FCEiE` z45q6RXT=sJp}Gyjw}|{>0eW>D%~9+8bUCDy1a{3$xKZt;#`^pH-_4IhaeO(olF?To zfNniee3HU`ab4`(&v_6yliE9$N3kC$iW=A#bKE&_bEuk@vR@NKIl+!17O++oZzlML zW;y`lP!D#{W3IVZg$C=}{3RTsDO!ws3{LCMUeQ$GJ1!)R!sVHb!S#>6eg~`jllgce zCYmu*rxxz8%l*D^Zw0{7no(yG8Ukamovf2s*(crkj=8z+IX`;lqj5l&^~EX9NYIgr zZ0iq)-pQ_e?bzk#QC}Q&&oj?Flk~KWH`LS_cM*@+gp{9hoO%n&KOH&fEW%@43l7y| z?AIi}LO6ah0w*rW_?B;y_u9Rk z+4tX%`^7JQu`ix*3gKrzgIN&S?l(94V%nSk@3GOcHQfqsU_JjuqV%6tCBbA%y65RN z`4_~xgQxk=mtT0~Q28&`Zu!&0k?NG$1g5}<&1Svgz)B3GL*4rjZDz#FP5ht#$^O-6 zIG;BJ9Ue8+f*e&Wui^plMTCiQm5033Myz00PQ{=?6>~j>59Q`eA$rUr3?myeJII4u z;LS;6sMa}gibl&mHyhpqL&ZI&5>%qSc@**?xsY6L%j`MBEU9}+GiGjbI2CC^TSI%K z^rW&_JV1CVm!ZBIY}8Pfe=~4_U(TRjENr3*aN7W;sl?l%98CJ+&Z)C%P|g;SUXvP_ z2IttY;BZ0`vCv|;E9(|DCpYOttlZ@(vx5LKF%0G8aeP;Xla@(VnlU>Cx zjLEavJh%S zR}bIB`3$qw70(z6p0#(NFpYu(EU$}Ghmb1a`%5EUYz%m&)Zee*fWuFM+)qZEw3S(M zm^VwGzT?ug$bou(A~-G9un&`8WyVEE`$JL2oOSWMGe<}0J^!uar#-{2es;QPU})9= zlJLJL!ifD{)X!r6s+<2O=1?XiM#jmV+39t5#UJy&S^K!1UtW7{*o}W#;4xAG1UhJR zy?lO%Ba3mUvoZ~PJ!?|Ux{|Bw*|$dX){92PZ62E~%Ha%n*2Jh7dec@l4-(aK*aCFW zolT+obwNBkJVpe_;dHg0@E+IsQaWHa_Fwarr?1{!@b#$f#3I?{p&V4cv)W}Jaj`3U zvMj8NE?!7rI@Ed#hvJQA2zOjztyi`T9os zal||J6p@KwC}OjUoTe&*aB@P|*v`oM8N@WiwdAJzidEZxmGzaWs@4yinVAetCEW)OYy@mzENShy365#G-eoGUz> zSFe&zUeiY3ipRy=36eH?E=G0&BRJ|<@>Y}?$qdXxC=FHuD8#_6#7s7k83z>!)a1V` z(XN6Chv8BBp?|&!+5BfKzA;-XH~tUx4e#K9y;hZaU4qo(Rw&Z<{okPmFy{?2(j%+X18e$&4v38 zf7p4wa2KB!Z1SNAQV65)*1v90$WMKf71)+a0Yq}xj2?N3Or{jBsocsIJFxdV<>cpD+npApZjOr+BPQRJHMQGm zjG`MHp2CXB)0zXDV?s#}?f$wV|8jPmJGI)`HT8H(u`c9VD(MArD}~fhY>0Plf`qTDYVZNCZ%bPV8tQVq_N=yVPIfHd)RbiZn?IZ;{SPZqD%ZeR3wyMNLR;jg@-dMypDAM9Fqn%Opz6hh#g3r7sQ6seD%3AOD1mim!{Vg6 zp)Bq2JT&3NOEZ|^gK>T|^Vh4+6Vh;fRQ=&^waw=9f@o715X)F}WS))KD0 zeY>iM&%)CyEfq4++UT2ijIy^i%lJJ&XG&4Pbu?>M>b;i_)lstie)`-aNa_E)Pz}(iri>^NC>Jekb(i@Hg4{{qi(rG@7-zs#gmpYb7fe;Wg_ldEn11&mwZYd20y*?lI;KYa}GbCa%; zt{ElLy7GLR=f@=P@$?WOu;REkDj_R0v!-XYA9lCW{2N*Eds=hkon|J+fSetf*$ zQ_qp$ZO9$*Im;haSbX6i+FUeSD}3)~;*NL-^$E5Yj92dWyR(~7-~_%X9PLf&jEk5M zUzpUiX!HZ4r{v~-{A~_wA*(ne^0_@9{c-B7sqVq)&u!0y^@jG9J;fS3iKDKe{Zlxr zaHk|tF4@CgKC;#d_aCE+-e-+5BU~|DA=e_tv_HYob@{|{_{>_36uW$n^I^xbY?eIs zC;a`;yF&b~6tEaret1FV&U2ys;fPw=Q$dipV#y?P8Vc0PrQgRU&(r1n2g~lns}nCB zH@JjOt_HEhn-3Sgh9Ez0k5Q*=w{E2YG{j>e9vT7jGMMJVf}}j-MNcT4K87DW(?QNs zfTwUVltTWUQ1cC)9ugmc9W!){x76YBucx}`AgK{GY$3pIrA+Hidr8Fj~ zd_w+ZeiD0Ygo^1QY7L6Ikl5(PN$I1JF>@Z-FY30cU_(x(#305~S@1@v2T`&;1sh*) zB_nB5eZB(;6)t~V-1fP(&Qia-?(nP$7?_#}N}zuD^%@yfFWtE>F0T96(^yHQ?&&Qk zT?01w@G)jn$Sg%ITsZMA+LHt6v&|k#!|E7U8n1k;ugvmWK@{*Ys^#eR@8UEKdbn}n z?+V~k_$^JDk(-Z-cEx$c5AA45xRRscWNSw4x$D)Ze_66(?mW8j73cr-j3GUABo@RR zIE+W?*eYMzorHhDmjC?V)jB6eL@DucTi@A?KjoUG*OI>Y+Y9d8vlTD63yVMKV8;yN zDdC|WsHx{p{_mi14bCk5_z4vjTOm>Sa+yoZPj7@{0n=ukB`#OaQ@TvH05{G{l=_qK6ms2x^`R?M7tWz1tO&N79h-CGBMtdv_Xvz zg>>;{aAK^zwE5EYdw1VgHpXgj*}+ZuV5=>$KyoXm%!>cwZzBt9?ZFSbis#XR=D9KZ zZ3uN^rP%WlbLkSb`0AZ@LOP~pWY!+3P7C`7GmxG@MYK5m;>p$guYr--Osc1kfd%tEnYdQO2DNF5_@^^Sq zJ5$Ub*cuIOwxI`BR7PwYXLkksUaNYzue(2$T1tSJ>6>=n_jP5oHLL;g^Y$vpg_%$O zd9wxh$rYGG#~IakW53nC+)i;-d39Rt*&55^SSgbALDe2gB~l-5sZY_gWOQ@{Gw?|J zN&!N)viX%CeA4ysG0~QwHO{AxHH%HU?GmoM8hIoZffbBhX1Uot1%V6SH=$GOOKidQ z*@afH%i)4+SU@<<&dvtVt>D*kXBnBm12JV-*uUGbGDux5&cyRjE_ctQRrcC21VpOH za-Z;zH0|@xUbB)?>N*JOoAXLW^8kPh>OOg*d-&i0TiJHsSixm~&RHtW!#_Wd3HHs0 zUxKsJ;AG#RdgCjjiP(?t_i*Nbtthv932gVR|0n6xGv-77khK7UtWw7%CeDMM`#O+Z zhi!NMK>1kE!YGc^$`^=7xJfA9Hb)iA@K^W7XRJv^-(fq1LT z6m=VvMnaDo>R>gbF20JzG!f9)I074QkTX;Yg>*$)4xv#LuYkQl<!8lv(FeRkQ`lIk16x>M#q95=+ zIG9Wn{%kCi$Xs4;&`hQX!5+P`O*b4)QO$YGz}Fo|SPNJX-z>JmRtYYhfmxJ?UHnB_G!h{fX+)W)YBH(BRODyD7#GmlpJ|ECMDWN zWx;*MnyAj{pZ)-wCSv%~T3L@Dqudd$?Mv}^(^G2?TK>_tR1~>Cf(X_UZ;i6{?XjyQ zQ2Rq4Wu_^6c_p~h*&Vgx^0SvEC(omz?~NK9CO1_^RM%9deGrKBRk*6%2Zwq2oXe8o z>_IAZ)BMC$x&Lr5J>_W1jD*~g7q3jsy|?1v`&I73ijB1%SJlBeE%-*HyCN^r0)0Kz z&gjycp7Pkk2YvR+85DjS9Z936kFj}@hYagkn%rka{T`nqPiEQ!qwVvyI<b9q$vT6e1pUV-WX=kEL99mDen zX&2E??XfR~CN3_{XFePcqc9+*D3%WGO~@u&XHI68FZLm65xx5y&B671Z~m%!!%L85 z__rjlpg$;kiWBGseEBpW@$o#Xrg6i#@N9rz_SPsFoFfU;lY3_HaMU&ik3q{)-hyVj zM748f>KHhP5ml?)E{|1Qd$yy$!2u1nzcL%_bp22ig=4m$b9BOy-L&D>*S_}acYW?w zE6TTM-cZj65lCeapwbn#vbLl(cdy+fLMvVt%ia6@0MaOHqJ)-}vrX<0t)AFy{%-V; z``vN*^Y;1jEHm~5(K21HK%2}-#uR&RL+fBG z59h(cS6sbiqYWBr{Cp%0M!7_bp#A=oL!?x8*IHXnxz$q=nnhjG>3`MMh8 z`cCwij1PLPfBLIa-Ad9}g-H-egt!EvbhJ!W=|%^#+h#ifvHUSrpf$q(Zw zQ;D-$ZEj+aIu5*r0r2H4R*A?dUE=&Az@$p2=7Ru7FsSq)h%o z$4c~+d?N*9RM`4Rp4Fx^i$f`z;o!5wgG2=b^lAZu2up_{q!%?6L=92xIC?J86#al8 z-!}3pF`Wr7gbCoHYH+j5P8~j;u{-;tQ2f&r!$}}`n9{%UU%U?)y$Hyf^c5R2Cl_NqY>4y!G>?2B8s%o^`xhXTDW^~K8DUu}PVp%8k&5m%7jba#ThHXMMhzfoVev8aEsE zU)hXC>=dMSp`EQlM^W30be04n4H5V;V(6OQeV~%R_77LTbj4~bI^?Xh`hnRY|MD-< z6DVmKCNR(KT;kB(8{MFz32mUzQ9|?9XZPhzb9tI;{RtYuQx`nQdFCk-93`}(m1XR^ zQr3N5J$#}xOi?i!K2b(F?tvA|bPzR&LJ#cHwDk2QtP=TdzEV5xJg4+2(AnJ^k=L01 z>ZMJEcB`D73MJ_GH4^oIQhK!m&2WdS?gVOf(Py0H8;J!EME>vMYwEh2)z>BgPW1l= zyD{rdNf)zu!xRRQq~z{?7&q-`H3yQdzLPp7S!mI3uTH3m^#e^)PiiFPVJiqy4Xxp+ zyg1f-hdxx1&7WmcR@A=e22RxChbJG z91?QfbP{dZ?*ZumH4bi^{%VUUoC)|E7ntzQ!buvZ0L(X&=CDCienWgNgi_uT8{;R7 z##rR^*Y8;L$Q!#tHACX;R*lbXv+633jIbKtm>QS&>7$nO-iMxmV;^3XC?L z^t`d?uI!A&-giN8y+s94>xV{dJOoZDrxb^Ohs|-A02~Pwgl0jOxS1lHP^XBem6IpI=(kH zBiO#-U)ku^#F~DV;CoxTq-{uadmPnR>45%6Qd;uy*;ho%I1Ivuu?I0m0f^eN)5Bj> z+w;O1*to~*PHjfi2f=n?4FK^CwojI8J|Mjejeqvu3l)Z+h*GU;O-XJ%$3MJ#lX&?I z)d2|@j$>z(hEyjfeC6o2(iA*neJPP3ahbEpea5+m5HcUt4=qsNyenXb1N?q38u?Ld z%~J}8(*XsLaaa^GKp5o$TlW&YM>uQ5Kvz zB+!!QgXS03Sj!@)!(#~d$PaLKcePt3zV~0SIfE-gO$Q2w+x&l+^YDA0wLmXxn|Q zhjU|gi6hT*&!8FykIbx!wddI^Um#eO?=EYru_Zf^xto$|ea=c?JV}86wKn>;t`yN{ zA9{UGYUM`c+BI!u;lPm$O)^ z=`RLTnvyDxbsJJZ+l^qiw$;^Xno0Jft+`j9La4kybK64(I$XDwlMo0jfJ+^Br z+}519O|?(M4yo>-rbQ+SeKDUWBbDGH*j!^uReYKQ{AZ4@ZPEQ-p^s~uF-KFeo=eB_|c+Au!0tSjMl;h^YtN9Jt*T<%k?|#O6X3Y~4^~ z))iVIY(sOSS^PF05-DTfYbzi;BA3HBLT`saH610Z7oAlUS&zhT_6J>MmCFWcAE&;# zwEhj??BZ5eC+9p${AJe$cVJuf~X+{0j*ltLJ^QK16vK}-OP9XIv@0> zFd=%`-rAKfr0)+kQjb%$FygRU1=e=$T7B=xD9;1XjvtACFOI|JwB^}tj~1{cn{Ky~ z{b)J`k!2`-ep`Cv?`x(utR9&Vl;2KVS!U0$6kk>2$i!s_vc1ucbFqo#TbFYX?#i8g zeYiS2)c=_P*|`RJ$fR*=JG09m$G1*i@z~PjGoV*vo%q6OGswq+X1aAe6{oYXmbwS+ zr{0kV%FF)PDU2lh=!LCQUM=y~Z4T9ZDyC(yytKYKy}H}?0ksT}3$>XVS@e0e7~0UX zeyH@?qwTs$W6aNAc%Cixk#ioQR;)l^gwC2~!dn4t*i|1yC9kx$c2{6&-|D z&2Ty11@0Zq!?#IOaHOf0S7Cw8Ffg3}2RHOHY)uz6v>=p2)E6{d`ozqSpOCP~wh81m zXhVx0px_GF-H5rcJS017b_*zIB$2~YTxC_*JenAxMVD3xzg2j`FGy9-N#va|4Bp|9 z28DuCjzV9&t>F|gcB{E->_hS%;FD4{hPR=9#+BS~%ZQo)l`3etW=B?1%eMCIUd$ND zkJiHuFd|OUv^$hB&!}`)XN@`s11??%vsVyRI6$J3y0QS^8BrMGeFAUo@VTXjAtk=k z>xJuhKA|GNsx_JV;^$|aD%I~+!`NI#->)~vJpd?!0tk`njRDd>XmWNb?^IPaBJNB zQMVrID$mQ_G1Dp=IVT28SN1To{#g2vJBSSdJJs1%#eI*QeiZ4$HS3NSxG84S#lt{i zD@$KByJzXnYq(Ye=Pcbh5NKULv}pHCV6kO?9V42@;M)RYgQ(;_y&eQMw9?8s(SB-b zT6{DQ)-+V+lum}ZIa`W`e}m=!D9R zv;}>icCT$!KPj|jO_Zup3&IX$^nyyfkTQ)^}DcI8uP%%Z@ zn(M&tI2Y#L6jI9o#;IElpyfDIFyCL??zPqbVCtjUKW1A3YpN0k;jwV0* zn7`Wh6e!D!+(>Wudg|+Uv`zmtg4ZI^nr4SfYN);$n`WnYog?UCB{R-%Z0>&A8@kkS zW*NOrGJ?1fr!t2O`6BwRz7JQkB+LS{_jobSN9AcmT}4aFHUe);Y|8jHM)9zbcv)G= zIEYY6o?iaWUpI$Q=GND43|4`qK?}PMEPZt^hZ-;w;-JVhQb)>!f?VL#agyg)X_|z` zj5pe)n2Wt>D-(9Ab+=l8--7T>D;o5VDT$pDA*tOnD}H~%d9PM&_>?0g%KrC5xXK-saMCox4nppO+7%mi>B;0{71lrrm`tz2jnLVOy-;3hQaf51S zNlwWK)}lA5grf8hQGvB#)v73eg}8UlC#NkSnB+qcyzc`POC}av09Mdj7dB1^kBNvLs+-^ke~S$L0W8S z&e{>v6x;UZ9dpZoxH5aTTLD%p=>W98$3@$H`-mD{TA?(IcE9_K9i!{dk_F%cM093* zJm2;B2IWaEol19lDBT47+|prjI%ZXDg_P}{KvDMcsFUd(iI-#g?djLG``A9caosSa z+h9b*2aIvlK6}z#hiwjLvd;z&9R0WB-tS&Y`R@08@MkT5R_pa!mi6792iJ;*`l4^r zNaa>Dwq$)@o`jq|5FM*EH|R&>cgGn%&dGH5#&z`zZ|p?v0WBPi6>iR0h*6t|^J^C4 zsLcbL$lE<>LfL;{jD`o71jS31qiLKwxsosk_Q`!#@Zo@0`KsD(yeoO(C2}^phadje z2m6YnjfbPCjP!e<-RW6n+((adS5)0Ko?fZ|`rgtNWKr2A6Dd)~a8^p620-cV{ZZw% zmOn-%{r>40z0s?D56qaeXI3bF|Kqc3?kh9=wRR!`GMtB*MOQ^$zRvK0vl>8GkD|XK zRP*nOXRB@t{&B73o5F%nI>?m~-uNTAE8KH9eh>P^C{Na!^z^N9 znE9#2CZv&~pN~ENp>rg|R}dsi13q2Eedq$q*-A^|T)bG7L~5?#Ek!AQP~cFtXrPYe z9h)y#5u)X>4bg~%%hUv>c6rG-Ti@+~6pOj%g7@@fwdnnz{tOs~Q8^<1nVGRsE9Ha+ zPvp4=8hZ;ae})QJIATaNSMNm5i5-%a#6SmESh4GLt<8%O4*tdp;o_E>3K0mn?f^er zbpCCL?hTZ%wnn^ym@eo^JNrtB9AqIn+yc-7Ie63{FMcm~n5hbY&)ZvkH@_GGv>Eux z9vs`Lu>^q`f*nVMPu-_g4Eh^`q?jJU4A+@wyW+Y!OGTM7?lKDQDL+n0^m`~wJ$jZ> z2XKi9hPDG0CWZRw+<&J3rD`xhqU~U0pZ`q1B=O|bvfA&=jB@e)?1lTRA;hn?0(&Km zV9MmrFU5@R8*hhy!LaJpf~4`vc@0t3ZycT#V2R6?=l0s-Yim7rU;G?Td}F{Ool$#d z#dohQ^!uekXEh+kslMc58OJmjw8Aql@bl90HO;Ys+UoSCE1M8rlqw@5Ki1wQ?W zj`#5;F?s-Lk?ykH8J2Auyw&prwi(U{R30KcbYAO*rKSsK;T8Py%+bh!`%(Mpn!W^I z7X-c6wK6=wPNTODp+@KKm*&}BL&1Kjws;A;>)P)hLLbt6)*;PRpUu)BVlDY$aVGy1 z3Qq0t@uT>|8e?5vGKL_;1!T@agrf{rK>$N|U2C|gq+3{*-S<_z1iFA;HteQb=kIV1 z;BCzuPWw46a?XN4QoGL9%?aao zZ`4wmCWi!hj zqD?_%H0y`#=exx>=rNC9mw_dUqrJ5QISud%GhNd|r~Ah&_ViC`T>sYi%t;IWkP_Wj z8N=LjfApAUUTeeZ?0xjM#M|kkN)N!B+p(}Tjel$k5zE_Vg(-fd3`igbd^TbjmFSLv zm1!DEXIkeQ5{&amaCbzZr)Ar}BP+$$pjB5D7>bOhK+0`xxXI7 z{nLipJbTV*hFTL=OAAoy5Hmg?q!77$)(}o5fkZuo zJZpse9d10EcjG4rm<`tbFVYqXXLg*%3DUvUR26((ubawqcwBG$R9T=BD1O+~_EoCi z;uz7J8*;81#Jh>eXs>J-WlDGsnuBSfYBAkD@7U&et~GMyYwy|x{;wX~ zN!;X6_v$eam!&+F?`T58lCmOytSTlke|bLy8aoU#So!U+g28;=vWTyl{I^ z*C8y*B-P>=hRFK>V8rtTN>l+y=RfGkENV_YI?2^ljwUJS9ap50z=+m-;g;wbF~lu) z5|)?=JzGIFp&DMiEN9>mI~rEUcL_=|6`B5v6*5l0>dNw8K2}iUii~an_J3qsae8VK z=t)W?i>+5{aS+@FUYJ~%&IG5$tWl?NHh4`fv(6UW^KQ;F35k{IBDPIEcE585iYrsc zG#CE&*w<$z9X-6jV&CumC$3DT?yWjhyK7`z?$!Ji=UEZ|sOXVx0yi>e#n1PZjE;`n zK3A38-XLw}S}!1CCSI2E_`aGo$iUCySrN|}b?<1tR-SB1#W}WdM271-9EjT#MWp$x zxzsFh1;#4gNKlHP*mF+WX_ce>?sM_?J>wTW$q)s}nVhTUx|L|K!!80D@>oN3+y@rN zZp7H|`eR?;aIj%0W9Tlh+nKBHPPW@ZNt}~C<&_(c|Mu&XrixYLr z&a?1URTG6d0~9}E1ymBgN={K~qk~1e#{`7Ay*6p_CMsd9%wM(MrORpPYlhHCc>|CE z8d!1jzpIBAomoBFZ>*dcKj5XHv7g`O#E>dK0jBn`?4^Uu9pa%yr|-Fv z1wjXr{sR_*Yv!o~!_3t>{J!dI_xO5Fc^px;7>NX2C@xBJZd|nwWE2>5Ir?{3W|rSc z_>boLq@dq%$`j2jTkDsMj!_{Ye~AD9u;GCvvS{1~Q|IiZkyLrYlDEDHBh?0ar#;9} zbtGOG$ue@h5%cBB0Z_R;^b5KvvEXMC@nVmOVG)GEaL(v>yF=cR%$_L3vKrFo07O~w zb2v#YrIWuJ%O=4>ZNloM!-ca&^paOHX_o1I%rK9|&Ib=4JT~`{|4^_jPvRAZ>w4#r z5m?_=%^iEeAG7F%HI;8no)g=h*jzV5W26KXHg_lTz`LS%#@W_yB}Ei`u&LW zqt1rl8hah^b8=#P3+zMYdg|m#-!E_-?r|lU3L6DUbK@Up99QR*jY+ZFXwEf>UY&{XlqI! zk+CkDQWD8j3X%5#tLVpHA_21T9Zw-!m^Ams78M&e-VG2zdv*ECAP*@?%G%I~qU#?& zAhxf{j15?9A5@JP%kNR2Eu=?(5`NH<8Il{(fL}yTKHMf{6#{Z}z@{k-yiT6c+)y){ zCT3|KkV2iD?J_3Qk{V!JfcmwN-6P;MX(i(e#+ruol_(qeW=xF^$2M)aMV$g!PJgG< zpa0&sKgKOGM$j1mnMPVX!hpRF$}_BT*(^x%7e;lIz*80ZW(NemJx#1fqV0T%8@~{l zT<-)n^?!X>=(B0Zhrs9U+I5_+dm;mP^-)?;f-$V0Lq=KCeA-}029r{%<_mTPym^7W zAGLEb7E5~K>^y3m(v$1zpXZ*yjxO8zw|_=QfV0Wo#)QU0U-W+R$x_Th=Elg9PU@P? zFG!*^nIV!z0_9tG)WsX-aNJnWXnW(l-COvajm~)e+G?|tUmgBeQXKAc+eSV&`JNR|boTxEU5OF&7RXXksw3b2xG3V13+?92q0Y}; zPht|VuW`}FT_ab<`{&2Rh5jq$+=o#K1;eP9$F${aeJ4N{VXI z;u`{y&P6*7L+@Z|TC;2Wd14a8bLX3M4L81*ckNr-CE!mz&A|r}Ng$2foz;^YWvfMG zb>5#hUwZ25XOo_@oYLZwqycA=oc--t)CS340`r6H2yh}tWR{fggq9B9(O2n2(!GX} zS~9{N!wZvK3(N-CYhSmg(xMPhu!scg?h3*zwAEM=*Tzy8eP!(3i?k&V*a17mdsH)ceR@vf^ z!*hB=l4%nkjA5|TAx&aA3=@*7SM+_#bLh;rIo_kfVoGr-LC(Hv<)_(jP}ZK6)4y-4 z!=1zszUi#6?&Ixxq4#Hm*4s?i z1AO-mw&3apWdW?3IRV%Jf!Z&50_}SjK2)8M@0iMT2-LLfUl&i=c}{E1bj8Ri3}zi- z`N)}j+}qRlwKZ$3HvNv6OV9VFy;^tviQ*4}zQ6~IW&l_|B#YFuKpetJRLxj#mM2&E zE7C$iGttW{O|dE$L;HPT!Hq5Cpn-tM<=;JvTFNGXVSq%rH>gXO;|8r8M-|YiOS-^N zho%o&+l;eeFYaLmD`W>#=|7*ZtU`r$O%*L84xUwxJewu!8#{EdYee^!68!+8|E2~p zLHk%FpZ||{IRWC+<6bIM(;OGBTzEz6E}4{xD#o@O6_db$e~c%7#}7Q&YLkp0=k=+} zGhtLd#6ObINC|zP^f;}S>x`OYi!83tqDOp2|AA12A+#=?U~e26c`4IS+6w2BI}2-3 zU@*`oT6VbxjtJ{5iGN{I5~Nwvw<;y6iEU8)Q+($85Wf*W4cB^J zB=pBsDb-VW8@5qbaRTTkg`>ni7`M?A!qd;rGJB5vY^9!*L>|f@%k?4kX3tU^Y??jC zC@XxQ2STC9+Vn*J?dZy^#*QGvA-2L}+6!2%;aGlM z*_u*Q)v+Kn)yE#8R94Z#oxqcm?E}&lOhcK9-jWJ=58-0@*094AIgr&?iR#=xe4i%_ zjJ$dx2MxNx%TgOW@!Qd&BxzL_j~-#9S&aIWHXGn3(Hf!3HIAS(sEE<~C8=1*>I)?= z2RF2xH`i7)F}?@ZkJWZ^^<@Si)`gK`pb7RA13Q{x>&jDcRMV0o>c&?RZKrQ`xn02I z2p4+RrJz> z5Z%Yy0tGM)Bz)S7y{+p}(9dxV8wPJ-#q$X3PJ&&AUOm#e;h&VLbfr=~__5pl)ICS) zXFWzV*WuBTVO#PA)|_8xvoJb6JE}Cr@0$;4(*I{*60|DQPWNYeZm#9>5{n|E8iSd3 z$4dBrSFgiUtaa8%$Yo_#0RK^;K&`W^c5;uq>s{og2uBwHM~Z#=uPH z!3bP~VD_@b_*1YD!CDhcy=*JsiQYuvOznCa9mT)=VJLyBv6&%v{mKI?_fCo|^57=0 z^XZI~_9_=rGx$9om^`Fz2pxv`IF!3gIn;+RZP2K?!MbmJddLW==&u|g?1}z43?{=1GJ0JD;6);R*h=UsjC}e2%ZEUu6(SV z?G`ub>XLgsDurn6lOv>y0Tg3?TzHZKM*0gjMj49mHwXTtz}v%rfW~4`CICRkP7&B_ zDArvQ<>CJ+D{H=Ta~x=Hp?q+v)c&JOr?7bs=%fkt#{Aau-F#=EYi0MqFBPQ-%=HN< zzE0Pf(a4VRx|*obIh&Z7PIbif;<Dwg-TWBx!O!q--6vR9Z+&qOV|<{rQ+Hc*k446 z%gCx1TJtXUcBX`8$5?}%FDK|R$2Mf9t;zyc@l-&b!xDyJ*~jxZ07YuAqDOK?THE0-zA=RpSH2 zp32cx&>XhU^_*Lq#Z6$Wvb?ATq`rfF$47k52D|_3lPc%U7tXdhtpJWDJI+ksFt+q6 zBnZ%mQQJ$e`mtMi71>KZ1z!v4Ca#W?qd^q3yZ(v&x9} zY&ZSA9`(RNE;NfP8%|u=d`adgL_@M-IE5+5+`PkdaFU0)zN04B%Ca{+*ht(e>Khf) z!_gPP0F^2`Ww&tuKkRmGu?3XV;#kBZjg?YHB|W!Bn+Lm0b+UvYn&QJZ6LkLrPQI>zYGP zWoAaricVAluNsvLfuM)}nIt6FF@rljA2z*E+xrt(YQtwHVJj8Wmsd!~fTRk6QQ&#c z1U#qWdVFM7g3?zZ;-MI@=z;=mO(u!+o2f&uxQZlA1?1bYVHmlW#nT4=5AXOtxfC=W z4Vhy0C@vFL;1KNc8Ygknigsq(Ie)}_tqKWnRY|J3)II9^8B>QRh_Jz*GIJrqKU>%+ zO4ezoco=fHyk-sI$&Y4FoIk+)U3tq+r4AJAh(0f3VW2bWQwx8aJ()4_l--MVw!~kg zH3n#y=}0?+&kr3;w4XBA^xO(Ge5{Hz3hbxs3bH0b^OT?Xakf^Htx&A5=|Jbh$JzxY zdMH_izH&(0dP6ftAC0r$HK)mylgyF&`&-vG`^WYs7C!!8f4R3OXX?YRm(AJx-hn9p z_Ubs!W7>|4>Xntft~ml0tT~yn7r*@SOHcH9>y1%!8~{geeRZbT7dMne*5HJF3?8G2 zjkuZSymd4;-+!-S<o|Olf2I=Chpia$qaV(>z2u@da%y>ulATSo!#@^RX4X zkeB3f$BT-$-QuuBI5TTnW_dEQN~xE7^|LOe7x^Yyn=Gjmb(SIpFF9vxu-Zz&L&pVGsmm5b zv4w7U`kf0k+)`qtgz?n1A5{tN(zOtcfD}j=`Bg^u)wR~H!u(4K)^9+LLypTwIy|0a z>*`aKsyokiFZWUz%)Rk1zN-s;cD;N)$JHZJhO*|m;+n2xt=UAgLs^N4=U@=+NSl8t z={QK%RQyz3A&@ss){&d>di(n4si3yrbtTlZ=eCGp&qq{?>dR<3%0$nW+Wy7A-Ah0eu%xMEf||s)`m&}PtZz;DQUC^d~x%r5js57p+o!& zf|d&vVyb`)@tQmeZl+X~a3U-WElF{9>TKyry!2(s!MDCzIDQyR9}-50DC&u}^UG7t zN3GdZBkjAOW2IFIfxj>`dmdH!7N-}CJqR4Ps?8`|I5QRgzwD$veR|QxMZ-Uxw3js6 zvGm_g4}P0_6iqyH97dc|n zqH+D#cg>C2SD$}AR0G!v$YEdnMaZQ9Il_L1|J9%$Xk1)#8{HpL229F&@SIx25YaoY-cz~J%F~6o`E$>DcCe^8& zJJ^MnmdbS!#{62^ELnM|;YtSu__bcEjz>#+ye*fz2YkQg?lVdU z4OnKV?tBW{%<(thW#$P_aj=>m2ZiL#Cn&7LvoiPs*uUOgSo(YcjH3)IqQDtk?JjA^ zk7;AEvMwPfe}UC&?|%FKr7q;*%B%IsDG%a%Drm#fvnI`J8vaMs9%=o*Al2fxM++1mnFp5-t($>U8L7f}qBAzIP=-24=hRArW zlS9q>W}!^fk$qt#lfOdC;pNjUPnK|F`W`jRf&${^4_GS)WxC+D8LbGvguWm_}U3VW5yx!m%ss|LhD8 z{bR9c*ta1||M2*<{@sg8SKUAcnuOGo9FC8Bul{CWx{e*vU{tXa6r}{`nX=I=W5X5# zhC_;tI^Y6IapaZndQ>Q~fiZ(YFnA8Xif-BXQ6j4JzxXIWrn7`T6=`!V1ez^ISOzAh z5<{E6tHHc{<$m{GPfc@6Z2XQp?kLKjI9FcNTl=&p=$$Rh&}a91e_UTe(zGr% zJv})!hGLR_!pe#DV`(YqeB>s-PjxZDCnVxP1z5&-j3=UeDQ&~Z4B_C(HWOdR06yGM zx(Gl7!ZV6_G^M*=>ImdrrLI|5aydp^qyB2;2H~7F4*w^br41~~(i`E>_S-KM;H~iZ zsYEch<->MtIx+tAKnyhvGk2r@vOYaGPb5+V`E6kHt?N(OGv|JDdtp?e2LW4JKW^;N zW-`$&zEoV+g5SLaMe)0j3n5plf*Lk3jd>+;Y3?_BL=T);}^;4K zaPTHtbeAbZ%GkN99bRa_y9eXMKJDMt{kDAVP)IKvYOkLv&oT?1S!2?&8b?}g$p6@; zDo8;CtmvQW3?9W zu!)>aY*%l_C6g*gdBcp^l?>%$FuE<8r}^om7t09J;WARuvFDt9@OZzy?poPs#EOz_ z_RM*vpJ~=hBwdS$CR|SPKAKNn=#;f-z9VP0WjLmK$7}#es+&4XHM^O|yzFtMi+ira zrExdu7r)7N&}B6=YL$?m0h7UAQRy{vM`~ww_Ks+Sz43bA=W?3Y2dPw^G4RpZ&?IbA z_qqt!W@OrYEtT(iRTfs@ORDgu@4WufIQb^L-T41(1eISnU|csN2{iCC9AyIGl?rY% zf#mmwzBtf>Y>#oVofL`*k&8K8fLtnHIGjdPQUm}D7w9?EyM=|1#dXly5;F^?0`vd1 zjH9eEMJxJDOuE`2m{z0#hGbG+f`e&?5AA=pM0v^T*h!ayS7FVBXT_XDfwrB+TvsetdQ@8yF0NFk&jRbUI<4Aq%yIbkSMf^OS`o;7 zp@TUp^75;jBOdg6MkQ4Hi(jvbfb@CL{|&p0T=iv`$f`9d%GkQ9;*WJ}Ms-!v?_R4J z9r#Jp=2aB}v!%Gxk=?qo#419oSU(WGFJFBU^sG1XgF&~=-+)8*+S$3m$xq^D@Wa#R z!6`4mSftUmAobCXt$&$pZMafh@)#LBq;_0Pd-hO56w4Wv8-qi9xjv+dU=Ha!+!PsAyR?5%)cOkDgksI}Ag;HW!o0GbYer@4f3LG@SHW*Za)M8#EYFx95O>fK+hE8zkRW3H&xPgifiaXZ4pJA^ zx-PgSt?i6Q@=4>x-U71-_Op-Y;4kK_Obh?Mq`-N z)N@T#uC-q8L-&>ce}DTBGY8smU^Fm}LYOh|Xe9jj)>rk#88~`0JX8|6FHs3}mi8p5 zCDt^Hd}*ixh9)FyXTC1sjwoRmK7KC#@-+6Y+O(;!WrmxttEA&o*dP3cGNvpU@l3;I zP*gM`1aGr05U8aD9!ih&^kf5dH z2Kt6F)3AR}U<^~Ul^fr#*1g(D=|Oh?zEDhWXz}acLKeV%CQ$^tGxPQ5YRmrV zrA8<6zc3AmY|L^XwskFf$e z?eMlwWzvvpKlVr3%$CxL({gfz)~b)eKpPSDqYLj@!N|>O>TpJTiQG0`-NblL6~4z* zV9fSSe$~*X^78d5u)V-xFs*;=gb(EHA7Dzma@N2PV+C>Nfx3VE<5$|n=T1(a?cp#b zk_%w!@D10u0ukSK&|_s;Tlx0=W|Td3)~MS?AIh3#;&4sZ7ZB+=Zq zT|Hu+B0kq1Zl~&K_YMN8&H;Ti?=>w_7s8=PF!h(yMEBPG$xanUr`2! z1i!x4D#(p;4ClJN(qMcrlT>Xn%8^=gWA_&}bNEb5yJJYTp z(}xBtIKiU_8KQcGVgbT6ttYy#R^@-~o!sMvG-kSjhETlLg#vvHvbGGTIg$;4)rkO( znadeYnF8Uu=dVO^XIQA&@?eY=6UBpzO15mC%C-VY&_6JqCf_$7Np~CyW=ES_DvwG! zXSOM7d^idpyPvu`-+`zT4;i!#Yi`;o`<~GBE!%uGo{q!I-qrL|(sD8g5`|GEkYWeL zMDyA4i}O(m5jisADr_GH+gSm-+`|lCv}AN0H8$)Ns|{ge3jMBPa3@8x7C3o}9vOA( zt#K*VsP;#lEvNtIqhTwTCBJ6$^1e6>=Z|%S0=dV1`{VC_J&5n{@aw{@eEgFK9(Z8X zT~F@n23G3vN~14xNDd*_hA}5=C9JB6i{hK}z$3cbOwtu~Da|A5EP0}Y2f$?XQc7<*ajQ7e1qly)%z5HKca` zr(3@emLC!Af7z|5KsH_T0RU2svC-ov2JzJy2`u^sIu49X!(3CbXLhFo)+wy2O|1W6 zH)Ml@--O^O3?cn_!Y0pNbW!znid|Y2qejyU)I}0Am2<*?6>7E~p~AJVe&y~)6_mtn zY6}`yop?io`B(rLvBhAd4%tMChlWtg4{}j}J5~4tFPWY((Xg!FgN24nnDV zM;|>5JPBW^(^eZ_Hz-8Zq`)-%`>w)@Bxo}a=GwakZX=x&npx+mg}*O?t9RXP&GyhLtAbq^U~6n|0y*!9zS3F(;M5NcosD z?jMEBh}Bk=BfD&4#3*tqPiEcFVV;`${6I|ylJ?wQD7O#iy4~B|#n`v{;@tLKvB8it zdLdR=R?+C_!BmJtJXH>N)cGhyLP(dO5^fKPThIUGjVYL&$XhAsGzTB*!0jm+Rp{0 zY5m^%6W#JoWU?uG`ih&WsCsDQX3UzIU%zy!wEU23;J(yJBl~WQaP_=&7(>4mi>ID? zyX2c22zQuj_u6w(!i5^Qrnzx=+UY4HGOVig!(Q`5SK8m73z&T|>1F4x_KbaPR#9a< z{X|o(|4d@mr0u8W8CY{F%69p}l}norud^bqUZ~l{N3^+m3b9Tu?Cu|~b@$9$NTV|2 zu?~r((N|Z>y$`+-s!8-)-ZmBP`LXmicAHQJOjp48PUc@Agnh9TOr1kU6ld?YiXe2>ex4Hvm;iw@FPese|VwmuzcQ#x=`w+fa zC7zEhd#2S*Et{J;O?6lXcpylAQC#bqcq=llwqR+*yxY3`pAZnh1O|tI+ugX-t#Wjg zr3R4t-i5U&CqQi~L78-vU=SYSvpEoZ3lBMIc(53}y2O3;$aekoXn)My_c9v-$tk?| zLQhr7cwg?l98nNCTG8~Vi~D4J@3$wbw^=h&7k5wD*BdND*8@3 zP-(gTdn3~J54}gG=zVztOoGe<-6K?C_Kf4pBZl;4xWP zoF{_rgmop*g?KUKRm1wFK_AqLd=5DFqg8G21&063vNwQ~bB4Q5MSwh9jcLBtaO2~E zkX|fg#_}YVjA8fX?O9*nUAUT+Vs{sG(J>^^26t%XY;5t;x3;T=^a?Nx@#!NfTTT@? zQ)*7#*iy0kTyXs`6uQW#Byd2=>7fL(^GWPge0$$)8w}+PzjwUPcC~7J%er7kR9@2PE$RYU4iZ&BBsFDk z)fJ+-ML3tikfS~FeD`bxo&GY*b?MTy1wp4HDzoQVi$W7--&TZQOUqGx4b?jwie6~R zHe}kGuB90luW(%9RU5K=lwbNYa|mO)ov5i%79Qj*nKDXcixOSh#?x;<13;l0i3rX3 z-J}|c*O*d-R>O+iq4!FyA#M*ziBmt>TuAVjmf2294as}Hon9TSI(GE~hgNGVBB;>b=J=Ah;higGD2s& zSTpk*KOx^MEpU$phHIik;99c6Q*}x7BYF~k&w&(p*QIg2vCy|h%hvLG4@>UjG;in6 zo9Lzw221KHEU$I{cP5iC6B3+E0t7iBtc08BVs^pHyA`HwCoaMq(nnw z)nX|67b6Yr-<~Q>_g0Pw=XXED-q+Quf+jQX`+TgAd)@0^=oC&XLej_Jm?RVfm72f; zL5{fA#zlb`~D;|U*QN?m~150nDxFkz^(3^O4=k%+TTjqIq{ZVOgUF(QM^bU4EY zYCN)fboS29n#Ey99=voOcf#wc3rj z3`Gujexam?@-N&r$Pqp_Bb|#v&cVsiQ10!X4UeyDQRhO=5K!kol!Mbf;C1~gMJ{@$ zc}Nto_4*-JZyQ#P!%g=$a|6dkrR9`di-5;Xqw7?hQw4o)hr%xk><@l>^0lWJzXllX-F(;MyQquboimP3#8YOFQ6`^mc?k1>9 zdGl289KxoZpxk3qMoupL_&uY#PE9mJ8VEv+gF7+rgU{~z62gWQ*N>ex*_VQ5({GVY zJo#mlAmTbj6i;8OG|+aOfBvJZa(DmX-WSe$-TUK_t76pPTDpwJ6x^Wz4PKCl-n)Nf zL|U8}y~g$g&TRjK@47kflq(Q`)q(o>m*=+%7?tVTpTc-NdxwHjP7{WWlxUo?x%H>; z3fYT-z9T4QtLXj$qFagk87+~nPzZx;<^t4xU1Xc*pUnI3*zlO>FZe^Z-aTM*g)*>ARz<- zbui;#2tE%nXGDeQ5ZT=kxM z<%ZW^eStAF2*VR8Qgd0PX}ppZ(O?rZ82f`CGYTid>=w52|1aFVof~^MTapD}ZeS)^ zc2mp(=`;e;6MB$fU=@rS8#XPcC~q@;LL6q=F6x|`<|!CsDcymRqJ+iP#KaO(b*Te% zgtbOc8;oVEo4_AY*_AUU(k0zh-KvkG=MQstr^DJcE(_N8XaDk=!dvU&>(97DJx7|~ zZi5nVvxU=6%of!dG^f+hPAaSfj3=_>{>tr2Ey|`617I>RWuR@Xr$9dG!AqCq1lz8_ z%Q!U_{MU!Z`rxxenAX%TkspfM_TIVZUR_~T?s%f3KT35k!V~yW&8~#C<_;~nulSWV z^@A>G=$ekDtt9SM*h{9|T@qMq&E7)6<6$%c*FEd_&~tImzx=prYt}54uYIAr7z2?( z%_oUZ@lHuBs+p4&3FIW%GYU{&lejVk!VY)A2u1_uMk1m0ElH|0HLrQiaxdxwW8yxK z;q=p9d~RwB;@%g^x0r;KXej@2p!sN}l#78-YMF)a*kOqdqm{5A=N&8b#FwT`OxQWP zCVwsJvqb0M!;Q^9{_Zi?%)(1q{N37bTYu`j!Se-+Sz|3fa|PmEaIm_*Sx}Ea0$%aP ze{j0Jn{MB-+BR?FGNn)|92N+_*NhGb!fvl)OG8NZ+qt3Eb`hz? zA-iH@6Y5WN8U?FAKkh=u(C`1Go3>hEL4^+Ad}mQx=y6|tfW}&=I2GQ8npNe=aS6e_ zmp5ftC|jy)XtyRVtxdgHlTQbR3i#FV+zPO>`KD6$^oPBc zirs6Hdht))OG~qRSKENL*NrX;=Ix@IEBR5<^1RL6t2`F$RABcwsy801{>qAVUvw_M z{>!$WnA+IDRz}zv@;>6B1n?D&BYV`zWLg8%y@`hfL_}RLo#hI=F}*e=)LwdivbTi5 z=M~F4{E<25Kbu(|K)rCEw=-l7jR6ZCd!m2<|3JWQgB^7}mPtLH2~*;%O2)CGrbm4Z zC>&eRx_jaAp12qW{kq(Zo4l{AYatsN3_S5h9KmqUk<=It4U@W|KL*nOzJ`IEWn`JA zXUQFFy>w!t;Nf?ctX#RW`p{<^_i|DfAN>B9G5;QMAcO2!yD(or zJ~Zv<4e43c$eaU7)XK4Am~=FP5~?`uXD-e7T5c{pcCR&XWE6BIn%lw%1EyS}JWfeo z86|S@rNlZk<+wu(Lc&v~PmBo-wbK3RX)jdPkO@BC+#|M?Shs!-0> z`69Gp`_4QD2hmDgnYO<6p?#9R9=Gd(*p{LgOa`=WI;qWJJt}N6pKs1mh(uqff*TI@5VnU z!&m3Bayfx4Mwv$#y$W1VX8iRN@OL7rki-#=5zD*@pQ{dugtYRpRk<_>&!=)&&eV&)DEsU+=PMGwelFI zh=qfX!h%@n_h%SXRlb|&P_zI^jJN~?T<`KqP>)Fm z{GNImipGJCuGqbms=|Et1EyTCh4HAQ6I5WgTwMh~Axj z*0-pI)!^!jPR^sae{x>&vgw2S1i~p&SNBnY2b!Fj9|V<-B0cC)DzB<@5wt^|`?{zz z-9npa5H2ubN zyv>BJ;c?zKsR=W8uW0&LpRZ2q+7KbXTDm%HaXytq?Og0C&R*;j78k==ApqE}|8Lz* zW8O_ok$iK5d-CXQoAbZ;y!7hF6Hkbl(7%=0DVh&Ypt#QOvpH*G8|T4oLhgP>TYjju zi9H(5=p1zkkVcZJ$h&pek?7DE7fjjvBvlM76Vh-ntg( zBm*;4WjCDKw@Rq3)nAFs&@n1VB1g17TMOMs^8pOmNB6zbL>jPpl=8b=wzec}K4v}A zvappf8)VI3Ku>XTRNjfyyhnmlbM_U95A5Bk2uNVhul!RHA(&TO`fMf{;W!8~L9RUK z7#hLLW)2iL;NV@%c%e*eM9&NeL|p0B*{|-}JX|yyQ}r}w0h31kli`;l9r60n<$%So z+J1T{XAg5`B?;~n&Ves5)F=D_MVFXRE5mo04OCA)jg2fSQ979l$oc5d85!H`eB z2|1b459l#RL*fa&Bf_eh@#ULJCsvAhss{J5uH84+`zx>UbQL$o0bm2CJn^ZySX^xF zJ(-fC6mB<4VmO@mll&nuh@?_#2vW z6q0EFg_(9$mRX71IP37e)be#sD;B}>=e!XwtytPMv{u2RrX!HexHYps5h(8~#QqvO#4(MXG*2<%2gaC{=I!Dsqw zi`PHcJn|QGxhW@5YG~Xl&ceF7bf-6+O0^l2M@Wue#Ti^<OIhf(bt@3>;KhpG32{@oUCj|RV zLCn%j3~~8j3ECmigAR@SDVS5tL?qgMjtp@xyLh&wfI5NZfueh&k@PzkfNykUCloqp zD6+3C|MZmxf1?wIJvv67#vqg_b8I*LR}i&M$+z#oS|#u+n(^3-M?+ z_mJ$g6XXW>h`V9`=sQsh-SRhbgV+DJyre;duH9zRbRf3fH_tJ6WvJnNP~=8+(9npm zt_7!0J%b)C-4q*|Wbh4)$~@YpuFWI)TD26PJM}Dwh!Ik%@u3GL**?`(&@*5eO-D=l z%DeqZv29^BtMN0+3b<_!&&?6ULq4N{tCZ2eAW(k`S#?F<{HV&dP?-r$*??y~(8 zVv9)LzH_1^E+3h~r2Gd&56b;P%Ic#p?(DqW#h-YM(X~Bo-V{8lJ)HgfIL^k^>t{o0 zL;dJv*{nD_&G23dUqIzsFV`mblAWQRP{1}Ssk6!*bweUk0Mt{*0zI=4$m5lDsYulC3GB+D~*Y@L`sW?v(h^8I>1xvpV=U2*~Wq#5O)bhgCr~(kn($+WQoJblN z!?tm+#HNWMDy*H%qTu{YrhjOc295atb~%1fU_Q^aY9JQ)idRji$kdzu=3vISMRaO+ z9pSDYFQ9oxr5B{hPS!PE88;^HrAsq1Zc7e> znnxBDod8$(NlQZi1w3VpRlD)_;($u=XbjX$A$|xWAXb#XjKTgE=5wHDvSUIOG7M{q zfrP-zlu954+taB>Dip5~{d7KA~@5>zP%< za*}^De`_ROaWGJ%>yVzULR}t`gsL^=~GYhi#De7t%SM z-JkyMDFQyxRI=Y_U%|h)P=03Gp@!`XjNZ}VC5J}+E{PA+h{9_>{r&HMKP)XR%_^Du z$iXba=;HB8V~4upY(8C75ND&!Mreb zRZ%GJ6Z7z4ufimP%E0Q^mc80?ri=WdGk5=I>Rwn7pH#V^FHt(q!@VHK~!3Y3>LI3Wc}j1NZ~PD3k<1(6G6yuKjfG2S3ic2Nxm$QEfP8*I>Mi0K>%> z^J)g+#Pl=sOWb3^iN=SUDH2Q*8-5+=dwF^JJ3pRkqG6gj_Z_m7R&%FX;v}XtCwZ%I zcOL)_yl3Y5+Hpxx@7Gq?1F)fk`~E@j!qcebMZv%2cg9+A{stkyUr-O6qxc%ScTUm~W7Pqp=8=0vx3{`M!Mp^)6?C8wv zh+|9Lr4zFpXvxS`DB6nlm~)9Nf_UPhg(sFT8v3(ke@MuP-}Rug`9N3h{vY)nxNGeC z2Uq)M&L<~Hs(d#q(Vr^^d2C7%Fh|yk)DMW=zI^*U5JY+Xmr9mK1(PDdLS#J@vKW(gUQ7W~PV1=mfkv(c$>M8YT{fQXt*q8;G?BCtdygC|rm zNQUlKz;sx=&ZOZNQ)>L6I&!-Ef21kn)*~s;0@;0066fBf^hnGN9b=x+E96^c4n`6N zh{e07F^gV?%5fP0a!B?j`mT`o+9moj{CA~HiG zxOnm}>M2CHjlUYspJHqo;ja}{nY1>ev=#10g@2hpN3AnfQ5)ZGK$a(BNU3pMTvl!m zHfcR_JyPHtZ!sXu#-lZ!oo1n7UzE<+d2m$bLwnQhTU@21nuEF{;(uww5Ly?T0)=Q zyMehQf1Ay{JGxj-a3F_Nw$Ll7JAAP^L-1!dI*-Nf9TMAX_*) z9e`l8WYV1OZ&ZgIyhn~1=Kv66k{E2a{)Emer-ct3>7RPImcG%Z!oo`q{LKh!pA_8! zBD+B}^fIACZG9;S{I4}s31-7-uI&+YtmDKD_DxOdzh|o|?>f*VudJ!TaH72O>ucaE zk+=?^d`9g@6mQK~mQ_}7d=20_vF^GSAZS1z;&*JLb(a2bwA4W29J&L-=n+Q}c?zth!7}}9x#=U4zYFy1)!cJvYTwD?BOl~Q|pl8H^ za&Rt9Q@rJ0Un{%J6kCK}3371<_+k@K81@Dq!z}nsnb1gLD>W;RGmuz>x9Dt+TS$?N zKME9MJVD@3&WD*;;;nqH?C}SKp-<1Ox~nGPnXGtDoi)?ZeEG>n(rh=yK$6~0r&hca zYQk5~!>!bF5cKkVL${yiT+wz*8pm|nfXB~9ZzkMo+LGNnkh0ZVKpe+)ru0$(@ z<5f`QfLJhR^}cClJIkwkzR79YT+|RLoZ5HNi6Z1e#5tG>dAk1^9$7IDx`&{Oz&DN% z;z*My9_KMYm3SHvm#QKk(F%JfG7Bw)QrkM_S~MhN&$>Reae|S(+&FAJ13GwB%pjA|ipUk)E*o9(&sW?{45I(S z-P2|mnEu#d2ZWnqm#A7mgyz5De1XW?YaLvHu5UUK5cngv|H|Zz-tT~O$Qe}uecw|> zYTvy1sls4ETy`XHNXBht!;xO6ejYtoI5Uhu3sPKKD*N6G*4cp^1L8DB5>j6Yr8R^r zI|orq>6{j6Q2)HrSaztwx*U*g5Cj+?p*;42GyK-(Z1ZS#sjKi}M|Oy7ZjhpKW`!tR z2$Q&T>ElrH`!*wXg(?g|kdozHF25YK_ZTX}N{ts)sK5FjuSP}70VA3=%QUE9*kjnjNic|SgY9%RGD@EXbr4oaaoxar?_ znZgMJ6QdOqqlitBh$^+bG&EqVrcl=&%f_S~nJ76s%@LmrxaN=|8-U7u)?Y)snRT!0 zF75_8K;QUp%;Zckv|^BVk?_Qwji}KACtDb4p&tAYP>9GwtQs)}c{iW{FVY3)pNp|C zkQstThJ=9n!WficzMC7tP;E{KIm-M%;ktWBWmo_kuWQ&|QImy@0m??X|OjCriI%++j^%IPy)c+h!6G{nJqtr+% z^RZXNm5QlNC(~%zcw=YyH00{PkBoiTMWfyuNS8|^njRsWpI%6B!1HogkzCf0tTp#JLzmp06%J^VLYGc zUYZG0!BKa`-`X85wdrI%cru8$(6|vZVtw%Aahtr*%Wga{@lcS>q+4|pVk~Mm#z~GCyNav2IP`J-jI5@nWxdY1^5zOeA=C7>vwnSa8E8 zFLY9cRnX(IzJoX^B%OI7=j_QKm{IRY8=1R2kV^cCE(L_)L zt&B>vuuzn9gyeDu>(NJesg6SCZ1rrX#N}tT7dAL`e^{ekuAJm-=9&@kDs8=3Hdis~ zkwiv|u6-60haG7a4>Ey8qeRg<3q3e9KAFE5uF;Qvu`Ai@^jefk}2jF^tp(j9Dc6x$ECXrRR?(?KGEu3Wv+k${6D%(?Dl25tG71pQcGC}pbR!b&XEIEt2{NtONt;3E5h zN{@>swF{JM>khq<+b}z)@!_@Di#4A8mgTZihfa)!Rx%}xf!X$iW1B{pvo?Y8qvxcZ zjaWs`k?CK3FojDZ&*huia=`Vp72{VDU@{$}OCyVc%eG)-)L(h&Xk7S3(4tXWY;+p# z7#krea`;@^KLTZ|qWSL8dk;RnpzE7QD0nay&pKA`ZmEY<|JlFL0Cy0!66bxOn1-fBq9l^J35zNSnQ- z)I0Tr51ai07Ij%fSSczb2#i9Eyp={IrYa?`@I&||m?sC447&^RYTcpF{_^$hn&{PD ztB&5(IQ1gXS+99LC@=3%S;kE0-fkxAdIx_vcCZQqDwzm4D)(|L!MBu1_nhj;8!4ja zJyp1QL`Z(<6A7sdeYI=Jy)*6Zx{<+?Ay$rrklxY}g6CxAmm=*&-)Form+bi9%Aw=K zmrv1r;&I=0IVDSl8DG_*&w>oH5eidVcj+(dVgrTl*oiiG>>~$L>~Hg|Ql};=>KTq` z^d4vfHsS*Cz#>M7@xxr*AN^p6 zxdTilg;L4{6xl1f-BG1K`h5a6prcQxlPCxn`owV5|M;#mfEM2MN2hJ)dzNDdJ)l$= zSeh3ECtdw~h0WdrQkPi$f|pOIWp}MT^!i(Uu2foGsN6Af&Zy=HoC|`=DwjwqwU#8e zxRj_oRFL^^AK(9IY``+`kpV&JdV{J9Ds;N%SjF``u62RGSipQ5_ZnZ+G z_tI_)`*q2Lzt)3Bfr1?iSO^IZPTZfe`pC~2HQBzShauGOCO>idF-qlidq4kI&%*~_ z$li4nE$Q3d|MI)Z@bv6)yY6FQo?Ms#w~tUcvkAEyL-V8&dMBK|1Y zQGE{3)$ujTyyJu`M&T)CO1c0f7Amk|m>)S%uN+-Jnj%2}62fE|pK>jg$7^jh9#vIy0iBD&PUi0{mwd04Np_`mdONo0{zjcyB<6 z1&I)laI5!7--}(>q=6xxMSUk(Vr&T?#1S#|26G*5et&MdY1Z-drrZDTZ(sWTP@4Bw zuNYdi=T!SPlfDg0Z+Y_ji0Sn_VjE>-+(KkF;5BML*{$@9tXpuics1HTzXXrDWriJM z06cLPL4uKZlzjI6#V>sRuXi>Pm8*Y>V~mxMGdE`+4FLo78V0@qD0w{MRlUqtug)9Z z#$Y7%b{tkOY?K%sB|m{zSOc{v5Rh`jc&n&k7-(KTe@}gdhw$u>lj6y*9JnzxS0wc@ zn;e_69rI$=7igl`MH2}MtCbad34BG#dH7&{-GleM2qJ8~mS31X18^-GpBk*fq>X}R zWbC-SPwN`4Kh;G$6M;6V{nB;MMjlSJNU|tP#|hOoEQ7LV;Jpa+0%$? zkqw}Bfxqt^PqP!4ATD%B25nUgQa?R7w(>ccJ(NS!pQS;N8aH`+p`{;Ffr;CPhT-KL zn|-Cbt!AbZFhav$U>`EIc*>ljN#AX>ygRbf8!nt(+jhqOZfeZlm-`Z}+WL}5TuXM# z+U>bibAGnZK5EIM(@VT z9VG${Dd`ji=`eS;pU&NNG)~H=9$VPOum;Aa!>T#C&J}pWa^MldHJiYo%FB~ID3tZX z`ojH}ya(?6%3Tpf-O)tyk7pQ7Up#(qd}6`ARaJ@hp-UbOoF35I+}-gT>UwN`{Hk89GjwK z*h??OeT;x}Ad86XTMxqRyZm=qiR|R@c3?wQE(&Kabi2nO{!u z{JtyquBs$&Q(XZ=d5T_N%{`m#x!`5GHKV=DsvkVanE7oAe^7<3mqziJ(C%zx(6)(S zc$V=McHS$p|I=lv^g=THL;%w(!>tLeFT!!;3$=$ zMR5y@l~SC>Zh<(y%3>=)~d>XM*lvR?q+2$7z&`!vxJnCkP02RxrWH+EN zUj$9HjT>-WNDS~@k+@VQ4XP7YuSs09+t0>Dqb$U5RA-^9k0NMTtofe8R~7WVQ5kc^WakQCTjQRRb)U&Qw2gt|a4ODDbZI|2;~M#%o&r%TcCAKP*}u5=v52Vz(c>+#>Cj983R0u3-EgTMn4y+5bFBnIY<3~+oq45!_ z#a{Fxlw$gSz1zaw1lBPr1oIV7M=AD+V^{7 z5#!P*HY+|ksV2V)SvJPN5pmJ%#dDGyjbcD3U<;nHe&m_Cho}Q6pB*^0y&B;SMLzTF zjNlr62;@Q>B&jTs%E>|AcG*!hkJd7A&*OE9*6r!Jiief#lF5%aCIHFhA`ZpX#5ab~RaMJckB zkBujZZDeqBvE@Rc<4o=o1&l|>SbGx|=iN_vePnT5UWZ}y1dv`U$5{L?2vbEee zGqxtW0G7%eub&rs^KRlo{vj!ULyfvJf&_3s{QnUd0zS%0cdv$=D>UCS_6!Skbxe(I z@MP5$H}!4NKFlsrkqqtbN<}0}gU|m0rI;0nR=NYsmw}vjnj0IAdC98WczdJU zz84?~YA#n@x&o9#Af9D`x!)G>y{O3=m|* z2tF(yEXN!zLF_MxhG(3SNacdUz0kw)oZ};fM_5HQt3kMov1cqmn7TOS&LajnM=^X{ zV}S7!Bn2EFS%z8#n5ys+6hlAbQYKkgE`K$xHdcSF1o+B=S6?M!rOKpC+HBIh$OxZZ zOR3U9QbjDGI-4;!st(^NcB?^CbQ=X@V5Op^CoBn2j*zRq0Sp!{CM*^pUvD}90kZ&x zH9JxcP8L~DsT|?8bHn>@eh0)HTpXh|UzJU9q{jxUXmaJ}{RH=9K;K%_CP#J*VGA!%VbaW2cEeCsth}%(gk0>UHl9}LICL0i_^72#xil7#Db}h zmp#6_C}c)hXc@8hNbZR-PBPOLu$LE}o_6QZQj30tGvqh^oV4SmF0{?C+ZIFLhevA> z5#=;|aBTSW$$313_Q8ll_GaGrXiVO#m#(38KaRvnWes#zE3KL`80DI-&<>lwh+{p` zoprqA4ibT)f;*P}0Z5E@D9l0YdFkr+mc)$W?Ytia@8;Ftx;&#VG&T@$&G)0jsM%zL zpW{ea^xjDuI!Cm)9M%(WY*|01{*ayKE5tvAwDCj?&*=OH$z^nm(6H`0!i000eOB`| zWvD`}Kec3n#7(T9Wk;$~rq|2_C5I8iJ7rtBy=BZv4*4U@a>K|#qG6S_tHC&qs6Y_V zONeDXQ)5h?{4jmE)wyFxaV&j!+BXlZE&sAC z6u0Q(I2kyW6xz^YN*KtUAtkdYm9}ZS7n0xb_Du~J^0v_iOl9P6apt|%@Lzi4=|;6z zZ>ZhG;OC1$Y3r+8<1P+%WX2v_pSeHf-B8+x$9ot$ig1`22ia2pG!(VJ{NL8~#W~5{ zh0ap)t-_p|jq}f*ocFjrwEn?V{~sP^Xq2~SGY#nT9*3(vs@e+$^ZGA`BUml(0=;|G z?;7f?Q8L$t#i}?6eToypn77j%5i(L-ub-D4Uj4|9c`HUADDBx<>7VDxa4w3RJs;@^ zKNlRB)wDDz=pJ}2rFl&gH1kz*ze-^Za*Ee6s)l3R@;#2lA)7tf9ec%5^?F0il={OR zfh+}~3$1KSNL58yG!pYk-b8_`A&~WE9?FiI5rkXb9A5uXIN(ViTS@0E$9{3B@;zXr zX3RHM@Xn_Bfm~hG;F-r3s-R&xP1^-LxCkvX!aU6Naulm)C1j8<$I%HrUl%8rJ>D|O zXMYd2c%Qyn)MS-fbnBRma+@(1pz%8@G=)<*w})a{)HQ<}pQGYHF^usSlW=W@xkX!y zF|6N|zvzzE(`m^`Cl)e+n@&pH-t+PHi&>(J)%Y1IRFH!Om@ji|rW_lMcJnBFA(Rc` z-a>|>47=Ej%OMDeG0KmUo`!GXb-v9)X zKT{w;Q=(ZPnNOK#S*g}J+%i1x-2NFs4a?J@Ik{-u9yK6Sr_(bT(6rbK8$E;3zDM2))-F~m{jwGuy z_e@(LsitH_d38QzO~q?@yVd*4^eKgiN;aUzsh-RDEln>2Y4F+U;n27Nay{iAUwsLy zpXi_00k$cB5h!BqvysBANa5R;pHzcmQwyrED*Pmx@p`$t{493tG8!^c}H`HOm6a|z0|6IyCAhaCK(Oq z!-<~8m*<1n9SA4DMEBX#ij%Bk`Ei3|_KoN)dLA!5*sJQ5n1rd$rpt2&EHRD>SymxscD^Pa~o? z-sEe0*MR{~3WPU3xm5+=X=&lA#s8f8$PXfq6(aBPiY|Whx|eo}5?`zdL5A-W%UB7dKJE>%CP7@Q8pKU7N;%@9HT2yu6WcDw= zHEeA4S6>EOXO6b+wG+|yp0~i1zW99K?JMK=a@r758Z_SLzUUjEqP?^&yw*;#s#-wjZa|fu~YPyQTC}|C`$i1zLuSLnI9{6CV*=S_`qK zIQ_$@-0^K-wCsp#>QlrY9V`bi0Ij!&Mn5rg?%Dbtmlb3RRC$gXsKvm0`6%(U!Zbox zqHKcU?UG}|*2SwpN=d#EVXzN<48tb#lxsS0^vv|1Q$kit3kQoRhC|EuCuT$(1DkGv z?Yva2z`qx=7w`1#bKY%&$9*$|Uc>dqwvi^Df*6mPK3!RdKw_aM`gksmAbIg$FoyD^yn_Z7sAZXMF8#=p26VqQ_D|_NAv@{B zbp~4)&SP{+12tD=7R)n^!ssY(rl1Q4K1BB->`Bv+NJG~ANuubeufdn&Q;G{|LeF_Z@>NmR4JI|_$&RqZ=Gzk8*-3 zmUPwME=Sj^n!+?QG^o^X9yt`ClX>W;w-qSk8Ed#noW+FHc22M^oBGB~N$ghMb|f}w z#alQMiOLgHz|v@F(LeZ_@uY07BF8+ot6@gz?nq>oouMBME$?T63b)UhAATXrn@GKf zW~F$gY@W;ijDOW!I{Vz&?)>NYu)qP00%t-|qu>%beoMnO~D^lK%IXXd-rZ-x&sPnGm3W zoqq=BB@kS|+o+W(c}<%h^Gr`8rN&msIRlSV`|p92GvuujMQqo#~?s&$)9}`x__3^VBW%kJ$DuEFJfP_kOk8 zcxS$mQh(?(RGb~^FrU_tiuPn3jH)8+<{HkkFT5HI2d*z4?fa>gHR z%&iG(Y~puL5Qf`{BQC2$UByB2mf@XS>g<674Qwfahy-0&iq70P<;RTf#k%3!qyJv0 zt1K|Wv4{ombQ~IH3PM_`o|Rk8>2K`dn&7K-a#R;IfolgNaDyg{H6e+Hn=H7u@KX8o zPgFbfD zq*Ck_2U>L(O_CR=FkVXfG(n1Vqd42V7&|Dif&#;aS+HN_FJORjqKWuOCXW5(;RfGymGh(E?Ak6^L=}53iddrUa=02w7fi~Gq)Lt9cII=N(ZP}vnX-bo|mpJ zzAPh(7%Rya*sV*;i6u@mvt|wN=>a`p5Rq!40Q@JrsceB_fAkbnWzm%oA{Rx9j0M1) z`T{Iq6i}nKVSuPJeoUdEC>W;+H`G+b;m*UIYHeaZbfH7_1amzkan0I&`RKt?8p_5} z?P_!mN7e;?4yLTPFjg1d`WuoqLcw8|P6WCPj(#CfI&a;Bm_Chkr>j5jzIt!DyO*X? zeBHarTQB7d6}+IROHYDVQecMJ$8&H7Ni(Z5Xz6o?16qGo5iqc3{dr9m(mpiJpI%cD zIQbVsG^tot{C#9yAQfWQm1t#w3ckE>PE%H8g~MbQW=xQ|rF;PgZo>N1?ywEp$v5Pj zt)D`M_0;iB#7>KXaoZ3KwN&W4D35H;u?(n$2)v*^cH&q$aU=Fp$&R zz4V#pA@Lg?+4^Dyzaj71XbkU0mO0j~RlWhn(qKbdwmbYqro4tMjmGLNHq zWU&klBUScZda%6u%?ft^&GN-~ zYbqj}=7NG83LbJUOW7B;WiSj{v>J(8(6x%q0vqMKtat-`ecqI}naN;6(+~$9mHlP1 zTS%p@xb@Py_%aopScB$2VPc@O@OwJzJsXN{j5Wp|OC3#~xmYk#b%JzjUp zZ(3|Y%t8%TgLY;D)AhG(_a}s1u5ty%D$Zd-rQZ{>e1!)%4V`-(!?UUW6MKn`v(K8j z+U`CoPFX@YF^T--wR17^uHDVja3i+8&B%DRN>DZ-HlQj@*n!uA?HH`?U<-!E{5-;SV=7uLw)k|m7 z873rzHVMQ=-b&$zG)LI6jMFKGna( z(tt(dwpM#QFmlKr3rz~fO{JL2#2aeoGN9thaKG7EOgIHRF%(tBW~G#di+`)Hk@~#E zpa-i)xefd$RLhj<57XEs@TZ;z>F$y?l9HApBm%ucDu})fWw&CP^N!x1@nKBPjg2q$ z^sI7mE*OfL9jdXBnU<_YR46Aat!;cf+VA%fgTC+FTGi9GZk9Omp@wsON^ZzZofDwR znwj*C>HzW2&|P$_(_Y?*N7H+-lo%uqVt_tvjLGtQjoOpJw{}HiUoqx4%<|Y=j8=T;SoBIH{pagc0Gk(H{dQy`B1 zJNoxoRd=5kE)PlNwZ;=Y^sG>yYi;`KsRn!35!x3aOvQxAAmO@F15u&$45*2h8HAo= zu2|F7GNw!{1F0SHY4~Kl#eE*6AKyGuzlP(9oNpA!Gj)bL5mmo3nQ>@eLNJZ?C}Ac6 zZFi3>+DiLhG%o-x+0`>NqjeYiba>+d2NmbtxbeJu7JPDT>Y{0?s&Kx=W-dMyWPx*c z;jWmHX2k_4cQ`UF&|~g{uFAXCbPn6fw1hKORsxt1FHjI=31gBnv*Q}yo@kZ)<9f5h zR=0WNkly@m$ksd&{a$z_1Mm3B>2#*8c~;cTLwajA!+@hjHc=`hl&feFR3HW;7C-kB z_x>LRe6EK=>3a)p89YbNAjx|1RUhR{d2K#XAtmB&SRiE%IBn*4i|R#zLjf+gfoWGt zz>J)X0{xx+GcH6Wfu!cToc7g4`4r@iOU~LA20Vq zoPlGT(qA^_OZ6r$&>8#P52NyJhytAL-0hFmR8D&&IqCF&4UA|hI{5TxVbJy|pa0}< zvyaU-LFAH00RnWsy_|ua3tm3TqZ$1y4h5G@vBI^dfN4cnz_N&YqKr!3FgkopbvDCC zVQoc1kLJXMj>HY8c!_Oq+QW6;Btv*yKc=B(3|Dd2_`iPL3Vn06huUi;T;uVvzhd$P zvPb7uNxN98uEuafwgpXNvuVJ!j-95}Z|=rUP3PZ)2|{YS1{=}w)ACY@#}<$d z=yY}*zug42GS0YJL3+FemR(wh@?bzR+#zYGa3a+{2y!OwfzjC(u0St2rqI|^eq*y= zHRNkwzIG0GuXYbU^&aC3ZW&=AtQud(?i#}-=nxB)6AcxK>;RkDStPo5^Z1)&S{7niUUjxRV?? zz7iK{1?;NHxdaDjOac5eSP zh+GM=7du-h$p!UJiK!ngYFZTf7r*+!&IO>t8rA`jM1WX^f#0W$VUj=;{ve0SBNOK` zV~OywpJws3ka3|*1f8 zPQznk%j?q`A8z48ABKPat`kygQnyG0eiOSlPAp{aF1n)2s^^xtbbn9`l36;t3^W&^In_w)>$5lA!S2- z=wSa=^`QZ^$I?YVxQq0P;M{~Zijl95iH1cVk9~9KDz!~pr8k-~fN_Kzb2=$EX`ipG zV)w82*=x#(XImQI9uwl4bwUl5t2|p0+#mCfM*~vzFYbN=T zZsG%Rj{&3ma6NX>G;2GhHQbPFjezT0N#RS!OJvruQ6ESI8dHub0B&Cpzdt4KE`KG8 z+2DE{d$P|PF9KpV2Kt3n4Pm6!gC=AxaHz9A?c(-N&p!Siu!ZY!3a_8<>uY}R%kNHa zpYsX=^SNW|nGJBLovZfukqkMI;lPyt=TCIDMhkcYNbhO;>|faEHlRR@Ld@aC!iNA1 zM{TJzc%TsUXOgL2f$GaL}Gy%+?GQ$(H!@Xh%0G!rg2K!sg00rZ^(jMm!~ z+9585;o~d5`XL8^4h!swh~zL9)Y6p0WDtzEKozBQrKy4pL&&aSG(JB4)BiOD%vDO@ z7zAR`mjb5KD}7YiYjcA3?TMmOeQ~nUD96AexUM_!;sZ}XlN>-K8An8|2 z3Oo^hDTPHw!i^{s;~Yzf0%;awL$(<0W>oa5zj3j&Qc4m9=Fok0c*myG(O}$IYJziO zYyvxH6fJzRyn5qrqehGaD`gQ@Qy_wDgrUh8cz73w>*k_pGI7xftPC!2_0?Tr$P+8m z%FTD-M2M$#GW}P7Is*sC2U+EZU>Q3+Z+3b@I}_7B6z<$Vqlm-lT{d0VsAd1#nGKBk zmJ1SNRr3aLRN!gqRwBp}8es|#a>|g;9zRugNw7L$sWH5$cQ{OQSx(c09^z@*Kzv~N z9--Of)y03UL!J6Ogxd0zqvxG1vD>_{A-0af2Hu0wKH&I8_9*j@J7=&aDD3$J)pGq{ z&OfJp>EP1}2yS^%MZM;+lqBeqlc>UX*X^SvGb{xx6YhUGm1+}FK0y)&lH#eq_~Z2Y zbLZy3r1|H+^~zqhLHE=(zuViM_Vh?XK5Q4gv_U&c9WTli_2)`yF;+h$y z{af6EVt@9)CTGbP*F}p|@kuFgMMMNPo+eE1mVTOjq~BiH7X(ntzeTzp(G$mSh>^4^ z^T)ZryZ64V0~bOKYugGQO};Ry0H%X~Pl1gP-~Zmkd7)GU%x7#kGjeWPy`?Y%K-#<{;2z27rg5sKAO&>*Fv%_@^7Uq(vKN!h*rNNE#*5OVq za=xb~l`~e^vkT%G^gz5m)IB+}@kYA%kEn;kF5e%9-HjhR?>Z^!I(Yma3wc@+I&0(u75^*OGw>}4rA2uMx0klQx&>Xr_B4F% zH)a^%&S0m%ce!ZKgxKiM#dwF@R`&OC_zf%ni&s@hrKM$(L{u7qc6ukR^&;AApbnf7 zfOr&=3*6CnX3GLo-{TYwmY*Jks|@FW zU0`eh1Ewc(L2B{#azu(Q;r?%6Fb~KWbfhpnu8K?rUoh{DD^*lBx~S~gx(+7?vgQuV zSiv2{$C3B{5~-Q=_#=grb~a+vr}^`ry>y||>VGo5@-*v-hOS1AM9(CHH=-zaq~Z8P z|C0LYmFS+<63<}~EP*y8*de}Hws z*6DA0H`81x?{+JS=DA@E%4+LB!DGRu3xgywLuUf_X)!=~n|_^e+9Y`9S7BrN$GV!V zK$Yd%jSzLw(gUiE502v~ku0ck$$jIs_0v&4rF!7gj&1tH9+WSnUrW(t5`)ypLsT!o zZ1?BD7B>%B=^kR}~s+ zToyUqe_?0f6KX;+-n4W%^MMCDy{)Qf2LPz$K(}7n%4L^N^jb&fUA<#lcj=G#= zyiprN{a@Xh?K=2mJ*jjb=M4UETq}(Ft__3>=LW&C@XJ6$ej$-`zBC3ZD}wi@U@l&F z>|Q7uG@*+EGaAy|=zlR%cVghuG&Y2J!FkI^0F6|ps}$wioBa}e}OM(!JyuT`iZTb)QF_x#Kb9@J(Ffp zl&S1U?OJuF?$V6<2_B0>t5AX2$Yh2`VwHT-OTnuPFis4|o~aS2+fp;7l4&yJEyS|@7hw4*Ce^*5vK2B~?KY;kM=nJBIYEh6~Vkwft&a3jfd*8?n-JZ1%?FMFVN7cv}aTOidAzrgPKg&(yIA=iw zHO(`QMqLo(0C?2mX6vs_p1jBAq=>NjX$I0KG7BV1-_P3N@a!7Jhywa^lPdS{lonE9 z2Bz>PZh31e2#J}fMVA9lPv7U4O@-^>HwAskmkV=?JaHGZ=EN&m&+IPg%)UT>ai(O~ z$HwkYS%8(h`F+`+Xi7#B%}7zV;qM7708CKdyii{Q=ZTFFT_|ivG&@tIW~$+gsFnVV zXL55x%}2n?CcOvK7!lE*%={;AEqSKwlk6<#-={O8FA~C%i0`s4zQ2T!Jv3A{lmc|8 zl=_JRzdW)j)7*6G)AL{s$lFM-bjeaTG&L5@wQCyk z+O^vtx1+DDi_6JD1clrKX=Kqt5oGz9U?_3Si9M7eL?@}h5;=`nr=*XmUUmS!%To`P zwc)yBM`diE>x)YW$7UT)TP!{GqU~?4!gbtMG(B2HWzNjQp-OR;LTOB(5NnLJyYh*Z zA=bMrqedX`-P|1B%v9_s>?0juBu;odp6;2fy=(=^6U{Q`M<2XvozHdeC%npVw(wT8 zr~`cLum^0224vcb8{1(Zm1RQFW(#)|M8B0l=@z)4d`S_hsrTtXL_3HSyy?zIS4S;N zrVWQ2{9aSBRK`t)W)8FRPSrzrcxOl7j%P)%R7&Jns{Is&jgp$4-lXUn z?1bc8Vn|)x*MHf^K$4{1GNtaJv0nK_H0TTZD-%)!K0qZ~cK50{b5BSfaXO?s^2#hG z$8;^jwg_`Mk-PT0YECS-*C*t#76UW7GZVa4iM?|mXNHxn{3Cpc)vUL&KJ1Net&Sbx z1_V0+Vq{k(Nsl#khRq!+X|qKntq%sbtn#_w(h=Y?zneD4+Uc<%!r^w-K09wxDpx(V znpP44;QgCMUERawcXjm5o`1Z6;!A0@f634L4s0u6GVRj&Onf32g75Bpcy<+B(}tQN zSgL1Tj9%!>)qv_<-AmI0sq0%#bXxWrITgLP$hOLbD~vV~feIqwEkL}fblO@I8^X5xI7yY`o0f5}WN`Ml?{Hon zL-tT#K5%WyY>&Drtu)TvOczYwK1>l#@b*nNKu~ zQep3$rRmiPRQJc$d&hg`pinp}`U|q>Cj=`U*Abjk!{_ij>(WR==&AsuHO=|MuEb>(;G^3$Gmwg-s%UNF#E{QF_HTLCH|(gI8(ps!UH`TunvIai7iYb&W?2`O!ab z1qAOjf}6uBdS}DC8DN z7)Pp!RC?cFrdYsPogYrf39+#?%xa*|yfd7%>jK@ip>h4!=v86)T~__b-=AJZ6;p8K z{_pz`chYr94E(9?N}2L>R7-{b3CqH?5}Z&J$D8j7B`*vh`sKHhb6;yuM^5rY0rn`p z^`2KCBJ_08aKv_B*_k)*<$|q&)XIE|VTS|Ph8_woYlb+>6?!9BVEaXFN^0bIN#Ka< zP$Xu7(^-?y7i13HpLXI>)V59$u-bF0z93P31DYz;i%i>oI&XR6d)Yv5F?*jWd$jC% z3L-~mdwIaf%Ew!3CY9S<&D7oG!;&OQFlp@U0>K@*yO zWCgDlFdf1JS|qL!CTRlVG@OL15*|atcH{gDl$lu^iR07s=K$2 zXBY9Qn9JW`n2ZfieLa{WHqr)`n=h}CD~gtaHujhuTjyZFwg0c7d7Fm;rUe&A#s5I;3(}_+ zFH5!-h~NA)s6Hto!In|mEE<$@KyhgdQ%6jw)~1bfv7osD@GUr)c5C7Ki;D(31>+idfksi zj4e`A88P#_&VAoeebS=Pv% z#SaE#LFw=!7XIp~6$Z=iGJ~uMnI0&QiF5b|X7HP=Lp$lNOg1!3Ix>`hkYNe*)f=jJ zEIEm&^kx!}47t#-W_~-LEx?qejc8;SQPwTHW5{vB!v8T@+=kL^cm&M6 zxgE-tJRA<@5*W}%Kz(rL7xtpgwOl3qG{f)iZjw$e@&hZx6ce9XsotjaHfvk%oI=MU zM-t5;zdi)pEgb2XMir!_?R0%gS>{oPVja7?_Mb#I5Oa|GqY*bp)}Kk?Qok-_jzZz1 zJESzCb>XbR2A^a+j{K8~3TorShNqD{15BGpNhelh1)liGbOXH-(3CMTuD+spyh*-k z!9BCS@K&<4a(9oz3`OA~qG;HEM=?x$V#A?PXBq)tL*L{_)V2}FNqm7mQfvSp{`&cs zfAGQ_;r;x_%p)}ERX)d4PH(4{s=<3Su#B%Q_qyn!DzVzC{2sc>Pzxn4UpbO&Eq$|v!A|x?Djns;jyO)4M2QbR-JNL641^6`Pil|Il-o5n(#}jn zN1Xdk;mUMFxKeD*<&*+hHgeBGTbeWHg~EKtBou7Qa%reKoeQ^VUSn$@Tr-J_|Ab_2 z`(_(j`rRwdN~oEHp|Wr`Kpmn=52TF9YM;*S9g!DFDEP2af$&N@`kirfrZ7nK6h#>+Jf9}ZWssKFb!BBa~O&W z=%r8(#jQ;87R1>!SDWWuKPyt@ft!QSu{t+|9;>XwMl0!LzCqakH%AYH2N=z3nAr-y zcvWt1@Aq`*J91t0RzMjh>S6cHt^Ri zNQz@^d8DubF3%qeqDKu=#Y7=)7Ho?FBr)`>a5wf;UmM>z%E;&rKa= zE+5u1VrL*!&)hqcnM0=tUOgbI%~4uME3sC9a>)15n=~p9ZZ5hfE4+I)RwOtjl3A z5}`;Y3Iks9XD3QqJ(}EIojCAuiD#e|&Zq9vlRUNNk(f`qr%A8Hvx^QTVus#BNgRxE zd;p#G94*_tlxbXV9?t|lo!<2i)ncY-mD37RRyU*=#s>GeB6OHNWKe}#xa z@^{CI8uwMP#NgPRp=6)^-Iv1&59Cj(E${q)OuY?Ql=qqTea|r941yU3G$=N?fdRpf zh-ipueBKN=nt`BEbn{_M0ujF|=FzyD)$MLFAXxCD8Nev0A;zLf+h|Y|8ryUO1T9o7 ziM9#W^r#_Lx5ws9YuslOw~4;L^FQ`E-s5;a(nMkAzW@L0IT6>yyuBfX?!2^68%at(Cm6y!x)&|9GIQ(#Q|HetvA>sMVsx18y zLQ~nDVF#n2F)5xuASEs7li|NVOJ{8SUv;DTCNGCK-ar{5bVDjwYZb+&AInP3cWizc zOxxNJJBEI!X`{7GQMF8)g+Izqx8k|*T3YhS_JlEmIQ(S>e7iu7|3}ocsIhm7ID3o| z)LEWos+pIijg8l8sC3GfObz3#D=**EBq>Kt|I9hgB&XBUQGM~LT}vr0duZ#<#U?~M zg&Bl|;S)ws3+kO7e5nZ8JmUJ(l{aFmMFs{qDc5da+W5@{f9FvQ0TStc7_@=Ad!@o~m0oP7Nj;P)AslH^x}E;t{04KwLahQx=l` za8TAW)B;M3Y}}RSCfNC>j^p6mr3Q=>+UeETgNsZ4G3a9Zo^RQ{^3BCnnOy~uu!9>l zsR`%eZ@#Y(!#Tb=nl6m#6yDN68uHcuYMJeS{}KMuIGr zDngZ}Y6s&OM_^4dxgN4qJ$IY4i@N-3PdyK5eic z3zw~%>E!X-wLJ%$v8as#H)J)q($K^D*rx}Ui)r*b4$zVFqcY3^qHX)z@}hDnFibKv zUyCVW4mqLW0ql)cn@Z-zP@VS+-VD{k2x zInkZ)KmuACJQzChd^Fid%rQd^h`80@6gzBold?4ccP0{!Hdk?jm#hirvh2kmZGBjf z8v}`tD@o|75*x^avbcvYGjm;h_-k*LQO7BNOFSmnCZx8Ph8=`3Pn||J1rN;Zbw(`I zpW;+APhi~NRB=w97o+)C=fOtQz_M{Lc#Qk^>uYf2qV&=_r%8(q{v*~z4Mv5EeW`@f{tHso+K~IaNY+YOcwd~zfcA+`^uv{eD|T% z3bGo_JuoLD`d*Zg$>&lz@!g{EH9IB_4tC(ZtxZ^Kv$XMFewm#Spvz*8hhx8HK?rCN zPzdQopqZl_B4d`y(E@(Mz+2?{6DT(QGy zt+zar=7SQ1InVjkewz_T#P7axB7k&vu|!k@r=Nm)PIJh*e172D3@!iCJV_K4Fb*bQwENzO%Xy(5qwV7% z5C_Pr*@9U-Yr1}5d%+d%jL~%SB>6y{4hMXfQJ*4|RKDXc>Bxg8-t~pu?1OqHT7yqf z(KT^s%M4DMiL>|4b}b+KM7bx zz9&A`qA~tpU#;2n3GO`5)cX2jV_bW*t6&cG2j3Lh0f5XRFbomc9WS8|7P@AomZV&5 z_rrb)*wboKl-Pg*kQpY^uxG8}Uk`LNT}gLzZl9QOc6?mknr#0$fiMlq*KaI0$i57*qW>euYgIyZw*pe&t)nDe#2d|xGX zdqcS3hyV3&2mdnZxh$?4xlX+wNz?FGSnL0APDR09hp2vJt;VAJ)cW?f;f@F3sCljx z!oi>X?}EJx*Zk>uie;&MkmI+IBG7=BQ4KV>XSH7Wl}cs`GsIpf&HZfM6{ zA%XvgUpBd~^iXMjGE-}K(mp-@f#1Ax|83#L_3kFC{Qr4nIvbxx(=`4xC7Zvo=|dJD zngM2Fqq^YMzx`1Ts67A2-~3qlm$*Cq?YU{=MB|b!O(R&yhPcy_*g|MRZUcp7X2J!1 z(LIsOpd4<|BAOc#b+tszAcC(jQdYwxwIK3Ieq1f&q|8}FSyrI4RZl zG-N(;n9y=Rf>}v3Db%t$qs{R_# zc!E*t^4CoSwRC`cwmg(Q5~8$4~?WJMd6{TBZfP|$gNmv zgZN3M8Hc~RzUQNl#>`J|*uvdtZryj^Kezqq*#?}<%$}7Rr6*Hn3_i3bkurdezgd}( zdt}w+{4DF>$nPaC8R`6V)y}eYYd(2%XVH|{ewJq3yLI*diX1L&9ORUjjA(2BnE5>E@c%?hcVXn8ifsAQh2j zbyZE9|BIFDTWMYMs(z+(A@9NAW4m$^)AN%nRigPdw9USr`Dgj~={p9FKZ>oq^(cEN z^k>h{t>-wcbt8>=zn~UAHPGTlH-EH!F(oM6h+`e+ciZXSk^5ctcWk$a zR?@1MjIArq`5JsWrX0qmwSVNUp}7-PaSlF+;Ab|7Y1F8|{!4XDh2fKodC68;PIylC zepu1&q%Owenob2q-Q9F$ah9;~1!cMJYZErKp1ig^&2sS6V25>(qr?(t?CQHUlW=F? zkCKYDFpc%t95{2&HLHNXbjfF$(9l;@CBiYT_7^$3mR9VodHo>f0zCyqLD$_{X-Z&! zFtuwID%muAo|&^~NNm_RW^cyTo~*&#ubC|3_XtFcX-^!E*PMf?i#2sExFy?L& zWm7Q&HOPh9aiB2_<&(eDf`DuN5AI2m7o&+03IjS{b0}uou`+ViTb9!rpVPa6HfNma z1W;+ypcSLVf)c$kTRXiJj)YiLmKRel*fFUb01pOH4vDo;sjSGLX3V%ThgnO+Pj>X< zGU^2xu{4|D{LwfwkyH}=V9%fb=ZEX7qy(z>J|j9vqnzTFIBjt@_^?BRYwECb<}}(Z zA119Qj)~CKLSTX0iV%;Yv;Nv;Oue{_G%R#>)I>4B2}sVVhEoEMQ6s&=GuSxh+P^*~ z&%>$X_-pK5rO1tfvI%Bok0G1z2#NAPfHgfhz6ou5zJ@gvz&SuYm(6Qa_-OqzI=jo$ zxL^z-RQPQ<5{R}_UHC|ga*e6;j~b6tI?Dh#O;ss~@kK>H2xh5Qij%euPhwOH%r~cC zGPA`L6Hrrt{##peMKn;ZnIKX|NaOV;WlSqVVZx0sOnnuHgk7JZuXUu-|zE&Riax%_wjoV)iFKF47 zne|o!{zQJ!5=!VtISf zAl)Ik^6&`Xx%RUVzkF35oy&({R8|uiN^>_&?kK#w|vA)z*^5r(Nl18%x7M+qjVY+lC4QWO=6Myvk56kM~E0#nkjx%aGmKg|JM52~cqNu6vdoGQZ&G8hNZ{lID3i+Qe0=p_+8h{*Nv`_5A*;Ig z_`yy4nH{>v3VvG6CR5>@G@N#9bgNg=J$qMjFyq_KgimB}*q=;&Ts3{$8DRnydo|9u z&=(Uxj@vhVh+^wn>F}KNEM>-x6+1ItqOZZ=&(-lebDXbH{rf{n82+75f4`t+Kvusy9-VAF1Ewi~7!r9Man`%x?08h0 z+nBsYqJ3G|Y_@^m+_$smTR*1oI5w4h%FhVs44)kBv#Pm%VVT-_S#>C0QTdADhpqxP z$$Kua?_n!%HO*?B)!bNH<;-zEI8@ZKpb0m^-F4QgMYDYs$w_ZjDGwH}Z#}j!3oo9$ za3sB&2V-QlpI@pw>L5UZ6s#djM)x==i#N9kZ}JEsMw;~c*yP&4(iPYSI%}>hZ<``H zLm!v>K||c}*|~sD8+E%_m%e?5#RJSzW~6&6X3c9qF*$VBQ}9f&OIx?&w*R4i;^*zZ z2f6Yg+*Cl60brRQdEuGTJ^K(LA|cVP)4)*T!G#6>4pzpTdWJ3FMYskEeyE%y>Z60# zkGLg7WqFu+@@4|!8{j))>W7;c|4izpbQb@Y8ja`Lcrr=H^apmg^YL)Hb7hU1$y_3X z15L7g2X)r-&syag;pC>$1fh#+p1p$4*W#c=q!Uib02CI;M{2*rU#YNtS#kxO04{It8X2ohppo*vIwpjRL19%NCKQoio1_1~Sj?9fapZ?hUL&M$$o@r22vI ztLKV>1RH$=aG=SYhUx;{W32s&znZ9a^SomC;k+RhHNY#7Ab=&dzxTa)EvH#Etn6z_ zAah>He1=_AJ{F@$qBhm8l8GTOHG^TAFYKp`GrPQGQy{3V-a~rBTSqarx7ewD0i7GC zbjrHn6oZsyDZ@fO^F4r-%1m%}8UQ!nn>Q$aO|5a%_$+~0vqPIEEWg&-u)Ud%)dRj% zP9((o)7IKs^YxqD_Aykm^vFbKAv`!jenI14%h`3pLBRA$r!+7kf^To-@a?5(#8C@hp-7EV*# zPn-(Zfn_RW5Yt{=*A$wCNEo$yz#nq()F$W6+>+1a0_J5tlC z>T|-LBRTawAjGygDYcP}cU8Mulc#RC97AH2q_)rlkwi*TMo6A#tk7tl5bM6ciA>Q$ zolrP?@}};&wDqEfLlAn1lfFlYRKd;fj_I-dgJZt=XPRI0fdUD`*PCOiP?S1Fou)(I zf`Y!6_0DAetRakjiJ3Zpo^T3xq^`KSI&ZLBl{~|d;!@EMz%CK;caq zkAX&h6z=OnJ&YYSAAa?9f$m*w@MV#7Z^6X6oY>Q^kD+s$&M|tUE47~x0(ECZEtqO? z8;ro*6u$yzl31#|2H+cgzN~$bK()<|(%3iduJj_%jjvrhxosQf?3XvuJ8)imx2HU2 zxUR$|Duho|{W_QuEc97t0(<_^hep9fOjqZtSvOn3uf~&yToJm(awzaXF>{1XsyXl= zYTQpyZf@%tzPE4IQyg8h?diFg+QmoN=y4xTGQo>0IAn_G1Q?d9izWwh(=yX0sZKr$vmM7)!3mT9`k0F_7B+K;3uiaf<*uV)^H zSXDMrj^wJm%$_#kXi?j?A?6U-3f&q|K(#*Wg)u{iD)NT#5|+`8>S%MO^p-E>6CVt7 zNySB&B<&)iqeh_C`@b(yJv|sSrVP;bD2M6ICTR~?IMmuvIK0V|r(Lm%G|_O-*%(u4 zAyNBmE1Ya7&28tT>|rZMx`z=P$95y0#jcOCoS7?yOK2@gi*b=b7u36an0ZXI9+jht zZH&T?Ve1F8QD`_&ubbQ6-E{M(=2}o;+?b%eW*AhNxrU0ciZneiNjlKBD1`YP#>;wC zl%3U}qv;du;!){icOC`tqM+xciyi9p%!cvbg+ANNg~)CcXNPB7<)=x@MsIo-GO`|O zK!O3obna-?ZAw2q*AT|+BU;~swBR~&+P@Kx>+ zwWQCN5&!nX88~=;+g`H5R|gzJ2%OtE4q%zf!Y+QkN!Z-*=yl}ul9<|SUWUKr{XnXh*;<~+Zjm4G}J zeQ(Yugm`;RmUr;CpuWUW72xCN2SmDd>f3v1lC!E$aiVQ5qi^BgdcR7 zdABu~K3oa}GLCq6KgQ5*DrRH%X74^3j6b%%75P}85MVZKOu#x7PE2QM3u9k@8;wqS z2Iv0O8CJec6L#&5d6iG*jIE>zo9J}Kvn=^r%*Oq9CGW=Dc=eH0A!m&~OZ`gi^`M|6 zu{L2}gmGpUE>17>k5&&TSnU&3C&TSLHD8H*=d6gUb5rNV`=9)>CU)x5zX~DBww{w% ztflfgo+^|nu|+D}HEBT!)VG$~D~4AcfAUR&^s>UIYd6lne6N1oR4@y9lZ~g{|NY?7cg7ERMu`gNw&po0s4GI<5zNkjD-` z{P}mjz{=UiZEgC0#!s04a_}IhDbDR}vU|VvMP!Tt`dd%_7secT?}v%ujTVDP%36qe zbaf}kc=7Fw#YZ!*ylbw{{z=Wt$-g?fqvnd%PjwHCv*rwM?Pbbn*0wX#DYbU^D@lk# z)O_p9xZx4)uLj20Pv(uy1FCVkRn2BPawb|#k4LQFl*;S}9+}Z2Hk( z9wqOE7Q}~o7R7MazaG4O)`D9853F zi32C6Ja29YN%pI4+Mh>EHi&?^U62eje2n8FVgjwPSzS08%usNPonqyfuoT3Oh!6aX zHh{=AamscS5)qmTwZPPM&m?WEDTX*EDuM5!5}{s|!G_jXIYpG^&+@5F9XK>RXBZ#L z75M%wr@j5c9V7a<*zl=T^t}bydW&E#@EXrQ690k4cn;iPQQY}i3kv<>lUQyY)2yZh z5rdfu6A?9tY^UGRclo-Cc)ERH1_fX>W2BHYPel6=_=tUBy4C7(A|n4=aa4c|d3EDE zO*cyn8)q;PXOh+iDX&_Th<3Q^JMJvwvwifRck{~l)xD#|5b=q>xF;coT9)*whO@*1 zoD9>OlX#fmE6_|0B4jM{;zb2k6(bTQ72_We%aYO29CdCvw`4X~|CxS7BotvT6=F=M z)3N+D|GI*#XBry%?7ViXul(x2>hp6Ix#}unc+ouLLbLh_jy(hItu)efn~9B7>M{#J zF#@jQbdkq-yHn#Ygl65g?MlVo+~(D(3r1T0MGrc9XWpF=czgd0-U_7X|CG`D-~9Dd zK^kiaucaK0ji8uJrT`X3MYkdEW)^cYiQ(%XlbWVUk)d$HAyA#0$m6p;UcQU;;0?X* ztEG#*Dw@YrjkY@TT!YB28-o)eL(j5-!)-L&;!_*TyF7tVpBAvgx=YhPT0Dvf1!h$B zy}jja^AzA0YmSRqc~d7S9qV^XjW%*w6Hp!VwSB!KCqSI52eFt?%B5|4Jl>z!S0$W;w6LWWW8ZMkyk zVt!iHzKk>mQ9V`3Ck41LDv_{ORk+#4_|}Px0OtSL?T^g3cIW%mYiq5%?$Km5D< zU#lD~KiN7B{|C$cT1U0ElrUy9)IZWkf{G7s8pWru#+X>H>eHwY8!&>YzEt-ho|}uC zItqOSH|Mf{XX~Z9#_ekZ;f}hsUECAyZO)K$I(5@aGPVmv48gd z`y7(w8iPxkQFB+sVA;I8zoqx`oH8$}DCz;+RO+qS-zD$oCugSAy_E!y9;~k?cZTyG zar1vV<~5kbo4CTq)d9A0?8k>|HLIrkc@GBE z0+2x9!EB)Mz_qMvVsU;l9h8#o z>k9f@PU{D3OiSS^3vVLslmp}#8A$h+5(4*olZN`EbKeL;5YR}Gu7oU{HVQS@Aes3j zr|J3JyQV)Ps2kh&*N@pXz;+m@;E|@T4}QztN8(OF)RI&Id^tS(4gK8nl3iH91g> zL^M1DzxhoZr~+1V5>@nT%BesE(x5IhVPzBjhU4#ZaTVPnAcQ--)n;vScc6TXbnqA0iX8S^bW_=3cn7}w6?$ppJC`d+cTt-lK6eob{ zjnCwJqszI76=q~WsfS3+vqJLbQ$L!2PzPw}n{8-){UT@$0KnwzOq)}(^F9e+VpjvcpXqPAfMNBjSobRW}9JRo}*5YlE#sj=n3n|}B{?I#rfgs`)OSdd6q_m*{7_(~wQcjB*df(gYhgm}O zMQ2W;8PaIIk0%nP)WFwLMKOx1{g0I6$5)M+>5Y|$S+Zf^Mt{J`q)Dd7^EpB^`dxNm zu49UE1mo*yZvmPME^BKsy{mwCp=e3C0lyl5iwRf!1k=;xzn>f<+`*Aj5A(^0nFs+w zl;nnD*>DWIq`HGi%nj}zgbL$vCQWI#t6h6o%ZnD?ltk1&O5HPq@!1m+nZD+kns8=v zJYOBO5eekqTU`Bz`isZ(8T9LD7m+j~wLPV41?(gt#TH6Oo~}!v&znRF=TCu!&-+3Y z$H98|jHskdQjimm5oNSu9zImZOh()0j3qDZV&n*feZi`?wp|&`_H}Kl7+bvba@;dv zw4*b-@C9P#j!>sEa%R}7DGlom(pxGF#*TP(D|nmq(O^Fg7)cvd?y0YkB` zNS6t_7{RFGkWwHjhpbFyp)^`bi1)C|T%o_KhRhI$d7#{Q!&U-O71gwI3vb%!m4S2k z(?cMWOa)i=EEuN8}As^ z$VR)M)AMMLuQ_c;dqr8q`Ga+-KQQ2aL5fS_l?HcvQTEK(Q7lw-nAf%<4c(Sv$b}iD zLmElCV7`mrbh(2Pzvn1}{rM5;47#fT|;&8IaWzMZos z=UB;Pjlxp}4RbnR=%ZR9X^IG!iWtMTnkEH5Yo+s|S+0tN8rjDsCS;5p?M~X-Ttr1u zl|aYk)zUI>i2!?n?NMIM5B-6?pXF87hWCJuRvi9A{=7$Kg6KmN%*BtI$4}#!wFlmO4zDcYF+7D?X-YJ}#w?Ce6NAgMBaWYZ;~JY1y} zBs2>GC~(pmZZ0q}KH99t3}FX!0qBX@bjHkeyZI?rarw3PG+k`YFW&)jE?PkU{|t4T zU2*!1oPJTk=JWw1sCR;S2a`yAqtcIrM$+#j!AMceTLcvUu~09`D8OJt`T0Vkcw-@@ zKXcO$mZcojL~GSDMlTjQWdKbQ))JLR*_Zg$@p-J7=iI*T&Kr(rSvo$LZ@hN*nDUs2 zGe)jvANh)dC{1=CS}Y~Z>nP%&T8-WTSWk5$NXX--@V3%>M>7nk=w_-u7HkSriOK%^ zoGBH|a~arwtJ))-s#J}S9aye9skua$X?=YPK6HrIaV8F-AmS0NZ+*$nY}>_4=Sy#| zJFx$yV9f%vV97iM-D-t;BJ|Yylh^bbZ`CYx4%+GXhWl|J-%^@67HJWmHg71raTM*a zFLsN-9Y(74=YWqHg@EitA4NV;7hmBR)uo!7!_SsYyVc#{n^YZ)ui`=KY*7|hSSbF# zeh3t#cp>WR+9z}qrF@4E0zDao2BR2VW2__2yEbE*OzxZ9#5=MoUY)^d1e)AmV}7tH z;YQl%rH2t@aGl67*_u$!Y&(;Bwd#~rzY>WK27zF8f)JOLQ}#|4$8}!n&QoGeZZ+Ss zYGhr=gSdL1|SKrLsyfJ$(@P!Xs#Ym0R z0o*;&BUDzpHkH}uW_;?JY#t5||H;K#P{)?K?%`OjBG>ba329Z6uLg1>0WgB)2?f~8 zb$(o{r`1Mn-B%R54;f|Iru|U_&~bDJk}G=Wd{l9!asY9KU!L{aMdHdMet9gb^J&7# zE!pkpo~65n@0UscdItDq@Gg9HTZ#Z~TvaocB|}IJB0U8!-41kr|6e%yRG``+uK5b& zgqN?~dvLL}v%!DrcTLYfeE$4*Pt81hH0|6B&3boYPEG#vQi>Q}SOBxJ6=8hym2zXr zKx}~1AXW&+FIl533Lqcde@$-2yoqR9GDR_{DTeF0) z^yIlF+(KBIUX0Umt;ymBW^h30x?LI3vW zRfne~#DFi9s)v-kG(r&Vs%iZIn|v+435RPTRktK%I;nFS zbD$7|ZF`X?sgRlBzY8+_jm&eX_oY+Yg~6DL9)JTMO&MMH!Q3SjTTE%`zw)W{rpjro z%7GUt+Y4hZz#T`=%JqMpkFSq7bb^-h0hvT&=6J%6;d(|Bo|0`A?jptsnai!(&~%}! z9I2r7N!h<*q!8(&?^*;Gys+ef;0IOyMo&`rzl=})RZ?+fectZnIR6v)maGxb(p99c z`L>hJa4%1R zw)CIsI?jCWZDeebR@of&u^7#-Rt{FKd(Y$?e0p!s=-A^!Ek}R(%QJb;4eem!#?e=c zZOQLsr!J|Hc|QuucqQvZt2f$Ha10ypt9Pb*TZ_{sY?;At$0ajb#eZvHJb8I(Hme4t z90Qm_lhU%7m+l)r zmbd%fjtQ0>X}ZF8@11n=nyP7~Tt1%=X7=DIBB(ZR!(QCq#F=YYGO^XeAiC9=TYn|H z?M#8q_3#cJy7b3~hV1oqn{S^paax>n8M@PPLsq*rI|v5+>F=5@yGFi*6N{`=pZGYv zft@kL#&e660L#xHTB?fBiy$62^cqrKYc7Z^li&nyCnA@F-RxknFbb4xO_tmiA@{3YbGVQBK&kj(|j>5M3u*1zp|vug{RwvRBw2D zRlss#BNgf@->gRL#{IaRz>q~z7gMF|NH+3w5Cl+u)Bdvfxom7IVxk0jf zaFlQFy~b5-TV$ajI)(ib1{Cb1KH6PSF4DWByU5k2d#0I1iy5vkmnj341VD3&KWSps z!0j{8f~7Hr-w}Lz)NQvF^RcskRjqA${`7nN)oHSYXEkLM23##t&qTLVi?7WEpR$vpm7>2|8P)lJ!D@; zM_0k`M2~P^M=mO?;tLPe2G=Bx8+;mng$%3Z5KFE}7;k;V%@fGsmoHhv z0d5-clb`Tma9uZY??ddhca~?-z2mcea%gpwoqi^ammF|@k zl%c@!Zr)~OZ3ZZKH@Sm?djZ~x~k;gROW0iCTp7sqKuV2~hy8K6)Nz)S-d&?axuf!bG6L(>zE8VsI ze9N(ly)#lI+O=K^Ou;75nwww7XDp|=V)!DW0Qo2$R{&~h)VD7IH~s=0foWe<bPy!IPFcz_2#0%@XKTdV5EjwAI8QH1 z8Im=-C`EbMlI1a2Ak214Y+7WhVSFdl`!CK>XGFz>@Q8t_a*R?A`~J`=UxgN_8Y{r) zHWt2z5CM5suZGFLpTXn3_qy@0hHTNW^)ql1CPDiF5m6-y$3Iihq6x2|m z5!M$+Q+|$B%Ryhdhz8|`hvV7qiINeV*Ev`5swtAzv~GUr!1A&+vHX5Y)e;5QTiI4) zZcSZidnM}7;SknVeg*L^t++8k>DyE!f>+WqOHcNJ?+1L=*S{I*kC}@XaZ>9kKZ|yj z3CeqBrz)VQzZ&K+(@S}++&+pfiWJw);1d-AsH^F3=N;iiISHm933OWP-2PP_Ljf|3 zAU<=hFFs}g&YN$^{3^=2MTIvQI^Ge=vfNnz6#0I0DPM9&TtThPmUFrDqW89)&bs}v znodOdRl?Wu#lZbH8ywOIrp_ zH=fqXiPBj=yELacfL6pR-@NHn|J8jQ64=p>z^vCUoi{SHS_c!cJpRbMT1E%4(Q`QS zDhxw#f~90var#?(W4Y8ynVLt^LDiVRH{TESV5_R#TwHWEUaJ8ik_RKLv3dI~G#(3b zV?ownwQU)bt+R4c84>Tvpi`i~EqW9&lBsjQVO^84jBS~;otpz10SVl~?24?YFnH0N z)w>=<0puIXKCrINazu}ki45|$hWY>->f{?(PbRXk(7(Lt(Xh2)PKL+bw&>{zIhH$S zOUmxpo-W4Xs|e(ri@~P3ag=zQ?Ea-Ip0t5W(#(i>FTpn=7QT_ShBi*>93>ff7?=)u z4^JwrhOz6)qj)O!JlIL__(HxAJS>k z-CSLCfDVznc<~+l2`-}eaAlX);zR5-2WR$ySVRd0us*+}?HPOl+dO z2c^1h5HeieC^f6`$nBhlLC2;-!E${95rk0zr#=o@MWCCxT*}T3_iH&5pEhdgk?<() zu5ryFr!Q-0E_m<68x>W}`AzG_#q1JcRU1mH=x~J9L}pmV223c71h~Xk-@JVBj}Pjs zN$T^O7(+3nEnT_pYgPS>WZYijxqN>7epd|`e)x~QhLT~Oh_)^GAj!%C?kb7bw5y zj-2VQx{w7xVIn!iMN_SYO?sr@6Wu42B!>PrRmywf{LML2x?w|wtRcZ`&!19#Ihvhc z;l3G$QnpgOz9~Br4?g$S_>OrY+i{UE<|rEFnmIu^xP8L7Q;RbF`?8OJSOmPqnns~( z(bm7!)virJHO=g5j5{Y{TeSnD^}V^D*A5h0KD#T`Sb*z&nZa;ggBaO<{0qlAoE_61 z(Z|eeusV`(dbOcp@uRlFo|`?vZr}@g{dJlMOGj4Wo>tExSy+{;)}DW zUDep=qn~s8-TWp&pve*;vF!ZuFRS#XB_SZnut+6B(AwVUf(@mdU{HL+9QSM8i5J@W zG8~oSup@K*W98e|*O(2OC}nw_u)Mf5$K>~UeVs|X6+wVmx245u<2^BI)p;OLRm|`o zvp4Qv{Op`B$B!32C>nhMaOn=CBN&%GhXZ-%9mQ}MYbTC(x1AjNg)=+Z`Ip#_5qr zvp2(6ny$7-?U+VR8HJ=nWX-FYj;#&u03^RgKS1Cv<`;{6o}qOl|utT)|gX@`l7 z*skO>I2YBp&g02lKVxy*Z5$#l*zNLH+yAHUtV zuQb<=ZCW+|dx!B&gV%{5qAvr{G%xI#QL4a-DijX{)A|N!c^|b^(nK3AoLd|%IA#>< z>;!F&3%vx*E2YhInaL8)$Bo36YusRN2N0Flrv3!AQQI7P-aHqlU{SftAIA#MWohAF zq~5!nP|-(s_{Q^}rG`W7FI`n6}#X9gi^UI^m* z)@*>F4=YPqxB!aNM?p+5#Z>N2OqLqS#ZZPy;K<&r@$Ejsazh7YnvNgG$8=K>b^x{T z{CP~#fkFasrizM)W=L_4#$bOydj-nJKd_|&3!y;Jn^YbsZYsZVny1g2j&Jtz#Pa$z z-mG*-sV(K))r^HqdRAsvKE3xNW6Lo!*^Tb2wb=GAjIlccDb_Kb@+N|v+7ixA^f zNg1NfM$^}SM>^1d27-RGMhE}4%5l$q3R@1ZAoJXpR*JU;NkE(oo@R%&ztm|Gw%hbm zHp8Flw}|wEG(1t)t#7I-4d{;5PX7xtbU!p;X%ms%Ru(^EEuZPhnM~88J?ttNj)$97 zt!xl{_1e!b<@;zirJAk?Ap#n5$nN>8R(E!OU)qXO1#F9y z3~TR7@-Vo_tJORS&b_C5N2^5b3Y8BmFS%>_qv0KEQyl)n)Wl{A>VT(}Mi%KYfRmo;PWy`z|KiTCSK?zsMUk?!xpgvQhEhfdk7KE_HB|d38Fs zR8B-0mF|>x^Sc6n1ttV-8u|l2|KZWr`uz(K6n_WLkgVT$KEd_UZJ`3jL~=wEs~Ya1 zI69z63{h%a?+o_k_=^3hJ25#{?R5D34-NRJT@99cM#@h7eC}r^L_!5_o3)@u{Q4Xt zl0w~Iol;xtpEx+jG^^NzJdD#+{lydP6kj!^(dFzX+%mYLrl-*jfe`;j_#BScQy`Jh z=mP!HCqegx$n(bG{N&dFKBPn9sPS+#vBs*^t!7Z0u-G;KuH%ihFSmD(`RUcj-+t4E zK}UO$IFYv>wp$0UuzL|q>(_3nZ6|B4ANbY$jGBGpxIGd#h=Im@b=K`_ti@57d%Plq z6hCX)18y!AztqB;{r~*Snd3A04;eMMd>Dcwdpfhm3J(;7wSoR`KSy9e7lzn~6DyEG zIZ@9?ARQK`cB3_xp32>JqjX)u%;_Grp!6pFuR4?Lv7yM(#Q6bDwS6%m%gP88<@Yh# z+WW#z+C9pw8{S(o>0nApu0pUi|Ixz_Z~v^`1p3hMc@fOU;r}^?ZTYGC3*-$mC3W)- zMX_@nLGw2$q5|*c$#w?wagoYI;^-%(hWXR8p85f9fQi!NHeo}2avQ9 zeu!qv)nMc2a(pP~Lrz&UScH`8yMwN`A1=vFiS6`^RLNHOW24YOFp6W19i{V>p^Ap( z8YSOF`ayZD^^McAzbX@J<-GA}3Wz!OzG%wPARcFwD$q3ChHj-#9tuNObdLEws%v`A1V1q`t=g33x`8#*E16c9gK5msv25m=YbYZ>D_Mk{sO%Fa-dnBgzxTwj?zj z5}2y85lh=OI|f{1MUVr$Bz zUMd5hld_gfm&cGEcM)4kTVMYsP0s}6quGYAD=8z3_jTJ&KnQ99GVnoF43(L^-=cZ_ zmJTm42|AKsVg!0L53J6OH+o0+Z|Jbn(+=`;c=%#ZhO&u#rbgJ77(Sr}7o~L17#`h} zs?CVH+UFhqU;p;UbBb8U>tBD=>G75PITGI*SMyQA`GBXOdR5nq#9CK4qf2_chAWFV z+Ksaoq-s*jQHzx1n3q<&k}WJ$tI~$2ACNqPzPbmC7L;1HF1#LdaR~N@Pfb>ByEAuF z0gT3I*+Ukyp@Acrry~1^x2zn$=LEOI-oCahj$(^1Qnl=!{O*E>yQw(VR;9<%lum#d zbVcH}SMv85GMJkh?gfIST6q=K^X!Ch*kz5l{QU5}4Y$v+^UB?x7>I?k!e5(^6Fd!9 z|HW=+!z7`e(HOfrE}!4tyMfi~7p(RGt4Bt&ZFS|df1SLgeSND)C3qK! zuwDGNA?m!oIAI)X)j3xnB>0WEbVTJiJ{_*v1vy=-BZWK#6bhHF`|O4c3c=F}&V5^E z(5{*F6b@R*A1Y%a!zX5B)GSEP$V;^F*iCDqRl;w*@A`}0SH$ z+O;O{;Lf--xXN;tddXAIRJEI)f8*j~{G3Pp} zqHXq<`}j=)1+=mPvDFG17S=B0b&JJ!dL0}07hRl@dsi~CAl#80L*1pr8FTr34V?&{ zRs<}>l>)^G(}{yqT<2&%93N&D@yAc6g{nxw=^0L$kp}*BzgcfSxRo5n8&c9Y=@-3@qhar1xd0k2HObml=H35#K_>EjEWqK47p7%bbZ1VQLQWmqD zo07xQVvqmxEidD@E5_2u1(=~;6Dq=L=5P1biK_GtLIDz*{Tht+J4~RgcdzrZLA`(^ zP6#dzFdd7}1v|Uc;36^UUq;Iaa+Jm<$cBF(M^EgW7L7Tg*p{VvJEtY)m05G+dq<`( zi%Go@czRsXP~5l$*T3S6(C-mfXXFneOEvHzD-M&DK(sv1StB;9OQJxI^fr!0$)B zK%t)Bd^(}E7{NRC;?!)~Ln$g|u5UNf%hD*|`*0dQQ(Jh!7lC)ziGEb_z>C)K)DjA}GC&%R}>rj#u zhmVSorSMk!F$xYPZ!j5J=kDvTl&WLm_)P5H)@|U>Sy9GTiUxD?*7EE5FY52>@}`4v z{cR1uKJI^{p2uClm!B)jH@ zdgSgBN{&C^!d0Y|kvxY#5?D7UqZM0#`YZ1{Xvd%O#TS0*^z%FEypTSuQ!OhOY6a=4 z*0)M4b@$kxp{kr-TUmHoHTrT?@16AFtg>h8s9URMyRjZm@7TC&vD5Ay-DBwyX0B)E zXlZsv&ecw9 z3Y1d~Bwaq1a%^!p_*8?F^dwsVP*a?#QB2vK=PsN zgjh-rV2Cob^w-ow2!upq04Ir&WI*HVChVt($BWFL>T5myM$ox;WrK#YW>z-$)=(lc34qxFhI@878S^1z2-17d(Ugtz0^8fRP6yW zbR(ZcHP?9Fn~`nmukc?VE&ov-f1+(~f)lrgo&pw8IyV;wcqF^~tq`kVtbQbO`eIVY zn60ld#j_UKvHH)9E|@37rO2S~IrxgP3&rn(uj#Ki!fTT0Nf=!#PRnw&i!(KZK|;)+ zT*TDp6gL#I;t*UqRDJStMepD*GJGHcP(X>Qn$yp-D5rY=VS zeGNBQdFp%S71N1$o=BM#Ep9-X+!vFS;DqU1tMa-2vtws8X{L&T=BwE$YA_J-SASHU zqv)b!i4^ALGVj(f&^|ADX4qbx`l%~+5R(sNnDIEaM>sVt1AZqmXRT0>!YV3BA}aC? zr|SM0wbmzt;ogzAB)ZMP+CEpvZ@|2oRfRy-R??r6o*5i56BE_SBk#PT<`Y$eN*6N3 zewU9WYv!Zl(=T#S&7Y77`ICI^8;7IvUA-S8WvAD+0-l9iN^z^uVa|cDZ1j^cMG3Xd zPlP5jvkL3SBb#%GVC9k zn25?h5A^zhcH#`7;!IJ;!Q`7O*Qv1)^^Gv|6SOxXjOo*X)Zhf+nDshmM#IVneZHv? z|L2#`l&TtyYS}2`zj**|Ox-0lnNe6$(HRdFSVV$~xKRa{&S^|r`1cEISU*`E^mKI0 zbHU6qQOE;M8p=Kgp&jtePk#GiuB3r>V}k!+%2`yx1zf`9;&K^b^H@y>Ia>$ADn`Q? zqi0OJ?vsaDtZ2S5zYiQwcH&XIhMk64U9OG>{EEeH=DnvY*^T%vR#M<~(+5=KW3Yfq zM<4X^rl5-jVvh&Hu^Q1$@uIxxfI`b~g03x;qzUzG9E<#R$?C(Ovby8U$j?&jGEeyI ztOf7Oc_-+;5aLcfnWs!l=t|+Q2iU)X2&?QzbU!QieB@(Kk)T(LE8s5nGrE(`Jd)Ux zxfIBnAyW1l%(i5jfo_{%0?R??bi4rQ#489*K+`FA={n0aG(kHK@4h{SF zOuz-^*nb75yd=+G_LS3)_Ml*CK3%i&SVv(z1?u(PeM>)u%^G|WNU>X~R$vI9JG~8A z$bGdTJFDi$X!v<%$_%xMmye3TXllESqP{~bBnrO|b07ppxkxFf-Zd7Yd9 zAS9npy{IQ!%3P@)q2dMOynS|zGhiAr8hJEht9m@9e*np#h4E>OqgUgWPG8zf5x`AC z@L+02qag;EumzRG$$?dp)0F_|s+4)k3?l6;gG!Rj2Cq!qZmScJxiAM}N>QeLu%3fq z*FM(bp#_NX1k~aJF07`&kq||^0Ck{TqOi#a`p>6Q>q6UO=Oc!IAUR-r?h{*{?C|x8 z=h%@@gvf-8>}EWHVPpt}^0e1DwrJg8Y;uDuhEw3CR?JQXm09zdYr@C;gC(Cy&=)n<*KQttcXd}GKd`!y z^)D;ZgzD~PF8M%|)%GBz=0k~3!|YoUUEXS^15)HjUU?C!XvrR4u33=xlcc1@7DmgQ z+R_+c^yT;q?a9`hlLfZln=yU$;SZNAlUVJo_3bI2mM*{wo=8STLnv%JscpX(Xh)gO zjw&qJev)E8ALWnlpE)O%w_8k{NP>%)af|H2>D3Q5~Oxnb2EsP4pq&Yz}-%)D%re@-n=dh{@#~ zHeLq&#glo(?PoTyd8c;mJ_5Whxhvn@h{-s0p!}I}o>V&q;|i;D8UVM7r)I#hqM~jC zkzLnG=|EyhIxGtA!XN}CdY78-j=E^ok!}@8IYEMW{B~2E@u{@-4npoB`CouE)MkaS zOWjb%Tk87epUp9?xHew@GRzbRN!RpA)C$4{)X1z5hQ0)nPc4SH327{ZM@4eEkx9vw zdl2VL{(o38eu61YHQ|YyIj=UUdo;wfc&R#20gzHqzS-4svy_{pe5wntT#-%7koTu0 zQ+QG8DnxTOG9rhD6Y&|z?IMhAuiP2e#n^XWDTbYDFUrnkq55Se+h6?)V2CvbuA7gk zD&=Uah38_)Gi&)O=i}v=5{IXlbAJhcgR{201Q=wWo6O>x>WtOfR6i@u~_wiyi@V?lEw^KRv}b~;3(ZaZrOaEvLnRn{Fx z@?|b!@97#Vki{wTWmY?`eo`|D_1s)&m>NeO#FldRTs@gK*m63> z#>t)oa@WY}blNsL|GWcQojf?`^a9~o2tqTpFfaJQs->4n8=LmirmKb4cD%ITg=}^L zk!1BAX_j$Z%TIgG_VnZg*QaOn;f+I?yVpv(9P75JFt;|{455WKc!b4m0Hy>(kwr&6 zR>I)2oJ~3>H|aoXiHrv@w?4QE^*M+U>^^>xlGTV$X!( zUG)M?7(Jo6*XJ@1u;7*3eQe2LbiAIBKiyY6@Vy5<{wHEb9H&AZM9qI&r^qz?g#Y>X z*LFI`XyaP;gd|7OP@Lt#L5_YJ-Lw7w{xJQfVqrsm>E~M#XY%$k21a)y-(>yv{o76m zAqSDxu~F8QuP@B^pz)$R2FSMl!NTd2mlC^~Q!)p(O{g;rv zBvniIV@Mbk_*`uT5}6?$s<3)?TuC8h*F6Z_Us^#(AwQ!$=~f^OFe!8z-jqd##R0Y_ zM<L{BTv`2Rt^p%(gvqg)S`4vcsBCK7y=sf7F6OT(OFHiuNJB8=}LrjF54Olb(t7m z)G}8sQ%w6IBKS21AD0)p@2)^LsXgNcVaI5>I%&>qExLd_A9HViPkCCbwtDK)sCqDa zTlj6nocDG`W4l#)t~W1%xRP79_}SJNu2O`H+F1YX`!T^+cUDhwGReb$CJwjgymK?A zg9}P>gDxjM9$M!wuI;^cY=^8djI1o*X5S0*G_n~s3}lu5wAM+=^Bm!WA0VUvG`a20 zt5CpsN3sQt7RT6N8!c!5H7*L(J(|9Ow0`c{$5^z=ZVOfGO&thcnG#f~Ut#0gEJxkq z$z$*%(d^(uxZPhqv7Aw__3ymk=Gp=dz0QEp2vrClkc_X+1iy{FB?3Zd{^YwF@fD>cG(@Dxr7Q882Vm+yCw=En1oM3yjx6>=i}WiMVy?k5lB69#A>TYE7@ zHb%`@|keWyi6;i%)unHmR{A5lrcs|9GK!5SXD~=0D2J-ja;-(9hvG)2 zZ%6w~in&>(^}%;C*q1ea=^=E&O9+aPTM!H&Fp9;Fd90Y~FSV-!?#HdgrWMQYgqw(Q z^6rUA2ky>nSm3}Fj|C}*OQ#g7yd{H@h0Ifuvj(`B0|ZRn)ClG^8BIz71MeGdG6-w- zXdzFg3)NZevdPm%he0?KqUM(JKCKQKl7sSKk6;hXp$7~=frfXr8UEn&#^PsE1 z!KAnY0I2jdB#~fs+iu$Yh5R=iW(B}WI4K@`tGIM1a4}_6VT@cVh&KwOx_rD;afUhF zw&!Z8e#2eIRXXs+u~Yd)bnCfrnZYu_`dWzNPudbTzzGV zHoz_?0h&llgTlmiH^*Pk&Aq<07xP;-*&$F;(g9)trgCF{k&b*q65@h+mfSwIdQIMD zZI6Qmfy<`WFimvRS(q2iY}^6Ui!e1$!%eq=55(O~qvT1c^2<~dhV#Lzmns!hbPk#7myZ%SUUl%AaT5p7Ig+*Su&uQgxQU(bt-NE_8}cET8(ZKt1r-u5>O) zwZ_)+?e9u{r98=2=5iOvNM^A>6CWw=rwH!K04 zfY+S6ap9x0ZsS%m1!}X;10`ehyb(&E940d(!;ALBaDcJ&KoqM}$My=s*rpHtkGQ68 zpHkK3h|8?ffmbQ~5BD;Z%4BVL8+x)vCNsD`Ciw}OR= zmZo^zN|8;sp6=a%48{{qRE5FK()r}$AUIb$g%SuRaPJGFuYGeK1@Z9n;1napF+~Y; zC@#!n5!3pcJWcQ&s_5q+cC6i=P>r28p)t8QKr4Mz#SwS!O+RsT!XqveJYP>0_4kPD z5kGaWPBwR6YR>Al9gV?QMV|p}r%E?ubV0zGaV~t6C3^=OwPu89evcm9K>JU=tT9A1 ziQB{jhpI(@0w0;R;)G2RJIa~ZtePP;6A$3yTWi2o#n@s8YV2uTrraF$c)1)N zYwQ9DVs6ee*oR?C076x$Agv(fLVS4T0slJ=M@diNMB=5QbWbFZT84v^y1XonElLMI$a`tZUS#hCdV|!!V7pT3BsEr@&! z>$Mi|go#3`NJQnqU~6i4c_4+1V?@YFoY~np@LrwYze=N@Po- zO*?~7Amn!1&a3g&2w!AM`0g zQ}W_OYvxHBCvmNkqw-~E%471m7&~KsmbsqkN(waTO#!11tjBw+*`k>hmT+KkN(3$| z%x4oHwUAVNRzDqQ#z3V*;IaJ3@KYR0Ro7LUdtWFpA&_bd)L*{$ayw#pKNRJuf_VJ} z%?J2z{DSX}B3BF`Gl6nWu!P~B>E~HXllSnK0WMElF%#HVQW)W@t|AA&yRJGhf4ArAo!4My&*PGr!ydGnG$seC*{@nz zkYex8uUzIUekZHPwZPy0!}a4EyiC^bkno={aGE$gusr|KS&KepoNPu?-QRN4I2(%+24b}3jxr~=9P_+6Qx_U4V}$o`)WCh|o-rxJ%vfLw;kH1=0SW{4u#tid` z0f&98dSa+2?9ad}mIuv^-Qs(zbmB|<&t@ktY|Pf=e@F7@bawBE^naE^ASMPP^qn4_ z+}4X4c%4A619$06rmOPP%Db#SE@^S!+=5*eVXKL)8R|G)!Rrt$5Q9-n($y_+wcD6K zl`zDgpVs8A^_Rsyj+x}zT1N<_@CcuWl^Tmeh1o-zWIdBu*9A^CRwyt&z#>lEvf1{6 zte4%qIVs80BYcRtio*LfOgbMTLxs@FG~G=C7_@+u;Zq zQy#1<5r?Wcq;)~Rh7_UoB6RJ~c${@e&j8-tsTbUC4+d$bNm1)y-O>Vo7ds_0mK2Oj z{)d;a89kclACtPd_NDeZbaj>Cbar1WVB9mgy7t5Y+uD9K(Q>9+3rk;9r_Q}o^L%hzS?0>OuJbA})mn**8NXwPwJmu10_nFEyY#x&&)?X~3>^jw=%>_-pm-9Wf-f&_V zMXI(9OA@~?yqb0zT)Sjfeah-Ueq4`8WU=H!7wiBqu&^C}V)3 zajpI!Dx30a@WrqH65VMJ#* zM27RFnkjpd(?9QO>zMb_s(di7Kc)_sJn9N=7Z3T|3>aTfG4BS!xgA=Dxr?KGHiFXj z|NJg$pP{(@KXuk@4>HPQjMr2L^nQDG#lw?k@73o~B`;J+Q&iljm`r$+CD???pIAJu8XP%PfI=dkek@=zMOk8}CLdKw!QjG!asO9m_aKbuX=O*cKuA zE3ObA0ObF$(zQT}3QRF5MR-mPa$WxXUF&mNYnBt~|)=lu?s5~U>6?udnoYl?; zqN}y;jfG@X1!1@b!(ge6XW*QA*VHf2b(2B$h8Q9J0c@FW+OgKAfn#jw1r@SqWAD

WX|mb6C0-afM%TA3Yscdm96@(2RK3|^x$ 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 z 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%0AOr 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

34{8Y^h&8((j9Eg+(nEJXM^{P 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�u*h(_Mj?~fHq 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�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%0D&GDy+J*oHPvpBxHpp=Dv+< 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 *SSB%yc{^hOz1S{vTEg3q-6TVeuwb4@O=vsXP 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 X9eWOs+PmMu;9ut0*~S)wrSSg&Slo$? literal 0 HcmV?d00001 diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..8c1e3f2 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,28 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "booru-viewer" +version = "0.1.0" +description = "Local booru image browser with Qt6 GUI and Textual TUI" +requires-python = ">=3.11" +dependencies = [ + "httpx[http2]>=0.27", + "Pillow>=10.0", +] + +[project.optional-dependencies] +gui = ["PySide6>=6.6"] +tui = ["textual>=0.50"] +all = ["booru-viewer[gui,tui]"] + +[project.scripts] +booru-gui = "booru_viewer.main_gui:main" +booru-tui = "booru_viewer.main_tui:main" + +[tool.hatch.build.targets.wheel] +packages = ["booru_viewer"] + +[tool.hatch.build.targets.sdist] +include = ["booru_viewer"]