popafox 0.6.1__tar.gz

popafox-0.6.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: popafox
+Version: 0.6.1
+Summary: Utility for patching your firefox, hide webdriver detecting
+Requires-Dist: configparser>=7.2.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pillow>=13.0.0
+Requires-Dist: psutil>=7.2.2
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: pywin32>=312 ; sys_platform == 'win32' and extra == 'windows'
+Requires-Python: >=3.14
+Project-URL: Homepage, https://gitflic.ru/project/kurilka/popafox
+Project-URL: Github, https://github.com/TheWhatis/popafox
+Provides-Extra: windows
+Description-Content-Type: text/markdown
+

popafox-0.6.1/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "popafox"
+version = "0.6.1"
+description = "Utility for patching your firefox, hide webdriver detecting"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "configparser>=7.2.0",
+    "jinja2>=3.1.6",
+    "loguru>=0.7.3",
+    "pillow>=13.0.0",
+    "psutil>=7.2.2",
+    "pydantic>=2.14.1",
+]
+
+[project.scripts]
+popafox = "popafox:main"
+
+[project.urls]
+Homepage = "https://gitflic.ru/project/kurilka/popafox"
+Github = "https://github.com/TheWhatis/popafox"
+
+[project.optional-dependencies]
+windows = ["pywin32>=312 ; sys_platform == 'win32'"]
+
+[build-system]
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.40.2",
+    "epc>=0.0.5",
+    "six>=1.17.0",
+    "twine>=7.0.0",
+    "watchdog>=6.0.0",
+]
+
+[tool.uv.sources.clipik]
+workspace = true

popafox-0.6.1/pyproject.toml.orig

@@ -0,0 +1,42 @@
+[project]
+name = "popafox"
+version = "0.6.1"
+description = "Utility for patching your firefox, hide webdriver detecting"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "configparser>=7.2.0",
+    "jinja2>=3.1.6",
+    "loguru>=0.7.3",
+    "pillow>=13.0.0",
+    "psutil>=7.2.2",
+    "pydantic>=2.14.1",
+]
+
+[project.scripts]
+popafox = "popafox:main"
+
+[build-system]
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.40.2",
+    "epc>=0.0.5",
+    "six>=1.17.0",
+    "twine>=7.0.0",
+    "watchdog>=6.0.0",
+]
+
+[project.urls]
+Homepage = "https://gitflic.ru/project/kurilka/popafox"
+Github = "https://github.com/TheWhatis/popafox"
+
+[project.optional-dependencies]
+windows = [
+    "pywin32>=312 ; sys_platform == 'win32'",
+]
+
+[tool.uv.sources]
+clipik = { workspace = true }

popafox-0.6.1/src/popafox/__init__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

popafox-0.6.1/src/popafox/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == '__main__':
+    main()

popafox-0.6.1/src/popafox/cli.py

@@ -0,0 +1,163 @@
+import argparse
+import os
+import sys
+import signal
+from loguru import logger
+from pathlib import Path
+from .patch import patch
+from .model import MainConfig, Config
+from .container import Container
+from .config import write_fresh_config, read_config_file
+from .logger import initialize_logger
+
+
+def _add_default_options(parser: argparse.ArgumentParser):
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f"{Container.program} {Container.version}"
+    )
+
+    parser.add_argument(
+        '--config',
+        dest='config',
+        type=Path,
+        default=None,
+        metavar='PATH',
+        help='Force choice config file',
+    )
+
+    parser.add_argument(
+        '--log-level',
+        dest='log_level',
+        type=str,
+        default=None,
+        metavar='LEVEL',
+        help='Logging level, default [INFO]'
+    )
+
+    parser.add_argument(
+        '--log-dir',
+        dest='log_dir',
+        type=Path,
+        default=None,
+        metavar='PATH',
+        help='Force choice log directory',
+    )
+
+    parser.add_argument(
+        '--src',
+        dest='src',
+        type=Path,
+        default=None,
+        metavar='PATH',
+        help='Source firefox directory'
+    )
+
+    parser.add_argument(
+        '--dst',
+        dest='dst',
+        type=Path,
+        default=None,
+        metavar='PATH',
+        help='Destination firefox directory (patched)'
+    )
+
+    parser.add_argument(
+        '--no-confirm',
+        dest='no_confirm',
+        action='store_true',
+        help='Skip confirmation prompts'
+    )
+
+    parser.add_argument(
+        '-y', '--yes',
+        dest='assume_yes',
+        action='store_true',
+        help='Assume yes'
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=Container.program,
+        description='Synchronize clipboard by network',
+    )
+
+    _add_default_options(parser)
+
+    return parser
+
+
+def _initialize_loop(container: Container, log_prefix: str):
+    initialize_logger(container.config, log_prefix)
+
+    if container.fresh_config:
+        logger.info('Config has been freshed [{}]', container.fresh_config_path)
+
+    logger.info('Initialized config')
+    for key, value in container.config.model_dump().items():
+        logger.info('Config [{}]=[{}]', key, value)
+
+
+def _main(container: Container):
+    _initialize_loop(container, 'main')
+
+    try:
+        patch(
+            container.config.src,
+            container.config.dst,
+            container.config.no_confirm,
+            container.config.assume_yes,
+        )
+    except KeyboardInterrupt:
+        print("Bye-bye!!!", file=sys.stderr)
+        sys.exit(130)
+
+
+def main():
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    def _shutdown_handler(signum, frame):
+        raise SystemExit(128 + signum)
+
+    signal.signal(signal.SIGINT, _shutdown_handler)
+    signal.signal(signal.SIGTERM, _shutdown_handler)
+
+    if os.name == 'nt': # Windows
+        config_path = Path(os.getenv('APPDATA', '~')) / 'popafox'
+    elif sys.platform == 'darwin': # MacOS
+        config_path = Path('~/Library/Application Support/Popafox').expanduser()
+    else: # Linux / Unix
+        config_path = Path('~/.config/popafox').expanduser()
+
+    config = MainConfig
+    config_path = config_path / 'config.json'
+    fresh_config_path = config_path
+    fresh_config: Config = write_fresh_config(fresh_config_path, config)
+
+    overrides = {
+        key: value
+        for key, value in vars(args).items()
+        if value is not None
+    }
+
+    config_path: Path = overrides.get('config', config_path)
+    config: Config = read_config_file(config_path, config, overrides)
+
+    try:
+        container = Container(
+            config=config,
+            fresh_config=fresh_config,
+            fresh_config_path=fresh_config_path,
+            config_path=config_path,
+        )
+    except Exception as e:
+        initialize_logger(config, args.command)
+        logger.critical('Error [{}] container initialization', e)
+        return
+
+    _main(container)
+
+    # parser.error('Command not passed, write [mux, server], for details use --help')

popafox-0.6.1/src/popafox/config.py

@@ -0,0 +1,102 @@
+import os
+import sys
+import json
+from pathlib import Path
+from .model import Config, MainConfig
+
+
+def _build_def_config(config: type[Config]) -> Config:
+    log_level = os.getenv('POPAFOX_LOG_LEVEL', default='INFO')
+    log_dir = os.getenv('POPAFOX_LOG_DIR', default=None)
+
+    if log_dir: # Env POPAFOX_LOG_DIR
+        log_dir = Path(log_dir).expanduser()
+    elif os.name == 'nt': # Windows
+        log_dir = Path(os.getenv('APPDATA', '~')) / 'popafox'
+    elif sys.platform == 'darwin':
+        log_dir = Path('~/Library/Appliction Support/Popafox').expanduser()
+    else: # Linux / Unix
+        log_dir = Path('~/.local/popafox').expanduser()
+
+    src = os.getenv('POPAFOX_SRC', default=None)
+
+    if src:
+        src = Path(src).expanduser()
+    elif os.name == 'nt': # Windows
+        src = Path('C:/Program Files/Firefox')
+    elif sys.platform == 'darwin': # MacOS
+        raise RuntimeError('MacOS does not supports')
+    else: # Linux / Unix
+        src = Path('/usr/lib/firefox')
+
+    dst = os.getenv('POPAFOX_DST', default=None)
+
+    if dst:
+        dst = Path(dst).expanduser()
+    elif os.name == 'nt': # Windows
+        dst = Path(os.getenv('APPDATA', '~')) / 'Firefox Undetected'
+    elif sys.platform == 'darwin': # MacOS
+        dst = Path('~/Library/Application Support/Firefox Undetected').expanduser()
+    else: # Linux / Unix
+        dst = Path('~/.local/firefox_undetected').expanduser()
+
+    return config(
+        log_dir=log_dir,
+        log_level=log_level,
+        src=src,
+        dst=dst,
+        no_confirm=True if os.getenv('POPAFOX_NO_CONFIRM', default='False') in ('True', 't', '1', 1) else False,
+        assume_yes=True if os.getenv('POPAFOX_ASSUME_YES', default='False') in ('True', 't', '1', 1) else False,
+    )
+
+
+def write_fresh_config(path: Path, config: type[Config]) -> bool:
+    """Создает файл конфига с нуля, если его нет."""
+    if path.exists():
+        return False
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    config: Config = _build_def_config(config)
+    payload = config.model_dump(
+        mode='json',
+        include=set([
+            'log_level',
+            'log_dir',
+            'src',
+            'dst',
+            'no_confirm',
+            'assume_yes',
+        ]),
+    )
+
+    path.write_text(json.dumps(payload, indent=2) + '\n', encoding='utf-8')
+    return True
+
+
+def read_config_file(
+    path: Path,
+    config: type[Config],
+    overrides: dict[str, object] = {},
+) -> Config:
+    if not path.exists():
+        write_fresh_config(path, config)
+
+    raw = path.read_text(encoding='utf-8')
+
+    def_config = _build_def_config(config)
+    merged = {**json.loads(raw), **(overrides if overrides else {})}
+
+    for key in config.model_fields:
+        if key in merged and merged[key]:
+            continue
+
+        merged[key] = getattr(def_config, key)
+
+    config = config(**merged)
+
+    config.src = config.src.expanduser()
+    config.dst = config.dst.expanduser()
+    config.log_dir = config.log_dir.expanduser()
+
+    return config

popafox-0.6.1/src/popafox/constants.py

@@ -0,0 +1 @@
+SEARCH_WEBDRIVER_BINARY = b"webdriver"

popafox-0.6.1/src/popafox/container.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from importlib.metadata import version, PackageNotFoundError
+from pathlib import Path
+import tomllib
+from .model import Config
+
+
+def _resolve_version() -> str:
+    try:
+        return version('fofan')
+    except PackageNotFoundError:
+        pass
+
+    # fallback: запуск из исходников
+    pyproject = Path(__file__).resolve().parent.parent / 'pyproject.toml'
+    try:
+        with pyproject.open('rb') as f:
+            data = tomllib.load(f)
+        return data['project']['version']
+    except (OSError, KeyError):
+        return 'unknown'
+
+
+class Container:
+    program: str = 'fofan'
+    version: str = _resolve_version()
+
+    config: Config
+    fresh_config: bool
+    fresh_config_path: Path
+    config_path: Path
+
+    def __init__(
+        self,
+        config: Config,
+        fresh_config: bool,
+        fresh_config_path: Path,
+        config_path: Path,
+    ):
+        self.config = config
+        self.fresh_config = fresh_config
+        self.fresh_config_path = fresh_config_path
+        self.config_path = config_path

popafox-0.6.1/src/popafox/functions.py

@@ -0,0 +1,149 @@
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from loguru import logger
+
+
+def _ask_via_tkinter(prompt: str) -> bool | None:
+    try:
+        import tkinter as tk
+        from tkinter import ttk
+    except ImportError:
+        return None
+
+    root = tk.Tk()
+    root.withdraw()
+
+    dialog = tk.Toplevel(root)
+    dialog.title("Confirmation")
+    dialog.geometry("400x150")
+    dialog.resizable(False, False)
+    dialog.attributes('-topmost', True)
+    dialog.focus_force()
+
+    frame = ttk.Frame(dialog, padding=16)
+    frame.pack(fill='both', expand=True)
+    ttk.Label(frame, text=prompt, wraplength=360).pack(pady=(0, 16))
+
+    result = {'answer': False}
+
+    # root.quit() закрывает mainloop, после чего мы уничтожаем окна
+    def _yes():
+        result['answer'] = True; root.quit()
+
+    def _no():
+        result['answer'] = False; root.quit()
+
+    btn_frame = ttk.Frame(frame)
+    btn_frame.pack(fill='x')
+    ttk.Button(btn_frame, text="Да", command=_yes, width=10).pack(side='right', padx=(8, 0))
+    ttk.Button(btn_frame, text="Нет", command=_no, width=10).pack(side='right')
+
+    dialog.protocol("WM_DELETE_WINDOW", _no)
+    dialog.bind('<Return>', lambda e: _yes())
+    dialog.bind('<Escape>', lambda e: _no())
+
+    # Ловим Ctrl+C прямо внутри окна Tkinter
+    dialog.bind('<Control-c>', lambda e: _no())
+
+    try:
+        root.mainloop()
+    except KeyboardInterrupt:
+        result['answer'] = False
+        raise
+
+    # Уничтожаем всё аккуратно
+    try:
+        root.destroy()
+    except Exception:
+        pass
+
+    return result['answer']
+
+
+def _ask_via_linux_dialog(prompt: str) -> bool | None:
+    """Пробует zenity или kdialog (работают и в Xorg, и в Wayland)."""
+    # zenity: возвращает 0 при Yes, 1 при No
+    zenity = shutil.which("zenity")
+
+    if zenity:
+        try:
+            result = subprocess.run(
+                [zenity, "--question", "--ok-label=Да", "--cancel-label=Нет", f"--text={prompt}"],
+                capture_output=True,
+            )
+            return result.returncode == 0
+        except Exception as e:
+            logger.error('Zenity error [{}]', e)
+            pass
+    else:
+        logger.info('Zenity does not exists for confirmation')
+
+    # kdialog: возвращает 0 при Yes, 1 при No
+    kdialog = shutil.which("kdialog")
+    if kdialog:
+        try:
+            result = subprocess.run(
+                [kdialog, "--yesno", prompt],
+                capture_output=True,
+            )
+            return result.returncode == 0
+        except Exception as e:
+            logger.error('Kdialog error [{}]', e)
+            pass
+    else:
+        logger.info('Kdialog does not exists for confirmation')
+
+    return None
+
+
+def _ask_via_terminal(prompt: str) -> bool:
+    """Последний fallback — обычный ввод в терминале."""
+    try:
+        answer = input(f"{prompt} [y/N] ").strip().lower()
+    except EOFError as e:
+        logger.error('Fallback confirmation error [{}]', e)
+        return False
+
+    return answer in ("y", "yes", "д", "да")
+
+
+def ask_confirmation(prompt: str = "Продолжить?") -> bool:
+    """
+    Показывает подтверждение в максимально подходящем для окружения виде:
+    - Windows / macOS  -> нативное окно tkinter
+    - Linux + Wayland  -> zenity/kdialog (Wayland-совместимые)
+    - Linux + Xorg     -> zenity/kdialog (X11)
+    - иначе            -> терминал (input)
+    """
+    platform = sys.platform
+
+    if sys.platform == 'darwin':
+        result = _ask_via_tkinter(prompt)
+        if result is not None:
+            return result
+        return _ask_via_terminal(prompt)
+    elif platform.startswith("linux"):
+        is_wayland = bool(os.environ.get("WAYLAND_DISPLAY"))
+        is_xorg = bool(os.environ.get("DISPLAY"))
+
+        if is_wayland or is_xorg:
+            # если системного диалога нет — пробуем tkinter
+            result = _ask_via_tkinter(prompt)
+            if result is not None:
+                return result
+
+            # zenity/kdialog умеют работать в обоих окружениях
+            result = _ask_via_linux_dialog(prompt)
+            if result is not None:
+                return result
+
+        # нет графического окружения или диалоговых утилит
+        return _ask_via_terminal(prompt)
+    else:
+        result = _ask_via_tkinter(prompt)
+        if result is not None:
+            return result
+        return _ask_via_terminal(prompt)

popafox-0.6.1/src/popafox/logger.py

@@ -0,0 +1,103 @@
+import sys
+import gzip
+import shutil
+import datetime
+from pathlib import Path
+from loguru import logger
+from .model import Config
+
+
+class _Rotator:
+    """Ротация по размеру ИЛИ по времени. Что сработает раньше - то и ротирует."""
+
+    def __init__(self, *, size: int, at: datetime.time):
+        self._size_limit = size
+        now = datetime.datetime.now()
+        self._time_limit = now.replace(
+            hour=at.hour, minute=at.minute, second=at.second, microsecond=0
+        )
+        # Если сейчас уже позже целевого времени - цель на завтра,
+        # чтобы не ротировать сразу же при старте.
+        if now >= self._time_limit:
+            self._time_limit += datetime.timedelta(days=1)
+
+    def should_rotate(self, message, file) -> bool:
+        # Условие 1: размер
+        file.seek(0, 2)
+
+        if file.tell() + len(message) > self._size_limit:
+            return True
+
+        # Условие 2: время
+        excess = message.record['time'].timestamp() - self._time_limit.timestamp()
+        if excess >= 0:
+            elapsed_days = datetime.timedelta(seconds=excess).days
+            self._time_limit += datetime.timedelta(days=elapsed_days + 1)
+            return True
+
+        return False
+
+
+def _compress_all_logs_except_active(log_dir: Path, active_name: str) -> None:
+    """Сжимает ВСЕ .log в директории, кроме активного файла."""
+    for log_file in sorted(log_dir.glob('*.log')):
+        if log_file.name == active_name:
+            continue
+
+        gz_path = log_file.with_suffix('.log.gz')
+
+        # Если .gz уже есть - исходник удаляем, он лишний
+        if gz_path.exists():
+            log_file.unlink()
+            continue
+
+        try:
+            with open(log_file, 'rb') as f_in, gzip.open(gz_path, 'wb') as f_out:
+                shutil.copyfileobj(f_in, f_out)
+            log_file.unlink()
+        except Exception as e:
+            # Не валим сервер из-за одного битого файла
+            logger.error('Failed to compress [{}]: [{}]', log_file, e)
+
+
+def initialize_logger(config: Config, prefix: str) -> None:
+    global logger
+
+    log_dir = config.log_dir / prefix
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    today = datetime.date.today().strftime('%Y-%m-%d')
+    active_name = f"{today}.log"
+
+    # Сначала сжимаем всё старое, потом открываем логгер.
+    # Порядок важен: если делать наоборот, Loguru займёт активный
+    # файл, и он попадёт в сжатие.
+    _compress_all_logs_except_active(log_dir, active_name)
+
+    logger.remove()
+
+    filepath = str(log_dir / '{time:YYYY-MM-DD}.log')
+    rotator = _Rotator(size=10 * 1024 * 1024, at=datetime.time(0, 0, 0))
+
+    logger.add(
+        filepath,
+        level=config.log_level,
+        encoding='utf-8',
+        rotation=rotator.should_rotate,
+        compression='gz'
+    )
+
+    logger.add(
+        sys.stdout,
+        level=config.log_level,
+        colorize=True
+    )
+
+    logger.add(
+        sys.stderr,
+        level='ERROR',
+        colorize=True,
+    )
+
+    logger.info('Log level: [{}]',config.log_level)
+    logger.info('Log file is [{}]', filepath)

popafox-0.6.1/src/popafox/model.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from pydantic import BaseModel
+
+
+class BaseConfig(BaseModel):
+    log_dir: Path
+    log_level: str
+    src: Path
+    dst: Path
+    no_confirm: bool
+    assume_yes: bool
+
+
+class MainConfig(BaseConfig):
+    pass
+
+
+Config = MainConfig