steamsift 1.0.0__py3-none-any.whl

steamsift/__init__.py

@@ -0,0 +1,3 @@
+"""sift — taste-aware Steam deals for you and your Steam Family."""
+
+__version__ = "1.0.0"

steamsift/__main__.py

@@ -0,0 +1,4 @@
+from .cli import entry
+
+if __name__ == "__main__":
+    entry()

steamsift/autodetect.py

@@ -0,0 +1,106 @@
+"""What setup can find on this computer, only when the user agrees: Steam accounts, Steam Family, keys.
+
+Nothing is sent anywhere. We read Steam's own text files (config/loginusers.vdf, userdata/*/localconfig.vdf)
+and, while a key step is open, the clipboard, so a key copied from the browser fills itself in.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+
+from .localsteam import ci_get, family_from_client, parse_vdf, steam_roots
+
+STEAM_KEY = re.compile(r"\b[0-9A-F]{32}\b")
+ITAD_KEY = re.compile(r"\b[0-9a-f]{40}\b")
+
+
+@dataclass
+class Account:
+    steam_id: str
+    persona: str
+    recent: bool = False
+    stamp: int = 0
+
+
+@dataclass
+class Found:
+    steam_root: str = ""
+    accounts: list[Account] = field(default_factory=list)
+    family: dict = field(default_factory=dict)
+
+    @property
+    def account(self) -> Account | None:
+        return self.accounts[0] if self.accounts else None
+
+
+def accounts() -> list[Account]:
+    """Accounts that signed in to Steam on this PC, the one used last first."""
+    out: dict[str, Account] = {}
+    for root in steam_roots():
+        path = root / "config" / "loginusers.vdf"
+        try:
+            users = ci_get(parse_vdf(path.read_text(encoding="utf-8", errors="ignore")), "users") or {}
+        except OSError:
+            continue
+        for sid, u in users.items() if isinstance(users, dict) else []:
+            if not (isinstance(u, dict) and str(sid).isdigit() and len(str(sid)) == 17):
+                continue
+            stamp = ci_get(u, "Timestamp") or "0"
+            out.setdefault(sid, Account(sid, ci_get(u, "PersonaName") or "", ci_get(u, "MostRecent") == "1",
+                                        int(stamp) if str(stamp).isdigit() else 0))
+    return sorted(out.values(), key=lambda a: (not a.recent, -a.stamp))
+
+
+def scan() -> Found:
+    roots = steam_roots()
+    found = Found(steam_root=str(roots[0]) if roots else "", accounts=accounts())
+    if found.account:
+        found.family = family_from_client(found.account.steam_id)
+    return found
+
+
+def clipboard_text() -> str:
+    """The clipboard as text, or '' when it can't be read (no display, no tool, not text)."""
+    try:
+        if sys.platform == "win32":
+            return _windows_clipboard()
+        for cmd in (["pbpaste"], ["wl-paste", "--no-newline"], ["xclip", "-selection", "clipboard", "-o"],
+                    ["xsel", "--clipboard", "--output"]):
+            if shutil.which(cmd[0]):
+                return subprocess.run(cmd, capture_output=True, text=True, timeout=2).stdout
+    except (OSError, subprocess.SubprocessError, ValueError):
+        pass
+    return ""
+
+
+def _windows_clipboard() -> str:
+    import ctypes
+    from ctypes import wintypes
+    user32, kernel32 = ctypes.windll.user32, ctypes.windll.kernel32
+    user32.GetClipboardData.restype = wintypes.HANDLE
+    kernel32.GlobalLock.argtypes = [wintypes.HGLOBAL]
+    kernel32.GlobalLock.restype = wintypes.LPVOID
+    kernel32.GlobalUnlock.argtypes = [wintypes.HGLOBAL]
+    CF_UNICODETEXT = 13
+    if not user32.OpenClipboard(None):
+        return ""
+    try:
+        handle = user32.GetClipboardData(CF_UNICODETEXT)
+        if not handle:
+            return ""
+        ptr = kernel32.GlobalLock(handle)
+        try:
+            return ctypes.wstring_at(ptr) if ptr else ""
+        finally:
+            kernel32.GlobalUnlock(handle)
+    finally:
+        user32.CloseClipboard()
+
+
+def key_in(text: str, kind: str) -> str:
+    """The first Steam (32 hex, upper case) or ITAD (40 hex, lower case) key in `text`."""
+    m = (STEAM_KEY if kind == "steam" else ITAD_KEY).search(text or "")
+    return m.group(0) if m else ""

steamsift/calendar.py

@@ -0,0 +1,145 @@
+"""Steam sale calendar, parsed from Valve's public partner page (seasonal sales + themed fests).
+
+Used for "wait — the Summer Sale starts in 9 days" hints and for fests matching your taste.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import html as htmllib
+import re
+from dataclasses import dataclass, field
+
+from .db import DAY, Cache
+from .net import SESSION
+
+URL = "https://partner.steamgames.com/doc/marketing/upcoming_events"
+_cache = Cache("calendar")
+
+# Themed fests -> the Steam tags whose games usually get discounted during them.
+FEST_TAGS: dict[str, list[str]] = {
+    "Racing Fest": ["Racing", "Driving", "Automobile Sim"],
+    "Steam Scream": ["Horror", "Psychological Horror", "Survival Horror"],
+    "Real-Time Strategy Fest": ["RTS", "Strategy"],
+    "Fighting Fest": ["Fighting", "2D Fighter", "3D Fighter", "Beat 'em up"],
+    "Rhythm Fest": ["Rhythm", "Music"],
+    "Couch Co-Op Fest": ["Local Co-Op", "Local Multiplayer"],
+    "Cooking Fest": ["Cooking"],
+    "Shop Keeper Fest": ["Management", "Economy"],
+    "Dinos vs. Robots Fest": ["Dinosaurs", "Robots", "Mechs"],
+    "Witch Fest": ["Magic", "Witch"],
+    "Mountaineering Fest": ["Climbing"],
+    "Medieval Fest": ["Medieval"],
+    "Auto-Battler RPG Fest": ["Auto Battler"],
+    "Survival Fest": ["Survival"],
+    "Open World Survival Craft Fest": ["Open World Survival Craft"],
+    "Simulation Fest": ["Simulation"],
+    "Puzzle Fest": ["Puzzle"],
+    "Sports Fest": ["Sports"],
+    "Strategy Fest": ["Strategy"],
+}
+
+_MONTHS = {m: i for i, m in enumerate(
+    ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"], 1)}
+
+
+@dataclass
+class Event:
+    name: str
+    kind: str                  # "sale" (seasonal, store-wide) | "fest" (themed)
+    start: dt.date
+    end: dt.date
+    tags: list[str] = field(default_factory=list)
+
+    def to_json(self) -> dict:
+        return {"name": self.name, "kind": self.kind, "start": self.start.isoformat(),
+                "end": self.end.isoformat(), "tags": self.tags}
+
+    @classmethod
+    def from_json(cls, d: dict) -> "Event":
+        return cls(d["name"], d["kind"], dt.date.fromisoformat(d["start"]), dt.date.fromisoformat(d["end"]),
+                   d.get("tags", []))
+
+
+def _date(text: str) -> dt.date | None:
+    m = re.match(r"(\d{1,2})\s+([A-Za-z]+),?\s+(\d{4})", text.strip())
+    if not m:
+        return None
+    month = _MONTHS.get(m.group(2)[:3].lower())
+    return dt.date(int(m.group(3)), month, int(m.group(1))) if month else None
+
+
+def _plain(fragment: str) -> str:
+    return re.sub(r"\s+", " ", htmllib.unescape(re.sub(r"<[^>]+>", " ", fragment))).strip()
+
+
+def parse(page: str) -> list[Event]:
+    events: list[Event] = []
+    text = _plain(page)
+    for m in re.finditer(r"(Spring|Summer|Autumn|Winter) Sale (\d{4})\s*\|?\s*(\d{1,2} [A-Za-z]+,? \d{4})\s*[-–]\s*"
+                         r"(\d{1,2} [A-Za-z]+,? \d{4})", text):
+        start, end = _date(m.group(3)), _date(m.group(4))
+        if start and end:
+            events.append(Event(f"Steam {m.group(1)} Sale", "sale", start, end))
+
+    # Themed fests live in tables that follow "<year> Fests" headings.
+    year = None
+    for m in re.finditer(r"(20\d\d) Fests|<tr[^>]*>(.*?)</tr>", page, re.S):
+        if m.group(1):
+            year = int(m.group(1))
+            continue
+        if year is None:
+            continue
+        cells = [_plain(c) for c in re.findall(r"<t[dh][^>]*>(.*?)</t[dh]>", m.group(2), re.S)]
+        if len(cells) < 2:
+            continue
+        d = re.match(r"([A-Za-z]{3})[a-z]*\.? (\d{1,2})\s*[-–]?\s*(?:([A-Za-z]{3})[a-z]*\.? )?(\d{1,2})$", cells[0])
+        if not d:
+            continue
+        m1, d1 = _MONTHS.get(d.group(1).lower()), int(d.group(2))
+        m2, d2 = _MONTHS.get((d.group(3) or d.group(1)).lower()), int(d.group(4))
+        if not m1 or not m2:
+            continue
+        start = dt.date(year, m1, d1)
+        end = dt.date(year + (1 if m2 < m1 else 0), m2, d2)
+        name = cells[1]
+        tags = next((v for k, v in FEST_TAGS.items() if k.lower() in name.lower()), [])
+        events.append(Event(name, "fest", start, end, tags))
+
+    uniq = {(e.name, e.start): e for e in events}
+    return sorted(uniq.values(), key=lambda e: e.start)
+
+
+def events() -> list[Event]:
+    cached = _cache.get("events", 7 * DAY)
+    if cached is not None:
+        return [Event.from_json(e) for e in cached]
+    try:
+        r = SESSION.get(URL, timeout=15)
+        evs = parse(r.text) if r.status_code == 200 else []
+    except Exception:  # noqa: BLE001 - the calendar is a nice-to-have
+        evs = []
+    if evs:
+        _cache.set("events", [e.to_json() for e in evs])
+    return evs
+
+
+def current_sale(today: dt.date | None = None, evs: list[Event] | None = None) -> Event | None:
+    today = today or dt.date.today()
+    return next((e for e in (evs if evs is not None else events())
+                 if e.kind == "sale" and e.start <= today <= e.end), None)
+
+
+def next_sale(today: dt.date | None = None, within_days: int = 45, evs: list[Event] | None = None) -> Event | None:
+    today = today or dt.date.today()
+    return next((e for e in (evs if evs is not None else events())
+                 if e.kind == "sale" and today < e.start <= today + dt.timedelta(days=within_days)), None)
+
+
+def fests_for(taste_tags: list[str], today: dt.date | None = None, within_days: int = 60,
+              evs: list[Event] | None = None) -> list[Event]:
+    """Upcoming or running themed fests whose tags overlap your strongest taste tags."""
+    today = today or dt.date.today()
+    want = {t.lower() for t in taste_tags}
+    return [e for e in (evs if evs is not None else events())
+            if e.kind == "fest" and e.end >= today and e.start <= today + dt.timedelta(days=within_days)
+            and want & {t.lower() for t in e.tags}]