steam-client 2.1.0.dev0__tar.gz → 3.0.0.dev0__tar.gz

{steam-client-2.1.0.dev0/steam_client.egg-info → steam_client-3.0.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: steam-client
-Version: 2.1.0.dev0
+Version: 3.0.0.dev0
 Summary: Steam client library for Python
 Author-email: William McAllister <dev.garulf@gmail.com>
 License: MIT
@@ -11,3 +11,6 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: vdf>=3.4
+Requires-Dist: pycrc>=0.10.0
+Dynamic: license-file

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/pyproject.toml

@@ -6,7 +6,7 @@ name = "steam-client"
 authors = [
     {name = "William McAllister", email = "dev.garulf@gmail.com"}
 ]
-version = "2.1.0-dev.0"
+version = "3.0.0-dev.0"
 description = "Steam client library for Python"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -31,7 +31,9 @@ packages = ["steam_client"]
 "steam_client" = ["py.typed"]
 
 [tool.bumpversion]
-current_version = "2.0.1-dev.0"
+current_version = "3.0.0-dev.0"
+search = "version = \"{current_version}\""
+replace = "version = \"{new_version}\""
 parse = """(?x)
     (?P<major>[0-9]+)
     \\.(?P<minor>[0-9]+)
@@ -45,8 +47,6 @@ serialize = [
     "{major}.{minor}.{patch}-{label}.{label_n}",
     "{major}.{minor}.{patch}",
 ]
-search = "version = '{current_version}'"
-replace = "version = '{new_version}'"
 tag = true
 allow_dirty = false
 commit = true

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/app.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 
-from .commands import Commands 
+from .commands import Commands
 
 if TYPE_CHECKING:
     from .steam import Steam
@@ -31,7 +31,7 @@ class App(ABC):
 
     @property
     @abstractmethod
-    def icon(self) -> Path:
+    def icon(self) -> Path | None:
         """Returns the path to the icon image."""
         pass
 

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/commands.py

@@ -4,6 +4,7 @@ from enum import StrEnum
 
 SCHEME = 'steam'
 
+
 class SteamWindows(StrEnum):
     """Enumeration of Steam client windows."""
     MAIN = 'main'
@@ -19,8 +20,9 @@ class SteamWindows(StrEnum):
     TOOLS = 'tools'
     CONSOLE = 'console'
 
+
 class Command():
-   
+
     def __init__(self, scheme: str):
         self._scheme = scheme
 
@@ -38,32 +40,30 @@ class Commands:
     def __init__(self):
         self._command = Command(SCHEME)
 
-    def run_game_id(self, app_id: str) -> str:
+    def run_game_id(self, app_id: str) -> None:
         """Launches game with the specified ID in the Steam client."""
         self._command(['rungameid'], app_id)
 
-    def store(self, app_id: str) -> str:
+    def store(self, app_id: str) -> None:
         """Opens the game's store page in the Steam client."""
         self._command(['store'], app_id)
 
-    def install(self, app_id: str) -> str:
+    def install(self, app_id: str) -> None:
         """Opens the game's install prompt in the Steam client."""
         self._command(['install'], app_id)
 
-    def uninstall(self, app_id: str) -> str:
+    def uninstall(self, app_id: str) -> None:
         """Opens the game's uninstall prompt in the Steam client."""
         self._command(['uninstall'], app_id)
 
-    def update_news(self, app_id: str) -> str:
+    def update_news(self, app_id: str) -> None:
         """Opens the game's update news in the Steam client."""
         self._command(['updatenews'], app_id)
 
-    def open(self, window: SteamWindows) -> str:
+    def open(self, window: SteamWindows) -> None:
         """Opens the specified window in the Steam client."""
         self._command(['open'], window)
 
-    def open_url(self, url: str) -> str:
+    def open_url(self, url: str) -> None:
         """Opens the specified URL in the Steam client."""
         self._command(['openurl'], url)
-
-

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/game.py

@@ -3,7 +3,7 @@ import functools
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-import vdf
+import vdf  # type: ignore
 
 if TYPE_CHECKING:
     from .steam import Steam
@@ -13,13 +13,13 @@ from .app import App
 
 UNKNOWN_GAME_NAME = 'UNKNOWN'
 
-ASSETS = [
+ASSETS = frozenset({
     "header.jpg",
     "library_600x900.jpg",
     "library_hero.jpg",
     "library_hero_blur.jpg",
     "logo.png"
-]
+})
 
 
 class SteamGame(App):
@@ -28,10 +28,16 @@ class SteamGame(App):
     def __init__(self, steam: Steam, library_path: str, appid: str):
         self.library_path = library_path
         self._appid = appid
+        self._icon: Path | None = None
+        self._name: str | None = None
         super().__init__(steam)
 
     def __repr__(self) -> str:
-        return f'Game(steam={self._steam.__repr__()}, library_path={self.library_path.__repr__()}, appid={self.appid.__repr__()})'
+        return (
+            f'Game(steam={self._steam.__repr__()}, '
+            f'library_path={self.library_path.__repr__()}, '
+            f'appid={self.appid.__repr__()})'
+        )
 
     @property
     def asset_dir(self) -> Path:
@@ -39,12 +45,18 @@ class SteamGame(App):
         return Path(self._steam.library_cache).joinpath(self.appid)
 
     @property
-    def icon(self) -> Path:
+    def icon(self) -> Path | None:
         """Returns the path to the icon image."""
-        for asset in self.asset_dir.iterdir():
-            if asset.name not in ASSETS:
-                return asset
-        return Path(self._steam.library_cache).joinpath(f'{self.appid}_icon.jpg')
+        if self._icon is None:
+            self._icon = next(
+                (
+                    asset
+                    for asset in self.asset_dir.iterdir()
+                    if asset.is_file() and asset.name not in ASSETS
+                ),
+                None,
+            )
+        return self._icon
 
     @property
     def header(self) -> Path:
@@ -81,9 +93,14 @@ class SteamGame(App):
         except FileNotFoundError:
             return {}
 
-    @functools.cached_property
+    @property
     def name(self) -> str:
         """Returns the name of the game."""
+        if self._name is None:
+            self._name = self._get_name_from_manifest()
+        return self._name
+
+    def _get_name_from_manifest(self) -> str:
         try:
             return self._manifest['AppState']['name']
         except KeyError:
@@ -96,8 +113,8 @@ class SteamGame(App):
 
     def open_store_page(self):
         """Opens the game's store page in the Steam client."""
-        self._steam.commands.store(self.appid)
+        self._commands.store(self.appid)
 
     def uninstall(self):
         """Uninstalls the game."""
-        self._steam.commands.uninstall(self.appid)
+        self._commands.uninstall(self.appid)

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/library.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
-from pathlib import Path
 import hashlib
 from typing import TYPE_CHECKING, List, Optional, Union
 
-import vdf
+import vdf  # type: ignore
 
 from steam_client.shortcut import Shortcut
 
@@ -70,7 +69,7 @@ class Library:
     def shortcuts(self) -> List[Shortcut]:
         """Returns the Non-Steam shortcuts from the Steam library."""
         shortcuts = []
-        for user in self._steam.login_users.users():
+        for user in self._steam.users:
             shortcuts.extend(user.shortcuts())
         return shortcuts
 

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/library_directory.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, List
-from pathlib import Path
-
-import vdf
 
 if TYPE_CHECKING:
     from .steam import Steam

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client/utils.py

@@ -1,5 +1,5 @@
-import winreg as reg
-from winreg import HKEY_LOCAL_MACHINE
+import importlib
+import sys
 
 from .steam import Steam
 
@@ -9,7 +9,11 @@ STEAM_SUB_KEY = r'SOFTWARE\WOW6432Node\Valve\Steam'
 
 def get_steam_from_registry() -> str:
     """Returns the Steam install path from the Windows registry."""
-    with reg.OpenKey(HKEY_LOCAL_MACHINE, STEAM_SUB_KEY) as hkey:
+    if sys.platform != "win32":
+        raise OSError("Windows registry is only available on Windows")
+
+    reg = importlib.import_module("winreg")
+    with reg.OpenKey(reg.HKEY_LOCAL_MACHINE, STEAM_SUB_KEY) as hkey:
         return reg.QueryValueEx(hkey, "InstallPath")[0]
 
 

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0/steam_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: steam-client
-Version: 2.1.0.dev0
+Version: 3.0.0.dev0
 Summary: Steam client library for Python
 Author-email: William McAllister <dev.garulf@gmail.com>
 License: MIT
@@ -11,3 +11,6 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: vdf>=3.4
+Requires-Dist: pycrc>=0.10.0
+Dynamic: license-file

{steam-client-2.1.0.dev0 → steam_client-3.0.0.dev0}/steam_client.egg-info/SOURCES.txt

@@ -17,4 +17,9 @@ steam_client.egg-info/PKG-INFO
 steam_client.egg-info/SOURCES.txt
 steam_client.egg-info/dependency_links.txt
 steam_client.egg-info/requires.txt
-steam_client.egg-info/top_level.txt
+steam_client.egg-info/top_level.txt
+tests/test_commands.py
+tests/test_game.py
+tests/test_login_users.py
+tests/test_shortcut.py
+tests/test_steam.py

steam_client-3.0.0.dev0/tests/test_commands.py

@@ -0,0 +1,61 @@
+from unittest.mock import patch
+
+from steam_client.commands import Command, Commands, SteamWindows, SCHEME
+
+
+class TestCommand:
+    def setup_method(self):
+        self.command = Command(SCHEME)
+
+    def test_create_uri_single_path(self):
+        uri = self.command._create_uri(["rungameid"], "12345")
+        assert uri == "steam://rungameid/12345"
+
+    def test_create_uri_multi_path(self):
+        uri = self.command._create_uri(["store", "app"], "67890")
+        assert uri == "steam://store/app/67890"
+
+    def test_call_opens_browser(self):
+        with patch("webbrowser.open") as mock_open:
+            self.command(["rungameid"], "12345")
+        mock_open.assert_called_once_with("steam://rungameid/12345")
+
+
+class TestCommands:
+    def setup_method(self):
+        self.commands = Commands()
+
+    def test_run_game_id(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.run_game_id("12345")
+        mock_open.assert_called_once_with("steam://rungameid/12345")
+
+    def test_store(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.store("12345")
+        mock_open.assert_called_once_with("steam://store/12345")
+
+    def test_install(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.install("12345")
+        mock_open.assert_called_once_with("steam://install/12345")
+
+    def test_uninstall(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.uninstall("12345")
+        mock_open.assert_called_once_with("steam://uninstall/12345")
+
+    def test_update_news(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.update_news("12345")
+        mock_open.assert_called_once_with("steam://updatenews/12345")
+
+    def test_open_window(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.open(SteamWindows.SETTINGS)
+        mock_open.assert_called_once_with(f"steam://open/{SteamWindows.SETTINGS}")
+
+    def test_open_url(self):
+        with patch("webbrowser.open") as mock_open:
+            self.commands.open_url("https://store.steampowered.com")
+        mock_open.assert_called_once_with("steam://openurl/https://store.steampowered.com")

steam_client-3.0.0.dev0/tests/test_game.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+import pytest
+
+from steam_client.game import SteamGame, UNKNOWN_GAME_NAME
+
+LIBRARY_PATH = "/library"
+APPID = "12345"
+
+
+@pytest.fixture
+def game(steam):
+    return SteamGame(steam, LIBRARY_PATH, APPID)
+
+
+def test_game_appid(game):
+    assert game.appid == APPID
+
+
+def test_game_repr(game, steam):
+    r = repr(game)
+    assert APPID in r
+    assert LIBRARY_PATH in r
+
+
+def test_manifest_path(game):
+    assert game.manifest_path == Path(LIBRARY_PATH) / "steamapps" / f"appmanifest_{APPID}.acf"
+
+
+def test_asset_dir(game):
+    assert game.asset_dir == Path("/fake/steam/appcache/librarycache") / APPID
+
+
+def test_header(game):
+    assert game.header == Path("/fake/steam/appcache/librarycache") / f"{APPID}_header.jpg"
+
+
+def test_grid(game):
+    assert game.grid == Path("/fake/steam/appcache/librarycache") / f"{APPID}_library_600x900.jpg"
+
+
+def test_hero(game):
+    assert game.hero == Path("/fake/steam/appcache/librarycache") / f"{APPID}_library_hero.jpg"
+
+
+def test_hero_blur(game):
+    assert game.hero_blur == Path("/fake/steam/appcache/librarycache") / f"{APPID}_library_hero_blur.jpg"
+
+
+def test_game_name_from_manifest(game):
+    game.__dict__["_manifest"] = {"AppState": {"name": "Portal 2"}}
+    assert game.name == "Portal 2"
+
+
+def test_game_name_unknown_when_manifest_missing_key(game):
+    game.__dict__["_manifest"] = {}
+    assert game.name == UNKNOWN_GAME_NAME
+
+
+def test_game_name_unknown_when_manifest_empty(game):
+    game.__dict__["_manifest"] = {"AppState": {}}
+    assert game.name == UNKNOWN_GAME_NAME

steam_client-3.0.0.dev0/tests/test_login_users.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from steam_client.login_users import LoginUser, LoginUsers, User, UserData, STEAM64_OFFSET
+
+
+FAKE_STEAM_ID3 = 12345678
+FAKE_USER_ID = STEAM64_OFFSET + FAKE_STEAM_ID3
+
+
+def test_login_user_is_most_recent(login_user):
+    assert login_user.is_most_recent is True
+
+
+def test_login_user_not_most_recent(steam, user_data):
+    data = UserData(
+        AccountName=user_data.AccountName,
+        PersonaName=user_data.PersonaName,
+        RememberPassword=user_data.RememberPassword,
+        WantsOfflineMode=user_data.WantsOfflineMode,
+        SkipOfflineModeWarning=user_data.SkipOfflineModeWarning,
+        AllowAutoLogin=user_data.AllowAutoLogin,
+        MostRecent="0",
+        Timestamp=user_data.Timestamp,
+    )
+    user = User(id=FAKE_USER_ID, data=data)
+    lu = LoginUser(steam, user)
+    assert lu.is_most_recent is False
+
+
+def test_steam_id3(login_user):
+    assert login_user.steam_id3 == FAKE_STEAM_ID3
+
+
+def test_user_data_dir(login_user):
+    assert login_user.user_data_dir == Path("/fake/steam/userdata") / str(FAKE_STEAM_ID3)
+
+
+def test_config(login_user):
+    assert login_user.config == login_user.user_data_dir / "config"
+
+
+def test_shortcuts_file(login_user):
+    assert login_user.shortcuts_file == login_user.config / "shortcuts.vdf"
+
+
+def test_grid_path(login_user):
+    assert login_user.grid_path == login_user.user_data_dir / "config" / "grid"
+
+
+def test_shortcuts_parses_vdf(steam, login_user):
+    fake_shortcut_data = {
+        "shortcuts": {
+            "0": {
+                "appid": 0,
+                "appname": "My Game",
+                "exe": "/path/game.exe",
+                "StartDir": "/path",
+                "LaunchOptions": "",
+                "icon": "",
+                "tags": {},
+            }
+        }
+    }
+    with patch("builtins.open", MagicMock()), \
+         patch("vdf.binary_load", return_value=fake_shortcut_data):
+        shortcuts = login_user.shortcuts()
+    assert len(shortcuts) == 1
+    assert shortcuts[0].name == "My Game"
+
+
+def test_login_users_most_recent(steam, user_data):
+    recent_user = User(id=FAKE_USER_ID, data=user_data)
+    not_recent_data = UserData(
+        AccountName="other",
+        PersonaName="Other",
+        RememberPassword="0",
+        WantsOfflineMode="0",
+        SkipOfflineModeWarning="0",
+        AllowAutoLogin="0",
+        MostRecent="0",
+        Timestamp="0",
+    )
+    not_recent_user = User(id=FAKE_USER_ID + 1, data=not_recent_data)
+    users = [LoginUser(steam, recent_user), LoginUser(steam, not_recent_user)]
+
+    with patch.object(LoginUsers, "users", return_value=users):
+        lu = LoginUsers(steam)
+        most_recent = lu.most_recent_user()
+
+    assert most_recent is not None
+    assert most_recent.is_most_recent is True
+
+
+def test_login_users_most_recent_none_when_no_recent(steam, user_data):
+    data = UserData(
+        AccountName="other",
+        PersonaName="Other",
+        RememberPassword="0",
+        WantsOfflineMode="0",
+        SkipOfflineModeWarning="0",
+        AllowAutoLogin="0",
+        MostRecent="0",
+        Timestamp="0",
+    )
+    users = [LoginUser(steam, User(id=FAKE_USER_ID, data=data))]
+
+    with patch.object(LoginUsers, "users", return_value=users):
+        lu = LoginUsers(steam)
+        most_recent = lu.most_recent_user()
+
+    assert most_recent is None

steam_client-3.0.0.dev0/tests/test_shortcut.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+import pytest
+
+import pycrc.algorithms as crc
+
+from steam_client.shortcut import Shortcut
+
+
+@pytest.fixture
+def shortcut(steam, login_user, shortcut_entry):
+    return Shortcut(steam, login_user, shortcut_entry)
+
+
+def _compute_appid(exe: str, appname: str) -> str:
+    algorithm = crc.Crc(
+        width=32,
+        poly=0x04C11DB7,
+        reflect_in=True,
+        xor_in=0xFFFFFFFF,
+        reflect_out=True,
+        xor_out=0xFFFFFFFF,
+    )
+    input_string = exe + appname
+    top_32 = algorithm.bit_by_bit(input_string) | 0x80000000
+    full_64 = (top_32 << 32) | 0x02000000
+    return str(full_64)
+
+
+def test_shortcut_name(shortcut):
+    assert shortcut.name == "Test Game"
+
+
+def test_shortcut_appid_is_string(shortcut):
+    assert isinstance(shortcut.appid, str)
+
+
+def test_shortcut_appid_matches_crc(shortcut, shortcut_entry):
+    expected = _compute_appid(shortcut_entry["exe"], shortcut_entry["appname"])
+    assert shortcut.appid == expected
+
+
+def test_shortcut_short_id(shortcut):
+    expected = str(int(shortcut.appid) >> 32)
+    assert shortcut._short_id() == expected
+
+
+def test_shortcut_icon_uses_data_icon(shortcut, shortcut_entry):
+    assert shortcut.icon == Path(shortcut_entry["icon"])
+
+
+def test_shortcut_header(shortcut, login_user):
+    short_id = shortcut._short_id()
+    assert shortcut.header == login_user.grid_path / f"{short_id}.png"
+
+
+def test_shortcut_grid(shortcut, login_user):
+    short_id = shortcut._short_id()
+    assert shortcut.grid == login_user.grid_path / f"{short_id}p.png"
+
+
+def test_shortcut_hero(shortcut, login_user):
+    short_id = shortcut._short_id()
+    assert shortcut.hero == login_user.grid_path / f"{short_id}_hero.png"
+
+
+def test_shortcut_repr(shortcut):
+    r = repr(shortcut)
+    assert "Shortcut" in r
+    assert "Test Game" in r

steam_client-3.0.0.dev0/tests/test_steam.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+from steam_client.steam import Steam, WIN_STEAM_PATH
+
+
+def test_steam_default_path():
+    s = Steam()
+    assert s.base_path == WIN_STEAM_PATH
+
+
+def test_steam_custom_path():
+    s = Steam("/custom/path")
+    assert s.base_path == "/custom/path"
+
+
+def test_steam_repr():
+    s = Steam("/custom/path")
+    assert repr(s) == "Steam(base_path='/custom/path')"
+
+
+def test_app_cache(steam):
+    assert steam.app_cache == Path("/fake/steam/appcache")
+
+
+def test_user_data(steam):
+    assert steam.user_data == Path("/fake/steam/userdata")
+
+
+def test_library_folders(steam):
+    assert steam.library_folders == Path("/fake/steam/config/libraryfolders.vdf")
+
+
+def test_library_cache(steam):
+    assert steam.library_cache == Path("/fake/steam/appcache/librarycache")