hwgdreqs 0.8.0__py3-none-any.whl

hwgdreqs/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

hwgdreqs/api_server.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import json
+import threading
+from dataclasses import asdict
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import parse_qs, urlparse
+
+from hwgdreqs.queue_manager import QueueManager
+from hwgdreqs.twitch_auth import TwitchSession, get_channel_moderate_enabled, ban_twitch_user
+
+
+def _make_handler(queue: QueueManager, session: TwitchSession | None = None):
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, format: str, *args) -> None:
+            return
+
+        def _send_json(self, payload: object, status: int = 200) -> None:
+            data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+        def _read_json(self) -> dict:
+            length_raw = self.headers.get("Content-Length")
+            if not length_raw:
+                return {}
+            try:
+                length = int(length_raw)
+            except ValueError:
+                return {}
+            if length <= 0:
+                return {}
+            raw = self.rfile.read(length)
+            try:
+                return json.loads(raw.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                return {}
+
+        def _params(self) -> dict[str, str]:
+            parsed = urlparse(self.path)
+            qs = parse_qs(parsed.query)
+            out: dict[str, str] = {}
+            for k, v in qs.items():
+                if v:
+                    out[k] = v[0]
+            if self.command == "POST":
+                body = self._read_json()
+                for k, v in body.items():
+                    if isinstance(v, str):
+                        out[k] = v
+            return out
+
+        def _find_entry(self, level_id: str):
+            for entry in queue.levels:
+                if str(entry.id) == level_id:
+                    return entry
+            return None
+
+        def do_GET(self) -> None:
+            path = urlparse(self.path).path
+            if path == "/queue":
+                params = self._params()
+                if "row" in params:
+                    try:
+                        row = int(params["row"])
+                        levels = queue.levels
+                        if row >= 0 and row < len(levels):
+                            self._send_json({"level": asdict(levels[row])})
+                        else:
+                            self._send_json({"ok": False, "error": "invalid_row"}, status=400)
+                    except ValueError:
+                        self._send_json({"ok": False, "error": "invalid_row"}, status=400)
+                else:
+                    self._send_json({"levels": [asdict(e) for e in queue.levels]})
+                return
+            if path == "/current":
+                levels = queue.levels
+                self._send_json({"level": asdict(levels[0]) if levels else None})
+                return
+            if path == "/add":
+                from hwgdreqs.gdbrowser import fetch_level
+                params = self._params()
+                level_id = params.get("id") or params.get("level_id") or ""
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                
+                level_data = fetch_level(level_id)
+                if not level_data:
+                    self._send_json({"ok": False, "error": "level_not_found"}, status=404)
+                    return
+                
+                success = queue.add_level(
+                    level_id=level_id,
+                    name=level_data.get("name", ""),
+                    author=level_data.get("author", ""),
+                    difficulty=level_data.get("difficulty", ""),
+                    requester="API",
+                    platform="custom",
+                    description=level_data.get("description", ""),
+                    length=level_data.get("length", ""),
+                    large=bool(level_data.get("large", False)),
+                    two_player=bool(level_data.get("twoPlayer", False)),
+                    disliked=bool(level_data.get("disliked", False)),
+                )
+                
+                if success:
+                    self._send_json({"ok": True})
+                else:
+                    self._send_json({"ok": False, "error": "add_failed"}, status=400)
+                return
+            if path in ("/delete", "/banauthor", "/banrequester", "/blacklistlevel", "/clear", "/bantwitch"):
+                params = self._params()
+                level_id = params.get("id") or params.get("level_id") or ""
+
+                if path == "/delete":
+                    if not level_id:
+                        self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                        return
+                    queue.remove_level(level_id)
+                    self._send_json({"ok": True})
+                    return
+
+                if path == "/banrequester":
+                    if not level_id:
+                        self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                        return
+                    entry = self._find_entry(level_id)
+                    if not entry:
+                        self._send_json({"ok": False, "error": "not_found"}, status=404)
+                        return
+                    queue.blacklist_requester(entry.requester)
+                    self._send_json({"ok": True})
+                    return
+                
+                if path == "/banauthor":
+                    if not level_id:
+                        self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                        return
+                    entry = self._find_entry(level_id)
+                    if not entry:
+                        self._send_json({"ok": False, "error": "not_found"}, status=404)
+                        return
+                    queue.blacklist_author(entry.author)
+                    self._send_json({"ok": True})
+                    return
+
+                if path == "/blacklistlevel":
+                    if not level_id:
+                        self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                        return
+                    queue.blacklist_level(level_id)
+                    self._send_json({"ok": True})
+                    return
+
+                if path == "/bantwitch":
+                    if not level_id:
+                        self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                        return
+                    entry = self._find_entry(level_id)
+                    if not entry:
+                        self._send_json({"ok": False, "error": "not_found"}, status=404)
+                        return
+                    if not session:
+                        self._send_json({"ok": False, "error": "no_twitch_session"}, status=400)
+                        return
+                    if not get_channel_moderate_enabled():
+                        self._send_json({"ok": False, "error": "moderation_not_enabled"}, status=400)
+                        return
+                    if entry.requester.lower() == session.login.lower():
+                        self._send_json({"ok": False, "error": "cannot_ban_self"}, status=400)
+                        return
+                    error = ban_twitch_user(session, entry.requester)
+                    if error:
+                        self._send_json({"ok": False, "error": error}, status=400)
+                    else:
+                        self._send_json({"ok": True})
+                    return
+
+                queue.clear_queue()
+                self._send_json({"ok": True})
+                return
+            self._send_json({"ok": False, "error": "not_found"}, status=404)
+
+        def do_POST(self) -> None:
+            path = urlparse(self.path).path
+            params = self._params()
+            level_id = params.get("id") or params.get("level_id") or ""
+
+            if path == "/delete":
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                queue.remove_level(level_id)
+                self._send_json({"ok": True})
+                return
+
+            if path == "/banrequester":
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                entry = self._find_entry(level_id)
+                if not entry:
+                    self._send_json({"ok": False, "error": "not_found"}, status=404)
+                    return
+                queue.blacklist_requester(entry.requester)
+                self._send_json({"ok": True})
+                return
+            
+            if path == "/banauthor":
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                entry = self._find_entry(level_id)
+                if not entry:
+                    self._send_json({"ok": False, "error": "not_found"}, status=404)
+                    return
+                queue.blacklist_author(entry.author)
+                self._send_json({"ok": True})
+                return
+
+            if path == "/blacklistlevel":
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                queue.blacklist_level(level_id)
+                self._send_json({"ok": True})
+                return
+
+            if path == "/bantwitch":
+                if not level_id:
+                    self._send_json({"ok": False, "error": "missing_id"}, status=400)
+                    return
+                entry = self._find_entry(level_id)
+                if not entry:
+                    self._send_json({"ok": False, "error": "not_found"}, status=404)
+                    return
+                if not session:
+                    self._send_json({"ok": False, "error": "no_twitch_session"}, status=400)
+                    return
+                if not get_channel_moderate_enabled():
+                    self._send_json({"ok": False, "error": "moderation_not_enabled"}, status=400)
+                    return
+                if entry.requester.lower() == session.login.lower():
+                    self._send_json({"ok": False, "error": "cannot_ban_self"}, status=400)
+                    return
+                error = ban_twitch_user(session, entry.requester)
+                if error:
+                    self._send_json({"ok": False, "error": error}, status=400)
+                else:
+                    self._send_json({"ok": True})
+                return
+
+            if path == "/clear":
+                queue.clear_queue()
+                self._send_json({"ok": True})
+                return
+
+            self._send_json({"ok": False, "error": "not_found"}, status=404)
+
+    return Handler
+
+
+class ApiServer:
+    def __init__(self, queue: QueueManager) -> None:
+        self._queue = queue
+        self._local_httpd: ThreadingHTTPServer | None = None
+        self._local_thread: threading.Thread | None = None
+        self._network_httpd: ThreadingHTTPServer | None = None
+        self._network_thread: threading.Thread | None = None
+        self._session: TwitchSession | None = None
+        self._local_port: int = 6767
+        self._host_to_network: bool = False
+        self._network_port: int = 0
+
+    def set_config(self, local_port: int, host_to_network: bool, network_port: int) -> None:
+        restart = (self._local_port != local_port or \
+                  self._host_to_network != host_to_network or \
+                  self._network_port != network_port)
+        self._local_port = local_port
+        self._host_to_network = host_to_network
+        self._network_port = network_port
+        if restart:
+            self.stop()
+            self.start()
+
+    def set_session(self, session: TwitchSession | None) -> None:
+        self._session = session
+        self.stop()
+        self.start()
+
+    def start(self) -> bool:
+        success = False
+        # local server
+        if self._local_thread and self._local_thread.is_alive():
+            success = True
+        else:
+            handler = _make_handler(self._queue, self._session)
+            try:
+                self._local_httpd = ThreadingHTTPServer(("127.0.0.1", self._local_port), handler)
+                self._local_thread = threading.Thread(target=self._local_httpd.serve_forever, daemon=True)
+                self._local_thread.start()
+                success = True
+            except OSError:
+                pass
+        
+        # network server if on
+        if self._host_to_network:
+            if not (self._network_thread and self._network_thread.is_alive()):
+                handler = _make_handler(self._queue, self._session)
+                try:
+                    self._network_httpd = ThreadingHTTPServer(("0.0.0.0", self._network_port), handler)
+                    self._network_thread = threading.Thread(target=self._network_httpd.serve_forever, daemon=True)
+                    self._network_thread.start()
+                    success = True
+                except OSError:
+                    pass
+        
+        return success
+
+    def stop(self) -> None:
+        # stop local server
+        if self._local_httpd:
+            try:
+                self._local_httpd.shutdown()
+            except OSError:
+                pass
+            try:
+                self._local_httpd.server_close()
+            except OSError:
+                pass
+            self._local_httpd = None
+            
+        # stop network server
+        if self._network_httpd:
+            try:
+                self._network_httpd.shutdown()
+            except OSError:
+                pass
+            try:
+                self._network_httpd.server_close()
+            except OSError:
+                pass
+            self._network_httpd = None

hwgdreqs/config.py

@@ -0,0 +1,123 @@
+import base64
+import json
+import os
+import sys
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+APP_NAME = "HwGDReqs"
+APP_VERSION = "0.8.0"
+
+TWITCH_CLIENT_ID = "hq65d75rdxry2cfjgemvydqp2vfr84"
+TWITCH_SCOPES = ["chat:read", "user:read:email"]
+TWITCH_CHAT_EDIT_SCOPE = "chat:edit"
+TWITCH_CHANNEL_MODERATE_SCOPE = ["channel:moderate", "moderator:manage:banned_users"]
+TWITCH_DEVICE_URL = "https://id.twitch.tv/oauth2/device"
+TWITCH_TOKEN_URL = "https://id.twitch.tv/oauth2/token"
+TWITCH_USERS_URL = "https://api.twitch.tv/helix/users"
+TWITCH_IRC_HOST = "irc.chat.twitch.tv"
+TWITCH_IRC_PORT = 6667
+
+LEVEL_ID_PATTERN = r"\b(\d{7,9})\b"
+COMMA_LEVEL_ID_PATTERN = r"\b(\d{1,3}(?:,\d{3})+)\b"
+
+
+def app_root() -> Path:
+    if getattr(sys, "frozen", False):
+        # use _MEIPASS 
+        return Path(sys._MEIPASS)
+    return Path(__file__).resolve().parent.parent
+
+
+def exec_dir() -> Path:
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).parent
+    return Path(__file__).resolve().parent.parent
+
+
+import sys
+import shutil
+
+def data_dir() -> Path:
+    if sys.platform == "win32":
+        # Windows
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        new_path = base / APP_NAME
+        
+        # old data chek
+        old_base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+        old_path = old_base / APP_NAME
+        
+        if old_path.exists() and not new_path.exists():
+            shutil.copytree(old_path, new_path)
+            # bye old data :3
+            shutil.rmtree(old_path)
+        
+        new_path.mkdir(parents=True, exist_ok=True)
+        return new_path
+    elif sys.platform == "darwin":
+        # macOS
+        base = Path.home() / "Library" / "Application Support" / APP_NAME
+        base.mkdir(parents=True, exist_ok=True)
+        return base
+    else:
+        # Linux
+        base = Path.home() / ".config" / APP_NAME
+        base.mkdir(parents=True, exist_ok=True)
+        return base
+
+
+def asset_path(name: str) -> Path:
+    return app_root() / "assets" / name
+
+
+def queue_file() -> Path:
+    return data_dir() / "data.json"
+
+
+def token_file() -> Path:
+    return data_dir() / "auth.dat"
+
+
+def encode_token(data: dict) -> str:
+    raw = json.dumps(data).encode("utf-8")
+    return base64.b64encode(raw).decode("ascii")
+
+
+def decode_token(encoded: str) -> dict | None:
+    try:
+        raw = base64.b64decode(encoded.encode("ascii"))
+        return json.loads(raw.decode("utf-8"))
+    except (ValueError, json.JSONDecodeError):
+        return None
+
+
+def save_auth(data: dict) -> None:
+    token_file().write_text(encode_token(data), encoding="utf-8")
+
+
+def load_auth() -> dict | None:
+    path = token_file()
+    if not path.exists():
+        return None
+    return decode_token(path.read_text(encoding="utf-8"))
+
+
+def clear_auth() -> None:
+    path = token_file()
+    if path.exists():
+        path.unlink()
+
+
+def get_local_ip() -> str:
+    """Get the local IPv4 address of the machine."""
+    import socket
+    try:
+        # dummy socket to a public server to find the local IP
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+            s.connect(("8.8.8.8", 80))  # Doesn't need to actually connect
+            return s.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"  # Fallback to localhost

hwgdreqs/gdbrowser.py

@@ -0,0 +1,17 @@
+import requests
+
+GDBROWSER_LEVEL_URL = "https://gdbrowser.com/api/level/{level_id}"
+
+def fetch_level(level_id: str) -> dict | None:
+    try:
+        response = requests.get(
+            GDBROWSER_LEVEL_URL.format(level_id=level_id),
+            timeout=10,
+        )
+        response.raise_for_status()
+        data = response.json()
+        if not data.get("name"):
+            return None
+        return data
+    except (requests.RequestException, ValueError):
+        return None

hwgdreqs/logging_service.py

@@ -0,0 +1,82 @@
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+
+from hwgdreqs.config import data_dir
+
+
+def get_logger() -> logging.Logger:
+    log_dir = data_dir() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    log_file = log_dir / "hwgdreqs.log"
+
+    logger = logging.getLogger("hwgdreqs")
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.INFO)
+
+    file_handler = logging.FileHandler(log_file, encoding="utf-8")
+    file_handler.setLevel(logging.INFO)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    file_handler.setFormatter(formatter)
+
+    logger.addHandler(file_handler)
+
+    return logger
+
+
+def log_level_added(level_id: str, level_name: str, requester: str, platform: str) -> None:
+    logger = get_logger()
+    logger.info(f"Level added | ID: {level_id} | Name: {level_name} | Requester: {requester} | Platform: {platform}")
+
+
+def log_level_deleted(level_id: str, level_name: str, requester: str) -> None:
+    logger = get_logger()
+    logger.info(f"Level deleted | ID: {level_id} | Name: {level_name} | Requested by: {requester}")
+
+
+def log_level_swapped(old_level_id: str, old_level_name: str, new_level_id: str, new_level_name: str) -> None:
+    logger = get_logger()
+    logger.info(f"Level swapped | Old ID: {old_level_id} ({old_level_name}) | New ID: {new_level_id} ({new_level_name})")
+
+
+def log_requester_blacklisted(requester: str) -> None:
+    logger = get_logger()
+    logger.info(f"Requester blacklisted | {requester}")
+
+
+def log_level_blacklisted(level_id: str, level_name: str) -> None:
+    logger = get_logger()
+    logger.info(f"Level blacklisted | ID: {level_id} | Name: {level_name}")
+
+
+def log_author_blacklisted(author: str) -> None:
+    logger = get_logger()
+    logger.info(f"Author blacklisted | {author}")
+
+
+def log_requester_unblacklisted(requester: str) -> None:
+    logger = get_logger()
+    logger.info(f"Requester unblacklisted | {requester}")
+
+
+def log_level_unblacklisted(level_id: str) -> None:
+    logger = get_logger()
+    logger.info(f"Level unblacklisted | ID: {level_id}")
+
+
+def log_author_unblacklisted(author: str) -> None:
+    logger = get_logger()
+    logger.info(f"Author unblacklisted | {author}")
+
+
+def log_queue_cleared() -> None:
+    logger = get_logger()
+    logger.info("Queue cleared")