psn-monitor 1.5.1__py3-none-any.whl → 1.6__py3-none-any.whl

{psn_monitor-1.5.1.dist-info → psn_monitor-1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psn_monitor
-Version: 1.5.1
+Version: 1.6
 Summary: Tool implementing real-time tracking of Sony PlayStation (PSN) players activities
 Author-email: Michal Szymanski <misiektoja-pypi@rm-rf.ninja>
 License-Expression: GPL-3.0-or-later
@@ -32,13 +32,15 @@ psn_monitor is a tool for real-time monitoring of Sony PlayStation (PSN) players
 ## Features
 
 - Real-time tracking of PlayStation users' gaming activity (including detection when a user gets online/offline or plays games)
+- Detailed user information display mode providing comprehensive PlayStation profile insights
 - Basic statistics for user activity (duration in different states, time spent playing a game, overall time and number of games played in a session etc.)
 - Email notifications for various events (player gets online/offline, starts/finishes/changes a game, errors)
 - Saving all user activities with timestamps to a CSV file
 - Possibility to control the running copy of the script via signals
+- Functional, procedural Python (minimal OOP)
 
 <p align="center">
-   <img src="https://raw.githubusercontent.com/misiektoja/psn_monitor/refs/heads/main/assets/psn_monitor.png" alt="psn_monitor_screenshot" width="85%"/>
+   <img src="https://raw.githubusercontent.com/misiektoja/psn_monitor/refs/heads/main/assets/psn_monitor.png" alt="psn_monitor_screenshot" width="90%"/>
 </p>
 
 <a id="table-of-contents"></a>
@@ -48,6 +50,7 @@ psn_monitor is a tool for real-time monitoring of Sony PlayStation (PSN) players
 2. [Installation](#installation)
    * [Install from PyPI](#install-from-pypi)
    * [Manual Installation](#manual-installation)
+   * [Upgrading](#upgrading)
 3. [Quick Start](#quick-start)
 4. [Configuration](#configuration)
    * [Configuration File](#configuration-file)
@@ -57,6 +60,7 @@ psn_monitor is a tool for real-time monitoring of Sony PlayStation (PSN) players
    * [SMTP Settings](#smtp-settings)
    * [Storing Secrets](#storing-secrets)
 5. [Usage](#usage)
+   * [User Information Display Mode](#user-information-display-mode)
    * [Monitoring Mode](#monitoring-mode)
    * [Email Notifications](#email-notifications)
    * [CSV Export](#csv-export)
@@ -74,8 +78,8 @@ psn_monitor is a tool for real-time monitoring of Sony PlayStation (PSN) players
 
 Tested on:
 
-* **macOS**: Ventura, Sonoma, Sequoia
-* **Linux**: Raspberry Pi OS (Bullseye, Bookworm), Ubuntu 24, Rocky Linux 8.x/9.x, Kali Linux 2024/2025
+* **macOS**: Ventura, Sonoma, Sequoia, Tahoe
+* **Linux**: Raspberry Pi OS (Bullseye, Bookworm, Trixie), Ubuntu 24/25, Rocky Linux 8.x/9.x, Kali Linux 2024/2025
 * **Windows**: 10, 11
 
 It should work on other versions of macOS, Linux, Unix and Windows as well.
@@ -107,6 +111,17 @@ Alternatively, from the downloaded *[requirements.txt](https://raw.githubusercon
 pip install -r requirements.txt
 ```
 
+<a id="upgrading"></a>
+### Upgrading
+
+To upgrade to the latest version when installed from PyPI:
+
+```sh
+pip install psn_monitor -U
+```
+
+If you installed manually, download the newest *[psn_monitor.py](https://raw.githubusercontent.com/misiektoja/psn_monitor/refs/heads/main/psn_monitor.py)* file to replace your existing installation.
+
 <a id="quick-start"></a>
 ## Quick Start
 
@@ -241,6 +256,51 @@ As a fallback, you can also store secrets in the configuration file or source co
 <a id="usage"></a>
 ## Usage
 
+<a id="user-information-display-mode"></a>
+### User Information Display Mode
+
+The tool provides a detailed user information display mode that shows comprehensive PlayStation profile insights. This mode displays information once and then exits (it does not run continuous monitoring).
+
+To get detailed user information, use the `-i` or `--info` flag:
+
+```sh
+psn_monitor <psn_user_id> -i
+```
+
+This displays:
+- PlayStation/PSN IDs
+- Online status and availability to play
+- Platform information
+- PS+ subscription status
+- Verification status
+- About me section
+- Languages
+- Friendship relation and mutual friends count
+- Profile URL
+- Recently played games with last played date and total play time
+
+To also display trophy summary and list of most recently earned trophies, add the `--trophies` flag:
+
+```sh
+psn_monitor <psn_user_id> -i --trophies
+```
+
+To disable fetching the recently played games list (faster execution), use the `--no-recent-games` flag:
+
+```sh
+psn_monitor <psn_user_id> -i --no-recent-games
+```
+
+You can combine both flags:
+
+```sh
+psn_monitor <psn_user_id> -i --trophies --no-recent-games
+```
+
+<p align="center">
+   <img src="https://raw.githubusercontent.com/misiektoja/psn_monitor/refs/heads/main/assets/psn_monitor_info.png" alt="psn_monitor_info" width="90%"/>
+</p>
+
 <a id="monitoring-mode"></a>
 ### Monitoring Mode
 

psn_monitor-1.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+psn_monitor.py,sha256=LUOMdhCCK5V0fx-2bkW0SfqrLjywOYc6-IwON6SNZg8,78993
+psn_monitor-1.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+psn_monitor-1.6.dist-info/METADATA,sha256=yf8X9sbc4ocZF5i85LkmN7Jxn7QBriTkqyFf1wGEFCU,14458
+psn_monitor-1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+psn_monitor-1.6.dist-info/entry_points.txt,sha256=2yXV06LBmzhWnvc4bKuEblezaWSHEWKdB2HClGXZlnk,49
+psn_monitor-1.6.dist-info/top_level.txt,sha256=IG37NL5yiB0wgx_MN-L47SDxKdqRXzjIqBpkU7JiISE,12
+psn_monitor-1.6.dist-info/RECORD,,

psn_monitor.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Author: Michal Szymanski <misiektoja-github@rm-rf.ninja>
-v1.5.1
+v1.6
 
 Tool implementing real-time tracking of Sony PlayStation (PSN) players activities:
 https://github.com/misiektoja/psn_monitor/
@@ -16,7 +16,7 @@ tzlocal (optional)
 python-dotenv (optional)
 """
 
-VERSION = "1.5.1"
+VERSION = "1.6"
 
 # ---------------------------
 # CONFIGURATION SECTION START
@@ -779,6 +779,496 @@ def resolve_executable(path):
     raise FileNotFoundError(f"Could not find executable '{path}'")
 
 
+# Normalizes Unicode punctuation, symbols and spacing in a string to plain ASCII
+def normalize_ascii(s):
+    if not isinstance(s, str):
+        return s
+    # punctuation & symbols to ASCII
+    s = (s.replace("\u2018", "'").replace("\u2019", "'")  # ‘ ’ -> '
+         .replace("\u201C", '"').replace("\u201D", '"')   # “ ” -> "
+         .replace("\u2013", "-")                          # – -> -
+         .replace("\u2026", "...")                        # … -> ...
+         .replace("\u00A0", " "))                         # NBSP -> space
+    # remove trademark symbols
+    for ch in ("\u00AE", "\u2122"):  # ® ™
+        s = s.replace(ch, "")
+    # collapse doubled single quotes that often appear after smart-quote normalization
+    s = s.replace("''", "'")
+    # collapse multiple spaces
+    while "  " in s:
+        s = s.replace("  ", " ")
+    return s.strip()
+
+
+# Prints the last N earned trophies across titles with game, type and earn date
+def print_last_earned_trophies(psn_user, max_items=5, title_limit=15):
+    PT = None
+    try:
+        from psnawp_api.models.trophies import PlatformType as PT  # 3.x
+    except Exception:
+        PT = None  # fallback to string platforms later
+
+    def _get(obj, *names, default=None):
+        for n in names:
+            if hasattr(obj, n):
+                v = getattr(obj, n)
+                if v is not None:
+                    return v
+        return default
+
+    def _platforms_to_try(title):
+        raw = getattr(title, "platform", None)
+        raw_val = getattr(raw, "value", raw)
+        s = (str(raw_val).lower() if raw_val else "")
+        if PT:
+            if "ps5" in s:
+                return [PT.PS5, PT.PS4]
+            if "ps4" in s:
+                return [PT.PS4, PT.PS5]
+            return [PT.PS5, PT.PS4]
+        # string fallback
+        if "ps5" in s:
+            return ["ps5", "ps4"]
+        if "ps4" in s:
+            return ["ps4", "ps5"]
+        return ["ps5", "ps4"]
+
+    def _earn_dt(tr):
+        return _get(tr, "earned_date_time", "earnedDateTime", default=None)
+
+    def _trophy_type_str(tr):
+        raw = _get(tr, "trophy_type", "trophyType", default=None)
+        if raw is None:
+            return "UNKNOWN"
+        if hasattr(raw, "name"):
+            return raw.name
+        return str(raw).upper()
+
+    # title-name resolver (cache)
+    _title_name_cache = {}
+
+    def _resolve_title_name(npcomm, platform):
+        key = (npcomm, str(platform))
+        if key in _title_name_cache:
+            return _title_name_cache[key]
+
+        def _first_name_like(obj):
+            # Try common fields first
+            for fld in ("trophy_title_name", "trophyTitleName", "title_name", "titleName", "name"):
+                if hasattr(obj, fld):
+                    val = getattr(obj, fld)
+                    if isinstance(val, str) and val.strip():
+                        return val.strip()
+            # Fallback: scan attributes that look like "*name"
+            for attr in dir(obj):
+                if attr.startswith("_"):
+                    continue
+                if "name" in attr.lower():
+                    try:
+                        val = getattr(obj, attr)
+                    except Exception:
+                        continue
+                    if isinstance(val, str) and val.strip():
+                        return val.strip()
+            return None
+
+        name = None
+
+        # A) groups often carry the title name
+        try:
+            for g in psn_user.trophy_groups(np_communication_id=npcomm, platform=platform):
+                name = _first_name_like(g)
+                if name:
+                    break
+        except Exception:
+            pass
+
+        # B) per-title summary
+        if not name:
+            try:
+                summ = psn_user.trophy_summary(np_communication_id=npcomm, platform=platform)
+                name = _first_name_like(summ)
+            except Exception:
+                pass
+
+        # C) scan titles
+        if not name:
+            try:
+                for tt in psn_user.trophy_titles(limit=title_limit):
+                    nc = getattr(tt, "np_communication_id", None) or getattr(tt, "npCommunicationId", None)
+                    if nc == npcomm:
+                        name = _first_name_like(tt)
+                        if name:
+                            break
+            except Exception:
+                pass
+
+        if not name:
+            name = npcomm  # last resort
+
+        _title_name_cache[key] = name
+        return name
+    # -------------------------------------
+
+    items = []
+
+    # 1) list titles (no special args for cross-version compat)
+    try:
+        titles_iter = psn_user.trophy_titles(limit=title_limit)
+    except Exception:
+        titles_iter = []
+
+    for tt in titles_iter:
+        npcomm = _get(tt, "np_communication_id", "npCommunicationId", default=None)
+        if not npcomm:
+            continue
+
+        for plat in _platforms_to_try(tt):
+            try:
+                it = psn_user.trophies(
+                    np_communication_id=npcomm,
+                    platform=plat,
+                    include_progress=True,
+                    trophy_group_id="all",
+                )
+            except Exception:
+                continue
+
+            got_any_for_title = False
+            for tr in it:
+                got_any_for_title = True
+                if not getattr(tr, "earned", False):
+                    continue
+                dt = _earn_dt(tr)
+                if not dt:
+                    continue
+
+                game_name = normalize_ascii(_resolve_title_name(npcomm, plat))
+                ttype = _trophy_type_str(tr)
+                tname = _get(tr, "trophy_name", "trophyName", default=None)
+                if not tname:
+                    tname = "(hidden)" if getattr(tr, "hidden", False) else "(unknown)"
+                tname = normalize_ascii(tname)
+
+                items.append((dt, game_name, ttype, tname))
+
+            if got_any_for_title:
+                break  # this platform works for this title
+
+        if len(items) >= max_items:
+            break
+
+    if not items:
+        print("- (no recent trophies found or trophy visibility is restricted)")
+        return
+
+    # 2) sort & print
+    try:
+        items.sort(key=lambda x: x[0], reverse=True)
+    except Exception:
+        def _ts(dt):
+            try:
+                return int(dt.timestamp())
+            except Exception:
+                return -1
+        items.sort(key=lambda x: _ts(x[0]), reverse=True)
+
+    for dt, game, ttype, tname in items[:max_items]:
+        try:
+            ts = int(dt.timestamp())
+            dt_fmt = get_date_from_ts(ts)
+        except Exception:
+            dt_fmt = "n/a"
+        print(f"- {dt_fmt} | {game} | {ttype} | {tname}")
+
+
+# Gets detailed user information and displays it (for -i/--info mode)
+def get_user_info(psn_user_id, include_trophies=False, show_recent_games=True):
+    print(f"* Fetching details for PlayStation user '{psn_user_id}'... this may take a moment\n")
+
+    try:
+        psnawp = PSNAWP(PSN_NPSSO)
+        psn_user = psnawp.user(online_id=psn_user_id)
+        accountid = psn_user.account_id
+        profile = psn_user.profile()
+        aboutme = profile.get("aboutMe")
+        isplus = profile.get("isPlus")
+        langs = profile.get("languages") or []
+        is_verified = profile.get("isOfficiallyVerified")
+        fs = psn_user.friendship()
+        share = psn_user.get_shareable_profile_link()
+    except Exception as e:
+        print(f"* Error: {e}")
+        sys.exit(1)
+
+    try:
+        psn_user_presence = psn_user.get_presence()
+    except Exception as e:
+        print(f"* Error: Cannot get presence for user {psn_user_id}: {e}")
+        sys.exit(1)
+
+    status = psn_user_presence["basicPresence"]["primaryPlatformInfo"].get("onlineStatus")
+
+    if not status:
+        print(f"* Error: Cannot get status for user {psn_user_id}")
+        sys.exit(1)
+
+    status = str(status).lower()
+
+    psn_platform = psn_user_presence["basicPresence"]["primaryPlatformInfo"].get("platform")
+    psn_platform = str(psn_platform).upper() if psn_platform else ""
+    lastonline = psn_user_presence["basicPresence"]["primaryPlatformInfo"].get("lastOnlineDate")
+    availability = psn_user_presence["basicPresence"].get("availability")
+
+    lastonline_dt = convert_iso_str_to_datetime(lastonline)
+    if lastonline_dt:
+        lastonline_ts = int(lastonline_dt.timestamp())
+    else:
+        lastonline_ts = 0
+
+    gametitleinfolist = psn_user_presence["basicPresence"].get("gameTitleInfoList")
+    game_name = ""
+    launchplatform = ""
+
+    if gametitleinfolist:
+        game_name_raw = gametitleinfolist[0].get("titleName")
+        game_name = normalize_ascii(game_name_raw) if game_name_raw else ""
+        launchplatform = gametitleinfolist[0].get("launchPlatform")
+        launchplatform = str(launchplatform).upper()
+
+    psn_last_status_file = f"psn_{psn_user_id}_last_status.json"
+    status_ts_old = int(time.time())
+
+    if os.path.isfile(psn_last_status_file):
+        try:
+            with open(psn_last_status_file, 'r', encoding="utf-8") as f:
+                last_status_read = json.load(f)
+            if last_status_read:
+                last_status_ts = last_status_read[0]
+                last_status = last_status_read[1]
+
+                if lastonline_ts and status == "offline":
+                    if lastonline_ts >= last_status_ts:
+                        status_ts_old = lastonline_ts
+                    else:
+                        status_ts_old = last_status_ts
+                elif not lastonline_ts and status == "offline":
+                    status_ts_old = last_status_ts
+                elif status and status != "offline" and status == last_status:
+                    status_ts_old = last_status_ts
+        except Exception:
+            if lastonline_ts and status == "offline":
+                status_ts_old = lastonline_ts
+    else:
+        if lastonline_ts and status == "offline":
+            status_ts_old = lastonline_ts
+
+    print(f"PlayStation ID:\t\t\t{psn_user_id}")
+    print(f"PSN account ID:\t\t\t{accountid}")
+    print(f"\nStatus:\t\t\t\t{str(status).upper()}")
+    if availability:
+        available_str = "Yes" if availability == "availableToPlay" else "No"
+        print(f"Available to play:\t\t{available_str}")
+
+    psn_platform_displayed = False
+    if psn_platform:
+        print(f"\nPlatform:\t\t\t{psn_platform}")
+        psn_platform_displayed = True
+
+    if not psn_platform_displayed:
+        print()
+    print(f"PS+ user:\t\t\t{isplus}")
+
+    # an official account belonging to a recognised developer, publisher, community manager or another official role
+    if is_verified is not None:
+        print(f"Verified:\t\t\t{is_verified}")
+
+    newline_needed = False
+
+    if aboutme:
+        print(f"\nAbout me:\t\t\t{aboutme}")
+        newline_needed = True
+
+    if langs:
+        prefix = "\n" if not newline_needed else ""
+        print(f"{prefix}Languages:\t\t\t{', '.join(langs)}")
+
+    try:
+        relation = fs.get("friendRelation")
+        print(f"\nRelation:\t\t\t{relation}")
+
+        if relation == "friend":
+            mf = fs.get("mutualFriendsCount")
+            if isinstance(mf, int) and mf >= 0:
+                print(f"Mutual friends:\t\t\t{mf}")
+            elif mf is None:
+                print("Mutual friends:\t\t\tunknown")
+            else:
+                print("Mutual friends:\t\t\thidden")
+        else:
+            # Don't print mutual friends at all
+            pass
+
+    except Exception:
+        pass
+
+    try:
+        print(f"\nProfile URL:\t\t\t{share.get('shareUrl')}")
+        # print(f"Profile QR image:\t\t{share.get('shareImageUrl')}")
+    except Exception:
+        pass
+
+    if status == "offline" and status_ts_old > 0:
+        last_status_dt_str = get_date_from_ts(status_ts_old)
+        print(f"\n* Last time user was available:\t{last_status_dt_str}")
+        print(f"* User is OFFLINE for:\t\t{calculate_timespan(now_local(), int(status_ts_old), show_seconds=False)}")
+    elif status != "offline":
+        if os.path.isfile(psn_last_status_file):
+            try:
+                with open(psn_last_status_file, 'r', encoding="utf-8") as f:
+                    last_status_read = json.load(f)
+                if last_status_read and last_status_read[1] == status:
+                    print(f"* User is {str(status).upper()} for:\t\t{calculate_timespan(now_local(), int(last_status_read[0]), show_seconds=False)}")
+            except Exception:
+                pass
+
+    # Show trophy summary and last earned trophies only if requested
+    if include_trophies:
+        try:
+            print(f"\n* Getting trophy summary ...")
+            ts = psn_user.trophy_summary()
+            et = ts.earned_trophies
+            prog = int(ts.progress) if ts.progress is not None else 0
+            print(f"\nTrophy level:\t\t\t{ts.trophy_level} ({prog}% to next, tier {ts.tier})")
+            print(
+                "Trophies earned:\t\t"
+                f"{et.platinum} Platinum, {et.gold} Gold, {et.silver} Silver, {et.bronze} Bronze "
+                f"({et.platinum + et.gold + et.silver + et.bronze} total)"
+            )
+        except Exception:
+            pass
+
+        num_trophies = 5
+        try:
+            print(f"\n* Getting list of last {num_trophies} earned trophies ...\n")
+            print_last_earned_trophies(psn_user, max_items=num_trophies, title_limit=15)
+        except Exception:
+            pass
+
+    # Show recently played games only if requested
+    if show_recent_games:
+        try:
+            # Helper function to compact duration format, convert "X day(s), HH:MM:SS" to "Xd HH:MM:SS"
+            def _compact_duration(s):
+                if not s:
+                    return "0:00:00"
+                s = str(s).strip()
+
+                if "day" in s.lower():
+                    try:
+                        if "," in s:
+                            parts = s.split(",", 1)
+                            days_part = parts[0].strip()            # "1 day" / "2 days"
+                            time_part = parts[1].strip()            # "23:47:54"
+                            d = int(days_part.split()[0])
+                            return f"{d}d {time_part}"
+                        else:
+                            # No comma, try to extract days anyway (unlikely but handle it)
+                            words = s.split()
+                            if len(words) >= 2 and words[1].lower().startswith("day"):
+                                d = int(words[0])
+                                if len(words) > 2:
+                                    time_part = " ".join(words[2:])
+                                    return f"{d}d {time_part}"
+                                return f"{d}d"
+                    except (ValueError, IndexError):
+                        return s  # fallback to original if parsing fails
+                return s
+
+            def _shorten_middle(s, max_len, ellipsis="..."):
+                if s is None:
+                    return ""
+                s = str(s)
+                if len(s) <= max_len:
+                    return s
+                keep = max_len - len(ellipsis)
+                if keep <= 0:
+                    return ellipsis[:max_len]
+                left = keep // 2
+                right = keep - left
+                return f"{s[:left]}{ellipsis}{s[-right:]}"
+
+            recent_entries = []
+            print(f"\n* Getting list of recently played games ...")
+            for i, t in enumerate(psn_user.title_stats(limit=10, page_size=50), 1):
+                if not t:
+                    continue
+                name_raw = t.name or "(unknown)"
+                name = normalize_ascii(name_raw)
+                cat = getattr(getattr(t, "category", None), "name", "UNKNOWN")
+                last_played = (
+                    get_date_from_ts(int(t.last_played_date_time.timestamp()))
+                    if t.last_played_date_time else "n/a"
+                )
+                total_raw = str(t.play_duration) if t.play_duration else "0:00:00"
+                # Compact duration immediately to ensure it fits in the column
+                total = _compact_duration(total_raw)
+                recent_entries.append(f"Recent #{i}:\t\t\t{name} | {cat} | last played {last_played} | total {total}")
+
+            # Decide column widths based on terminal size
+            try:
+                import shutil
+                term_width = shutil.get_terminal_size(fallback=(100, 24)).columns
+            except Exception:
+                term_width = 100
+
+            w_num = 3
+            w_platform = 8
+            w_last = 24
+            w_total = 14  # fits "999d 23:59:59" (14 chars) after compacting "X day(s), HH:MM:SS" -> "Xd HH:MM:SS"
+            fixed = 1 + w_num + 2 + w_platform + 2 + w_last + 2 + w_total
+            w_title = max(24, term_width - fixed)
+
+            # Only print the table if we have entries
+            if recent_entries:
+                print()
+                hdr = f"{'#'.ljust(w_num)}  {'Title'.ljust(w_title)}  {'Platform'.ljust(w_platform)}  {'Last played'.ljust(w_last)}  {'Total'.ljust(w_total)}"
+                sep = f"{'-' * w_num}  {'-' * w_title}  {'-' * w_platform}  {'-' * w_last}  {'-' * w_total}"
+                print(hdr)
+                print(sep)
+
+                for i, entry in enumerate(recent_entries, 1):
+                    try:
+                        _, rest = entry.split(":", 1)
+                        parts = rest.strip().split("|")
+                        name = parts[0].strip()
+                        cat = parts[1].strip()
+                        last_played = parts[2].replace("last played", "").strip()
+                        total = _compact_duration(parts[3].replace("total", "").strip())
+                    except Exception:
+                        # If parsing ever fails, print raw line as a fallback
+                        print(entry)
+                        continue
+
+                    name_fmt = _shorten_middle(name, w_title)
+                    row = (
+                        f"{str(i).ljust(w_num)}  "
+                        f"{name_fmt.ljust(w_title)}  "
+                        f"{cat.ljust(w_platform)}  "
+                        f"{last_played.ljust(w_last)}  "
+                        f"{total.ljust(w_total)}"
+                    )
+                    print(row)
+        except Exception:
+            pass
+
+    if game_name:
+        launchplatform_str = ""
+        if launchplatform:
+            launchplatform_str = f" ({launchplatform})"
+        print(f"\nUser is currently in-game:\t{game_name}{launchplatform_str}")
+
+
 # Main function that monitors gaming activity of the specified PSN user
 def psn_monitor_user(psn_user_id, csv_file_name):
 
@@ -801,6 +1291,8 @@ def psn_monitor_user(psn_user_id, csv_file_name):
     except Exception as e:
         print(f"* Error: {e}")
 
+    print("Sneaking into PlayStation like a ninja ... (be patient, secrets take time)\n")
+
     try:
         psnawp = PSNAWP(PSN_NPSSO)
         psn_user = psnawp.user(online_id=psn_user_id)
@@ -808,6 +1300,10 @@ def psn_monitor_user(psn_user_id, csv_file_name):
         profile = psn_user.profile()
         aboutme = profile.get("aboutMe")
         isplus = profile.get("isPlus")
+        langs = profile.get("languages") or []
+        is_verified = profile.get("isOfficiallyVerified")
+        fs = psn_user.friendship()
+        share = psn_user.get_shareable_profile_link()
     except Exception as e:
         print("* Error:", e)
         sys.exit(1)
@@ -827,19 +1323,23 @@ def psn_monitor_user(psn_user_id, csv_file_name):
     status = str(status).lower()
 
     psn_platform = psn_user_presence["basicPresence"]["primaryPlatformInfo"].get("platform")
-    psn_platform = str(psn_platform).upper()
+    psn_platform = str(psn_platform).upper() if psn_platform else ""
     lastonline = psn_user_presence["basicPresence"]["primaryPlatformInfo"].get("lastOnlineDate")
+    availability = psn_user_presence["basicPresence"].get("availability")
 
     lastonline_dt = convert_iso_str_to_datetime(lastonline)
     if lastonline_dt:
         lastonline_ts = int(lastonline_dt.timestamp())
     else:
         lastonline_ts = 0
+
     gametitleinfolist = psn_user_presence["basicPresence"].get("gameTitleInfoList")
     game_name = ""
     launchplatform = ""
+
     if gametitleinfolist:
-        game_name = gametitleinfolist[0].get("titleName")
+        game_name_raw = gametitleinfolist[0].get("titleName")
+        game_name = normalize_ascii(game_name_raw) if game_name_raw else ""
         launchplatform = gametitleinfolist[0].get("launchPlatform")
         launchplatform = str(launchplatform).upper()
 
@@ -905,12 +1405,57 @@ def psn_monitor_user(psn_user_id, csv_file_name):
     print(f"PSN account ID:\t\t\t{accountid}")
 
     print(f"\nStatus:\t\t\t\t{str(status).upper()}")
+    if availability:
+        available_str = "Yes" if availability == "availableToPlay" else "No"
+        print(f"Available to play:\t\t{available_str}")
+
+    psn_platform_displayed = False
     if psn_platform:
-        print(f"Platform:\t\t\t{psn_platform}")
+        print(f"\nPlatform:\t\t\t{psn_platform}")
+        psn_platform_displayed = True
+
+    if not psn_platform_displayed:
+        print()
     print(f"PS+ user:\t\t\t{isplus}")
 
+    # an official account belonging to a recognised developer, publisher, community manager or another official role
+    if is_verified is not None:
+        print(f"Verified:\t\t\t{is_verified}")
+
+    newline_needed = False
+
     if aboutme:
         print(f"\nAbout me:\t\t\t{aboutme}")
+        newline_needed = True
+
+    if langs:
+        prefix = "\n" if not newline_needed else ""
+        print(f"{prefix}Languages:\t\t\t{', '.join(langs)}")
+
+    try:
+        relation = fs.get("friendRelation")
+        print(f"\nRelation:\t\t\t{relation}")
+
+        if relation == "friend":
+            mf = fs.get("mutualFriendsCount")
+            if isinstance(mf, int) and mf >= 0:
+                print(f"Mutual friends:\t\t\t{mf}")
+            elif mf is None:
+                print("Mutual friends:\t\t\tunknown")
+            else:
+                print("Mutual friends:\t\t\thidden")
+        else:
+            # Don't print mutual friends at all
+            pass
+
+    except Exception:
+        pass
+
+    try:
+        print(f"\nProfile URL:\t\t\t{share.get('shareUrl')}")
+        # print(f"Profile QR image:\t\t{share.get('shareImageUrl')}")
+    except Exception:
+        pass
 
     if status != "offline" and game_name:
         launchplatform_str = ""
@@ -947,6 +1492,7 @@ def psn_monitor_user(psn_user_id, csv_file_name):
     email_sent = False
 
     m_subject = m_body = ""
+    error_streak = 0
 
     def get_sleep_interval():
         return PSN_ACTIVE_CHECK_INTERVAL if status and status != "offline" else PSN_CHECK_INTERVAL
@@ -968,7 +1514,8 @@ def psn_monitor_user(psn_user_id, csv_file_name):
             game_name = ""
             launchplatform = ""
             if gametitleinfolist:
-                game_name = gametitleinfolist[0].get("titleName")
+                game_name_raw = gametitleinfolist[0].get("titleName")
+                game_name = normalize_ascii(game_name_raw) if game_name_raw else ""
                 launchplatform = gametitleinfolist[0].get("launchPlatform")
                 launchplatform = str(launchplatform).upper()
             if platform.system() != 'Windows':
@@ -1004,15 +1551,45 @@ def psn_monitor_user(psn_user_id, csv_file_name):
             if platform.system() != 'Windows':
                 signal.alarm(0)
 
-            if 'Remote end closed connection' in str(e):
+            msg = str(e).lower()
+            # Connection-related errors that can often be fixed by recreating the session
+            connection_error = ('remote end closed connection' in msg or 'connection reset by peer' in msg or 'connection aborted' in msg)
+
+            if connection_error:
                 try:
                     psnawp = PSNAWP(PSN_NPSSO)
                     psn_user = psnawp.user(online_id=psn_user_id)
                 except Exception:
                     pass
-                time.sleep(FUNCTION_TIMEOUT)
+                error_streak += 1
+                # For connection errors, retry quickly since they're often transient
+                retry_delay = FUNCTION_TIMEOUT
+                # However, if connection errors persist, it might indicate an expired NPSSO token
+                # Send notification after 5+ consecutive connection errors
+                if ERROR_NOTIFICATION and not email_sent and error_streak >= 5:
+                    print(f"* Multiple consecutive connection errors detected - this may indicate an expired NPSSO token, error streak {error_streak}: {e}")
+                    m_subject = f"psn_monitor: PSN NPSSO key might be expired! (user: {psn_user_id})"
+                    m_body = f"Multiple consecutive connection errors detected - this may indicate an expired NPSSO token.\n\nError: {e}\n\nError streak: {error_streak}{get_cur_ts(nl_ch + nl_ch + 'Timestamp: ')}"
+                    print(f"Sending email notification to {RECEIVER_EMAIL}")
+                    send_email(m_subject, m_body, "", SMTP_SSL)
+                    email_sent = True
+                    print_cur_ts("Timestamp:\t\t\t")
+                # print(f"* Connection error, recreating session and retrying in {display_time(retry_delay)}: {e}")
+                # print_cur_ts("Timestamp:\t\t\t")
+                time.sleep(retry_delay)
                 continue
 
+            error_streak += 1
+
+            # Check for authentication errors (excluding connection errors which we already handled)
+            likely_auth = ('401' in msg) or ('expired' in msg) or ('invalid' in msg)
+            if likely_auth and ERROR_NOTIFICATION and not email_sent and error_streak >= 5:
+                m_subject = f"psn_monitor: PSN NPSSO key error! (user: {psn_user_id})"
+                m_body = f"PSN NPSSO key might not be valid anymore: {e}{get_cur_ts(nl_ch + nl_ch + 'Timestamp: ')}"
+                print(f"Sending email notification to {RECEIVER_EMAIL}")
+                send_email(m_subject, m_body, "", SMTP_SSL)
+                email_sent = True
+
             sleep_interval = get_sleep_interval()
             print(f"* Error, retrying in {display_time(sleep_interval)}: {e}")
             print_cur_ts("Timestamp:\t\t\t")
@@ -1021,6 +1598,7 @@ def psn_monitor_user(psn_user_id, csv_file_name):
 
         else:
             email_sent = False
+            error_streak = 0
 
         finally:
             if platform.system() != 'Windows':
@@ -1274,6 +1852,27 @@ def main():
         help="Send test email to verify SMTP settings"
     )
 
+    # User information
+    info = parser.add_argument_group("User information")
+    info.add_argument(
+        "-i", "--info",
+        dest="info_mode",
+        action="store_true",
+        help="Get detailed user information and display it, then exit"
+    )
+    info.add_argument(
+        "--trophies",
+        dest="include_trophies",
+        action="store_true",
+        help="Show trophy summary and last earned trophies (only works with -i/--info)"
+    )
+    info.add_argument(
+        "--no-recent-games",
+        dest="no_recent_games",
+        action="store_true",
+        help="Don't fetch recently played games list (only works with -i/--info)"
+    )
+
     # Intervals & timers
     times = parser.add_argument_group("Intervals & timers")
     times.add_argument(
@@ -1403,6 +2002,12 @@ def main():
         print("* Error: PSN_NPSSO (-n / --npsso_key) value is empty or incorrect")
         sys.exit(1)
 
+    if args.info_mode:
+        include_trophies = args.include_trophies if hasattr(args, 'include_trophies') and args.include_trophies else False
+        show_recent_games = not (hasattr(args, 'no_recent_games') and args.no_recent_games)
+        get_user_info(args.psn_user_id, include_trophies=include_trophies, show_recent_games=show_recent_games)
+        sys.exit(0)
+
     if args.check_interval:
         PSN_CHECK_INTERVAL = args.check_interval
         LIVENESS_CHECK_COUNTER = LIVENESS_CHECK_INTERVAL / PSN_CHECK_INTERVAL

psn_monitor-1.5.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-psn_monitor.py,sha256=a84GPByu6XlwlCm04lnNUWng9IXkJFQpCCZxPa_IX8Y,55082
-psn_monitor-1.5.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-psn_monitor-1.5.1.dist-info/METADATA,sha256=l5yH9pB3Hwvwx-Ik_09iP6rzxx6ab2Ipd5WBKRaR7cM,12577
-psn_monitor-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-psn_monitor-1.5.1.dist-info/entry_points.txt,sha256=2yXV06LBmzhWnvc4bKuEblezaWSHEWKdB2HClGXZlnk,49
-psn_monitor-1.5.1.dist-info/top_level.txt,sha256=IG37NL5yiB0wgx_MN-L47SDxKdqRXzjIqBpkU7JiISE,12
-psn_monitor-1.5.1.dist-info/RECORD,,