recently-splatted-with 1.0.0__tar.gz

recently_splatted_with-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Shadow Doggo
+
+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.

recently_splatted_with-1.0.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: recently-splatted-with
+Version: 1.0.0
+Summary: GUI application to view a list of players you've recently encountered in Splatoon matches using Splatlogger logs
+Author-email: Shadow Doggo <shadowdoggo@protonmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PySide6>=6.5.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: userpaths>=0.1.3
+Requires-Dist: pyshortcuts>=1.9.1
+Dynamic: license-file
+
+# RecentlySplattedWith
+
+A GUI application to view a list of players you've recently encountered in Splatoon matches using [Splatlogger](https://codeberg.org/ShadowDoggo/Splatlogger) logs.
+
+<img src="assets/UI_Screenshot.png" width="600" alt="(UI Screenshot)">
+
+## Download / Installation
+### Standalone executable
+Windows and Linux executables are provided on the Releases page.
+These are portable and don't require you to have Python installed.
+
+On Linux, you might need to make the file executable first with `chmod +x path/to/executable`. You might also need to install `libxcb-cursor` / `xcb-util-cursor` if you get `qt.qpa.plugin: From 6.5.0, xcb-cursor0 or libxcb-cursor0 is needed to load the Qt xcb platform plugin` upon launching the app.
+
+### Python package
+You can install RecentlySplattedWith as a package from PyPI:
+```
+pip install RecentlySplattedWith
+```
+
+Then run with:
+```
+RecentlySplattedWith [--create-shortcut]
+```
+(if that fails, try `python -m recently_splatted_with`)
+Use `--create-shortcut` to create an aplication shortcut.
+
+On Linux, you will need to install `libxcb-cursor` / `xcb-util-cursor` if you get `qt.qpa.plugin: From 6.5.0, xcb-cursor0 or libxcb-cursor0 is needed to load the Qt xcb platform plugin`
+upon lanching the app.
+
+To run from source instead, download the latest source archive from the Releases
+page and extract it, then open a terminal window in the extracted directory.
+
+Install the required dependencies:
+```
+pip install -r requirements.txt
+```
+
+Then move into the `src` directory and run:
+```
+python -m recently_splatted_with
+```
+
+## Usage
+If you have not used [Splatlogger](https://codeberg.org/ShadowDoggo/Splatlogger) before, you will need to set it up and log a few matches beforehand. Using auto-logging is recommended.
+
+When you launch the app, it will automatically load all logs from `Documents/Splatlogger/logs/`. You can also manually choose a log directory or log file(s).
+
+Use the `Exclude (PID/PNID):` field to hide yourself from the list.
+
+You can search for individual players using the search field and change the sorting category in the `Sort by:` field. The `Max entries:` feild defines the maximum number of players displayed in the list.
+
+## Building the executable with PyInstaller
+Set up a virtual environment and install PyInstaller as well as the required dependencies.
+
+In `main.py`, replace
+```py
+icon_path = resources.files(__package__).joinpath("resources", "icon.png")
+```
+
+with
+```py
+icon_path = Path(sys._MEIPASS) / "resources/icon.png"
+```
+
+Then run:
+```
+pyinstaller --noconfirm --onefile --windowed --name "RecentlySplattedWith-v1.x" --upx-dir "path/to/upx" --optimize "2" --add-data "path/to/RecentlySplattedWith/src/recently_splatted_with/resources:resources/" --icon "path/to/icon.ico" "path/to/RecentlySplattedWith/src/recently_splatted_with/__main__.py"
+```
+replacing the placeholder paths with the actual ones.
+
+You can omit `--upx-dir` if you're not using UPX to compress the executable and `--optimize "2"` to disable bytecode optimization.
+
+## License
+This project is licensed under the [MIT License](LICENSE).
+
+The executables include third-party components; their license texts are contained in [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).

recently_splatted_with-1.0.0/README.md

@@ -0,0 +1,76 @@
+# RecentlySplattedWith
+
+A GUI application to view a list of players you've recently encountered in Splatoon matches using [Splatlogger](https://codeberg.org/ShadowDoggo/Splatlogger) logs.
+
+<img src="assets/UI_Screenshot.png" width="600" alt="(UI Screenshot)">
+
+## Download / Installation
+### Standalone executable
+Windows and Linux executables are provided on the Releases page.
+These are portable and don't require you to have Python installed.
+
+On Linux, you might need to make the file executable first with `chmod +x path/to/executable`. You might also need to install `libxcb-cursor` / `xcb-util-cursor` if you get `qt.qpa.plugin: From 6.5.0, xcb-cursor0 or libxcb-cursor0 is needed to load the Qt xcb platform plugin` upon launching the app.
+
+### Python package
+You can install RecentlySplattedWith as a package from PyPI:
+```
+pip install RecentlySplattedWith
+```
+
+Then run with:
+```
+RecentlySplattedWith [--create-shortcut]
+```
+(if that fails, try `python -m recently_splatted_with`)
+Use `--create-shortcut` to create an aplication shortcut.
+
+On Linux, you will need to install `libxcb-cursor` / `xcb-util-cursor` if you get `qt.qpa.plugin: From 6.5.0, xcb-cursor0 or libxcb-cursor0 is needed to load the Qt xcb platform plugin`
+upon lanching the app.
+
+To run from source instead, download the latest source archive from the Releases
+page and extract it, then open a terminal window in the extracted directory.
+
+Install the required dependencies:
+```
+pip install -r requirements.txt
+```
+
+Then move into the `src` directory and run:
+```
+python -m recently_splatted_with
+```
+
+## Usage
+If you have not used [Splatlogger](https://codeberg.org/ShadowDoggo/Splatlogger) before, you will need to set it up and log a few matches beforehand. Using auto-logging is recommended.
+
+When you launch the app, it will automatically load all logs from `Documents/Splatlogger/logs/`. You can also manually choose a log directory or log file(s).
+
+Use the `Exclude (PID/PNID):` field to hide yourself from the list.
+
+You can search for individual players using the search field and change the sorting category in the `Sort by:` field. The `Max entries:` feild defines the maximum number of players displayed in the list.
+
+## Building the executable with PyInstaller
+Set up a virtual environment and install PyInstaller as well as the required dependencies.
+
+In `main.py`, replace
+```py
+icon_path = resources.files(__package__).joinpath("resources", "icon.png")
+```
+
+with
+```py
+icon_path = Path(sys._MEIPASS) / "resources/icon.png"
+```
+
+Then run:
+```
+pyinstaller --noconfirm --onefile --windowed --name "RecentlySplattedWith-v1.x" --upx-dir "path/to/upx" --optimize "2" --add-data "path/to/RecentlySplattedWith/src/recently_splatted_with/resources:resources/" --icon "path/to/icon.ico" "path/to/RecentlySplattedWith/src/recently_splatted_with/__main__.py"
+```
+replacing the placeholder paths with the actual ones.
+
+You can omit `--upx-dir` if you're not using UPX to compress the executable and `--optimize "2"` to disable bytecode optimization.
+
+## License
+This project is licensed under the [MIT License](LICENSE).
+
+The executables include third-party components; their license texts are contained in [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md).

recently_splatted_with-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=83.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "recently-splatted-with"
+version = "1.0.0"
+description = "GUI application to view a list of players you've recently encountered in Splatoon matches using Splatlogger logs"
+readme = "README.md"
+authors = [
+    { name = "Shadow Doggo", email = "shadowdoggo@protonmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "PySide6>=6.5.0",
+    "requests>=2.28.0",
+    "userpaths>=0.1.3",
+    "pyshortcuts>=1.9.1"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.gui-scripts]
+RecentlySplattedWith = "recently_splatted_with.main:main"
+recently-splatted-with = "recently_splatted_with.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["recently_splatted_with*"]
+
+[tool.setuptools.package-data]
+recently_splatted_with = ["resources/*"]

recently_splatted_with-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

recently_splatted_with-1.0.0/src/recently_splatted_with/__init__.py

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

recently_splatted_with-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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