recently-splatted-with 1.0.0__py3-none-any.whl

recently_splatted_with/__init__.py

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

recently_splatted_with/__main__.py

@@ -0,0 +1,7 @@
+try:
+    from .main import main
+except ImportError:
+    from recently_splatted_with.main import main
+
+if __name__ == "__main__":
+    main()

recently_splatted_with/data_models.py

@@ -0,0 +1,61 @@
+# RecentlySplattedWith (c) 2026 Shadow Doggo.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass
+class PlayerEntry:
+    pid: int
+    pnid: str
+    name: str
+    mii_name: str | None = None
+    match_time: datetime | None = None
+    session_id: str | None = None
+    mii_icon_url: str | None = None
+    source_file: str | None = None
+
+
+@dataclass
+class PlayerRecord:
+    pid: int
+    pnid: str
+    name: str
+    mii_name: str | None = None
+    aliases: list[str] = field(default_factory=list)
+    last_encountered: datetime | None = None
+    games_played: int = 0
+    mii_icon_url: str | None = None
+    encounters: list[PlayerEntry] = field(default_factory=list)
+
+    @property
+    def pid_str(self) -> str:
+        return str(self.pid)
+
+    @property
+    def formatted_last_encountered(self) -> str:
+        if self.last_encountered:
+            return self.last_encountered.strftime("%Y-%m-%d %H:%M:%S")
+        return "Unknown"
+
+    @property
+    def aliases_display(self) -> str:
+        return ", ".join(self.aliases)
+
+    def add_alias(self, alias: str | None) -> bool:
+        if not alias or not isinstance(alias, str):
+            return False
+
+        clean = alias.strip()
+        if not clean or clean == self.name:
+            return False
+
+        if any(a == clean for a in self.aliases):
+            return False
+
+        self.aliases.append(clean)
+        self.aliases.sort()
+
+        return True

recently_splatted_with/main.py

@@ -0,0 +1,56 @@
+# RecentlySplattedWith (c) 2026 Shadow Doggo.
+
+from __future__ import annotations
+
+import platform
+import sys
+from importlib import resources
+from pathlib import Path
+
+import userpaths
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication
+
+from .ui.main_window import MainWindow
+
+
+def main() -> None:
+    app = QApplication()
+    app.setOrganizationName("RecentlySplattedWith")
+    app.setApplicationName("RecentlySplattedWith")
+
+    if len(sys.argv) > 1 and sys.argv[1] == "--create-shortcut":
+        # print("Not supported for the executable")
+        create_desktop_shortcut()
+
+    icon_path = resources.files(__package__).joinpath("resources", "icon.png")
+    # icon_path = Path(sys._MEIPASS) / "resources/icon.png"
+    if icon_path.is_file():
+        app.setWindowIcon(QIcon(str(icon_path)))
+
+    window = MainWindow(initial_path=Path(userpaths.get_my_documents()) / "Splatlogger/logs")
+
+    window.show()
+    sys.exit(app.exec())
+
+
+def create_desktop_shortcut() -> None:
+    from pyshortcuts import make_shortcut
+
+    executable = None
+    if platform.system() == "Windows":
+        pythonw_path = Path(sys.executable).with_name("pythonw.exe")
+        if pythonw_path.exists():
+            executable = str(pythonw_path)
+        else:
+            executable = sys.executable.replace("python.exe", "pythonw.exe")
+
+    make_shortcut(
+        str(resources.files(__package__).joinpath("__main__.py")),
+        name="RecentlySplattedWith",
+        description="View a list of players you've recently encountered in Splatoon matches",
+        icon=str(resources.files(__package__)
+                 .joinpath("resources","icon.ico" if platform.system() == "Windows" else "icon.png")),
+        executable=executable,
+        terminal=False,
+    )

recently_splatted_with/mii_fetcher.py

@@ -0,0 +1,263 @@
+# RecentlySplattedWith (c) 2026 Shadow Doggo.
+
+from __future__ import annotations
+
+import os
+import platform
+import time
+from pathlib import Path
+from xml.etree import ElementTree
+
+import requests
+import userpaths
+from PySide6.QtCore import QObject, QRunnable, QStandardPaths, Qt, QThreadPool, Signal
+from PySide6.QtGui import QColor, QFont, QImage, QPainter, QPainterPath, QPixmap
+
+
+def fetch_mii_url(pid: int, timeout: int = 5, session: requests.Session | None = None) -> str | None:
+    if pid <= 0:
+        return None
+
+    api_url = f"https://account.pretendo.cc/v1/api/miis?pids={pid}"
+    headers = {
+        "User-Agent": "Mozilla/5.0",
+        "X-Nintendo-Client-ID": "a2efa818a34fa16b8afbc8a74eba3eda",
+        "X-Nintendo-Client-Secret": "c91cdb5658bd4954ade78533a339cf9a",
+    }
+
+    url: str | None = None
+
+    try:
+        client = session if session is not None else requests
+        response = client.get(api_url, headers=headers, timeout=timeout)
+        if response.status_code == 200:
+            url = _get_mii_icon_url(response.text)
+    except requests.RequestException:
+        pass
+
+    # Fallback to CDN url
+    if not url:
+        url = f"https://r2-cdn.pretendo.cc/mii/{pid}/normal_face.png"
+
+    return url
+
+
+def create_placeholder_pixmap(size: int) -> QPixmap:
+    pixmap = QPixmap(size, size)
+    pixmap.fill(QColor(0, 0, 0, 0))
+
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+    path = QPainterPath()
+    path.addEllipse(2, 2, size - 4, size - 4)
+
+    painter.fillPath(path, QColor(80, 85, 100))
+    painter.setPen(QColor(120, 125, 145))
+    painter.drawPath(path)
+
+    painter.setPen(QColor(230, 235, 245))
+    font = QFont("Sans-Serif", int(size * 0.4), QFont.Weight.Bold)
+    painter.setFont(font)
+    painter.drawText(pixmap.rect(), int(Qt.AlignmentFlag.AlignCenter), "?")
+    painter.end()
+
+    return pixmap
+
+
+def _get_mii_icon_url(response_txt: str) -> str | None:
+    try:
+        root = ElementTree.fromstring(response_txt)
+        if len(root) == 0:
+            return None
+
+        mii_img_url = root.find(".//images/image/url")
+        if mii_img_url is not None and mii_img_url.text:
+            return mii_img_url.text.strip()
+
+        cached_url_elem = root.find(".//images/image/cached_url")
+        if cached_url_elem is not None and cached_url_elem.text:
+            return cached_url_elem.text.strip()
+
+        return None
+    except ElementTree.ParseError:
+        return None
+
+
+def _get_default_cache_dir() -> Path:
+    try:
+        generic_cache = QStandardPaths.writableLocation(QStandardPaths.StandardLocation.GenericCacheLocation)
+        if generic_cache:
+            cache_dir = Path(generic_cache) / "RecentlySplattedWith"
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            return cache_dir
+    except OSError:
+        pass
+
+    if platform.system() == "Windows":
+        cache_dir = Path(userpaths.get_local_appdata()) / "RecentlySplattedWith"
+    elif platform.system() == "Darwin":
+        cache_dir = Path.home() / "Library" / "Caches" / "RecentlySplattedWith"
+    else:
+        xdg_cache = os.environ.get("XDG_CACHE_HOME")
+        if xdg_cache:
+            cache_dir = Path(xdg_cache) / "RecentlySplattedWith"
+        else:
+            cache_dir = Path.home() / ".cache" / "RecentlySplattedWith"
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+class MiiFetchWorkerSignals(QObject):
+    finished = Signal(int, QImage)
+
+
+class MiiFetchWorker(QRunnable):
+    """Background worker to fetch and cache Mii icons."""
+
+    def __init__(self, pid: int, direct_url: str | None, cache_dir: Path, session: requests.Session | None = None,
+                 delay: float = 0.2):
+        super().__init__()
+        self.signals = MiiFetchWorkerSignals()
+        self._pid = pid
+        self._direct_url = direct_url
+        self._cache_dir = cache_dir
+        self._session = session
+        self._delay = delay
+
+    def run(self) -> None:
+        if self._pid <= 0:
+            return
+
+        image_path = self._cache_dir / f"{self._pid}.png"
+        qimg = QImage()
+
+        # Check local file cache
+        if image_path.is_file():
+            if qimg.load(str(image_path)):
+                self.signals.finished.emit(self._pid, qimg)
+                return
+
+        if self._delay > 0:
+            time.sleep(self._delay)
+
+        url = self._direct_url
+        if not url:
+            url = fetch_mii_url(self._pid, session=self._session)
+
+        if url:
+            try:
+                client = self._session if self._session is not None else requests
+                res = client.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=5)
+                if res.status_code == 200 and res.content:
+                    # Save to cache
+                    image_path.write_bytes(res.content)
+                    if qimg.loadFromData(res.content):
+                        self.signals.finished.emit(self._pid, qimg)
+                        return
+            except (requests.RequestException, OSError):
+                pass
+
+
+class MiiIconManager(QObject):
+    """Handles caching and requesting Mii icons."""
+    icon_ready = Signal(int, QPixmap)
+
+    def __init__(self, cache_dir: Path | None = None, parent: QObject | None = None, delay: float = 0.2):
+        super().__init__(parent)
+        self._cache_dir = cache_dir or _get_default_cache_dir()
+        self._delay = delay
+        self._session = requests.Session()
+        self._memory_cache: dict[int, QPixmap] = {}
+        self._pending_pids: set[int] = set()
+        self._thread_pool = QThreadPool()
+        self._thread_pool.setMaxThreadCount(4)
+        self._clean_cache_by_size()
+
+    def wait_for_done(self, msecs: int = 1000) -> bool:
+        return self._thread_pool.waitForDone(msecs)
+
+    def get_cached_pixmap(self, pid: int) -> QPixmap | None:
+        if pid in self._memory_cache:
+            return self._memory_cache[pid]
+
+        image_path = self._cache_dir / f"{pid}.png"
+        if image_path.is_file():
+            pixmap = QPixmap()
+            if pixmap.load(str(image_path)):
+                self._memory_cache[pid] = pixmap
+                return pixmap
+
+        return None
+
+    def request_icon(self, pid: int, direct_url: str | None = None) -> QPixmap:
+        """Get icon if cached, or queue background fetch and return placeholder."""
+        cached = self.get_cached_pixmap(pid)
+
+        if pid not in self._pending_pids and pid > 0:
+            self._pending_pids.add(pid)
+            worker = MiiFetchWorker(
+                pid,
+                direct_url,
+                self._cache_dir,
+                session=self._session,
+                delay=self._delay,
+            )
+            worker.signals.finished.connect(self._on_image_fetched)
+            self._thread_pool.start(worker)
+
+        if cached:
+            return cached
+
+        return create_placeholder_pixmap(56)
+
+    def _on_image_fetched(self, pid: int, qimg: QImage) -> None:
+        if pid in self._pending_pids:
+            self._pending_pids.remove(pid)
+        if not qimg.isNull():
+            pixmap = QPixmap.fromImage(qimg)
+            self._memory_cache[pid] = pixmap
+            self.icon_ready.emit(pid, pixmap)
+
+    def _clean_cache_by_size(self) -> None:
+        if not self._cache_dir.exists():
+            return
+
+        max_size_bytes: int = 50 * 1024 * 1024
+        target_size_bytes: int = 30 * 1024 * 1024
+        max_files: int = 3000
+        target_files: int = 2000
+
+        cached_files: list[tuple[float, int, Path]] = []
+        total_size = 0
+
+        for icon_path in self._cache_dir.glob("*.png"):
+            try:
+                stat = icon_path.stat()
+                cached_files.append((stat.st_mtime, stat.st_size, icon_path))
+                total_size += stat.st_size
+            except OSError:
+                continue
+
+        if total_size <= max_size_bytes and len(cached_files) <= max_files:
+            return
+
+        # Sort files ascending by modification time (oldest first).
+        cached_files.sort(key=lambda item: item[0])
+
+        current_size = total_size
+        current_count = len(cached_files)
+        iter_count = 0
+
+        for _, size, icon_path in cached_files:
+            if current_size <= target_size_bytes and current_count <= target_files and iter_count > max_files:
+                break
+            try:
+                icon_path.unlink()
+                current_size -= size
+                current_count -= 1
+                iter_count += 1
+            except OSError:
+                iter_count += 1
+                continue

recently_splatted_with/parser.py

@@ -0,0 +1,285 @@
+# RecentlySplattedWith (c) 2026 Shadow Doggo.
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Iterable
+
+from .data_models import PlayerEntry, PlayerRecord
+
+RE_TIMEZONE = re.compile(r"\(UTC\s*[+-]?\d+\)")
+RE_PID_PARENS = re.compile(r"\((\d+)\)")
+RE_MII_PREFIX = re.compile(r"^(.*?)\s*\(Mii name:\s*(.*?)\)$", re.IGNORECASE)
+RE_MII_PARENS = re.compile(r"^(.*?)\s*\((.*?)\)$")
+
+RE_LOG_HEADER = re.compile(r"Splatlogger log from\s+([^\n\r]+)")
+RE_DATE_IN_FILENAME = re.compile(r"(\d{4}-\d{2}-\d{2})")
+
+RE_BRACKET_MATCHES = re.compile(r"\[Match\s+\d+")
+RE_PLAIN_MATCHES = re.compile(r"(?:^|\n)Match\s+\d+")
+RE_PLAYER_SECTIONS = re.compile(r"\[Player\s+\d+")
+RE_TABULAR_HEADER = re.compile(r"Player\s*\|\s*PID\s*\|\s*PNID\s*\|\s*Name", re.IGNORECASE)
+RE_TABULAR_SFID_HEADER = re.compile(r"Player\s*\|\s*PID\s*\|\s*SFID\s*\|\s*Name", re.IGNORECASE)
+
+RE_SPLIT_MATCH_BLOCKS = re.compile(r"(?=\[Match\s+\d+)")
+RE_SPLIT_PLAYER_BLOCKS = re.compile(r"(?=\[Player\s+\d+)")
+RE_SPLIT_PLAIN_MATCHES = re.compile(r"(?=(?:^|\n)Match\s+\d+)")
+
+RE_TIME = re.compile(r"Time:\s*([^\n\r]+)")
+RE_FETCHED = re.compile(r"Fetched at:\s*([^\n\r]+)")
+RE_SESSION_ID = re.compile(r"Session ID:\s*([^\n\r]+)")
+
+RE_NAME_FIELD = re.compile(r"^\s*Name:\s*([^\n\r]+)", re.MULTILINE)
+RE_PID_FIELD = re.compile(r"^\s*PID:\s*([^\n\r]+)", re.MULTILINE)
+RE_PNID_FIELD = re.compile(r"^\s*PNID:\s*([^\n\r]+)", re.MULTILINE)
+RE_MII_NAME_FIELD = re.compile(r"^\s*Mii name:\s*([^\n\r]+)", re.MULTILINE)
+
+RE_TABULAR_ROW = re.compile(r"^\s*Player\s+\d+\s*\|\s*([^|]+)\|\s*([^|]+)\|\s*(.+)$")
+
+TIMESTAMP_FORMATS = (
+    "%Y-%m-%d %H:%M:%S",
+    "%Y-%m-%d",
+    "%H:%M:%S"
+)
+
+
+def parse_log_file(file_path: str | Path) -> list[PlayerEntry]:
+    path = Path(file_path)
+    if not path.is_file():
+        return []
+
+    try:
+        content = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return []
+
+    return _parse_log_content(content, file_path=str(path))
+
+
+def aggregate_players(encounters: Iterable[PlayerEntry]) -> list[PlayerRecord]:
+    grouped: dict[tuple[int, str], list[PlayerEntry]] = {}
+
+    for enc in encounters:
+        # Group primarily by PID, fallback to PNID
+        key = (enc.pid, enc.pnid if enc.pid == 0 else "")
+        if key not in grouped:
+            grouped[key] = []
+        grouped[key].append(enc)
+
+    records: list[PlayerRecord] = []
+
+    for (pid, fallback_pnid), p_encounters in grouped.items():
+        if not p_encounters:
+            continue
+
+        sorted_encounters = sorted(p_encounters, key=lambda e: e.match_time or datetime.min)
+
+        most_recent = sorted_encounters[-1]
+        last_date = most_recent.match_time
+        pnid = most_recent.pnid or fallback_pnid
+        primary_name = most_recent.name
+        latest_mii_name = next((e.mii_name for e in reversed(sorted_encounters) if e.mii_name), None)
+
+        record = PlayerRecord(
+            pid=pid,
+            pnid=pnid,
+            name=primary_name,
+            mii_name=latest_mii_name,
+            aliases=[],
+            last_encountered=last_date,
+            games_played=len(sorted_encounters),
+            mii_icon_url=None,
+            encounters=sorted_encounters,
+        )
+
+        for e in sorted_encounters:
+            if e.name:
+                record.add_alias(e.name)
+            if e.mii_name:
+                record.add_alias(e.mii_name)
+
+        records.append(record)
+
+    return records
+
+
+def parse_and_aggregate_logs(file_paths: Iterable[str | Path]) -> list[PlayerRecord]:
+    all_encounters: list[PlayerEntry] = []
+
+    for path_item in file_paths:
+        path = Path(path_item)
+        if path.is_file():
+            all_encounters.extend(parse_log_file(path))
+        elif path.is_dir():
+            for f in sorted(path.rglob("*")):
+                if f.is_file() and f.suffix == ".txt":
+                    all_encounters.extend(parse_log_file(f))
+
+    return aggregate_players(all_encounters)
+
+
+def _parse_timestamp(time_str: str, base_date: datetime | None = None) -> datetime | None:
+    time_str = time_str.strip()
+    time_str_clean = RE_TIMEZONE.sub("", time_str).strip()
+
+    for fmt in TIMESTAMP_FORMATS:
+        try:
+            date = datetime.strptime(time_str_clean, fmt)
+            if fmt in ("%H:%M:%S", "%H:%M") and base_date:
+                date = base_date.replace(hour=date.hour, minute=date.minute, second=date.second)
+            return date
+        except ValueError:
+            continue
+
+    return None
+
+
+def _parse_pid(pid_str: str) -> int:
+    pid_str = pid_str.strip()
+    match = RE_PID_PARENS.search(pid_str)
+    if match:
+        return int(match.group(1))
+
+    if pid_str.isdigit():
+        return int(pid_str)
+
+    return 0
+
+
+def _clean_name_and_mii(raw_name: str) -> tuple[str, str | None]:
+    raw_name = raw_name.strip()
+    match = RE_MII_PREFIX.match(raw_name) or RE_MII_PARENS.match(raw_name)
+    if match:
+        return match.group(1).strip(), match.group(2).strip()
+
+    return raw_name, None
+
+
+def _extract_log_date(content: str) -> datetime | None:
+    log_header_match = RE_LOG_HEADER.search(content)
+    if log_header_match:
+        if date := _parse_timestamp(log_header_match.group(1)):
+            return date
+
+    return None
+
+
+def _extract_match_time(text: str, base_date: datetime | None = None) -> datetime | None:
+    for regex in (RE_TIME, RE_FETCHED):
+        match = regex.search(text)
+        if match:
+            if date := _parse_timestamp(match.group(1), base_date):
+                return date
+
+    return base_date
+
+
+def _extract_session_id(text: str) -> str | None:
+    sess_match = RE_SESSION_ID.search(text)
+    return sess_match.group(1).strip() if sess_match else None
+
+
+def _parse_player_block(p_block: str, match_time: datetime | None, session_id: str | None, file_path: str | None,
+                        ) -> PlayerEntry | None:
+    name_m = RE_NAME_FIELD.search(p_block)
+    pid_m = RE_PID_FIELD.search(p_block)
+    pnid_m = RE_PNID_FIELD.search(p_block)
+    mii_m = RE_MII_NAME_FIELD.search(p_block)
+
+    if pid_m and name_m:
+        pid = _parse_pid(pid_m.group(1))
+        pnid = pnid_m.group(1).strip() if pnid_m else ""
+        raw_name = name_m.group(1).strip()
+        name, inline_mii = _clean_name_and_mii(raw_name)
+        mii_name = mii_m.group(1).strip() if mii_m else inline_mii
+
+        return PlayerEntry(
+            pid=pid,
+            pnid=pnid,
+            name=name,
+            mii_name=mii_name,
+            match_time=match_time,
+            session_id=session_id,
+            mii_icon_url=None,
+            source_file=file_path,
+        )
+
+    return None
+
+
+def _parse_player_sections(text: str, match_time: datetime | None, session_id: str | None, file_path: str | None,
+                           ) -> list[PlayerEntry]:
+    entries: list[PlayerEntry] = []
+
+    player_blocks = RE_SPLIT_PLAYER_BLOCKS.split(text)[1:]
+    for p_block in player_blocks:
+        entry = _parse_player_block(p_block, match_time, session_id, file_path)
+        if entry:
+            entries.append(entry)
+
+    return entries
+
+
+def _parse_tabular_block(block: str, match_time: datetime | None, session_id: str | None, file_path: str | None,
+                         spfn: bool = False) -> list[PlayerEntry]:
+    entries: list[PlayerEntry] = []
+    is_sfid = bool(RE_TABULAR_SFID_HEADER.search(block)) or (spfn and not RE_TABULAR_HEADER.search(block))
+
+    for line in block.splitlines():
+        row_match = RE_TABULAR_ROW.match(line)
+        if row_match:
+            pid = _parse_pid(row_match.group(1))
+            # Ignore SFID for now
+            pnid = "" if is_sfid else row_match.group(2).strip()
+            name, mii_name = _clean_name_and_mii(row_match.group(3))
+            entries.append(
+                PlayerEntry(
+                    pid=pid,
+                    pnid=pnid,
+                    name=name,
+                    mii_name=mii_name,
+                    match_time=match_time,
+                    session_id=session_id,
+                    mii_icon_url=None,
+                    source_file=file_path,
+                )
+            )
+
+    return entries
+
+
+def _parse_log_content(content: str, file_path: str | None = None) -> list[PlayerEntry]:
+    encounters: list[PlayerEntry] = []
+    log_date = _extract_log_date(content)
+
+    has_bracket_matches = bool(RE_BRACKET_MATCHES.search(content))
+    has_plain_matches = bool(RE_PLAIN_MATCHES.search(content))
+    has_player_sections = bool(RE_PLAYER_SECTIONS.search(content))
+    has_tabular_header = bool(RE_TABULAR_HEADER.search(content) or RE_TABULAR_SFID_HEADER.search(content))
+    is_spfn_log = bool(RE_TABULAR_SFID_HEADER.search(content))
+
+    if has_bracket_matches:
+        for block in RE_SPLIT_MATCH_BLOCKS.split(content):
+            if not RE_BRACKET_MATCHES.search(block):
+                continue
+
+            match_time = _extract_match_time(block, log_date)
+            session_id = _extract_session_id(block)
+            encounters.extend(_parse_player_sections(block, match_time, session_id, file_path))
+
+    elif has_player_sections:
+        session_id = _extract_session_id(content)
+        encounters.extend(_parse_player_sections(content, log_date, session_id, file_path))
+
+    elif has_plain_matches or has_tabular_header:
+        for block in RE_SPLIT_PLAIN_MATCHES.split(content):
+            if not block.strip():
+                continue
+
+            match_time = _extract_match_time(block, log_date)
+            session_id = _extract_session_id(block)
+            encounters.extend(_parse_tabular_block(block, match_time, session_id, file_path, spfn=is_spfn_log))
+
+    return encounters