steam-client 3.0.0.dev0__tar.gz → 4.0.0__tar.gz

steam_client-4.0.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: steam-client
+Version: 4.0.0
+Summary: Steam client library for Python
+Author-email: William McAllister <dev.garulf@gmail.com>
+License: MIT
+Project-URL: Source, https://github.com/garulf/steam-client
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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
+
+A Python library for interacting with a locally installed Steam client — enumerate your game library/non-steam games, read game metadata and artwork paths, send Steam URI commands, and query the Steam Web API.
+
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-garulf-FFDD00?style=flat&logo=buy-me-a-coffee&logoColor=black)](https://www.buymeacoffee.com/garulf)
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-garulf-FF5E5B?style=flat&logo=ko-fi&logoColor=white)](https://ko-fi.com/garulf)
+
+---
+
+## Installation
+
+Requires Python 3.8+.
+
+```bash
+pip install steam-client
+```
+
+Or install from source:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+```python
+from steam_client.steam import Steam
+
+steam = Steam()  # Uses default path: C:\Program Files (x86)\Steam
+
+# On Windows, auto-detect path from registry:
+from steam_client.utils import steam_from_registry
+steam = steam_from_registry()
+```
+
+---
+
+## Common Operations
+
+### List all installed games
+
+```python
+for game in steam.library.games():
+    print(game.appid, game.name)
+```
+
+### Find a game
+
+```python
+game = steam.library.game_by_id("440")       # by app ID
+game = steam.library.game_by_name("Portal 2") # by name (case-insensitive)
+```
+
+### Artwork paths
+
+```python
+game.header   # Path to header image    (460×215 jpg)
+game.grid     # Path to grid image      (600×900 jpg)
+game.hero     # Path to hero image
+game.icon     # Path to icon file, or None
+```
+
+### Launch and manage games via Steam URI commands
+
+```python
+from steam_client.commands import Commands, SteamWindows
+
+commands = Commands()
+commands.run_game_id("440")         # Launch a game
+commands.store("440")               # Open store page
+commands.install("440")             # Prompt install
+commands.uninstall("440")           # Prompt uninstall
+commands.open(SteamWindows.FRIENDS) # Open a Steam window
+commands.open_url("https://store.steampowered.com")
+```
+
+Or launch a game directly from a `SteamGame` object:
+
+```python
+game.run()
+```
+
+### Users and shortcuts
+
+```python
+for user in steam.users:
+    print(user.user.data.PersonaName)
+
+for shortcut in steam.library.shortcuts():
+    print(shortcut.appname)
+```
+
+### Steam Web API
+
+```python
+from steam_client.web_api import WebAPI
+
+api = WebAPI()
+apps = api.get_app_list()
+```
+
+---
+
+## Platform Notes
+
+| Platform | Default path                   | Registry helper         |
+|----------|--------------------------------|-------------------------|
+| Windows  | `C:\Program Files (x86)\Steam` | `steam_from_registry()` |
+| Linux    | `~/.local/share/steam`         | Not available           |
+
+Pass a custom path to override the default:
+
+```python
+steam = Steam("/custom/steam/path")
+```
+
+Requires read access to local Steam config files (`libraryfolders.vdf`, `shortcuts.vdf`, appmanifest files).
+
+---
+
+## Development
+
+```bash
+pytest          # Run tests
+flake8 steam_client  # Lint
+mypy steam_client    # Type check
+tox             # Run all environments (lint, type, py311–314)
+```

steam_client-4.0.0/README.md

@@ -0,0 +1,130 @@
+# Steam Client
+
+A Python library for interacting with a locally installed Steam client — enumerate your game library/non-steam games, read game metadata and artwork paths, send Steam URI commands, and query the Steam Web API.
+
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-garulf-FFDD00?style=flat&logo=buy-me-a-coffee&logoColor=black)](https://www.buymeacoffee.com/garulf)
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-garulf-FF5E5B?style=flat&logo=ko-fi&logoColor=white)](https://ko-fi.com/garulf)
+
+---
+
+## Installation
+
+Requires Python 3.8+.
+
+```bash
+pip install steam-client
+```
+
+Or install from source:
+
+```bash
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+```python
+from steam_client.steam import Steam
+
+steam = Steam()  # Uses default path: C:\Program Files (x86)\Steam
+
+# On Windows, auto-detect path from registry:
+from steam_client.utils import steam_from_registry
+steam = steam_from_registry()
+```
+
+---
+
+## Common Operations
+
+### List all installed games
+
+```python
+for game in steam.library.games():
+    print(game.appid, game.name)
+```
+
+### Find a game
+
+```python
+game = steam.library.game_by_id("440")       # by app ID
+game = steam.library.game_by_name("Portal 2") # by name (case-insensitive)
+```
+
+### Artwork paths
+
+```python
+game.header   # Path to header image    (460×215 jpg)
+game.grid     # Path to grid image      (600×900 jpg)
+game.hero     # Path to hero image
+game.icon     # Path to icon file, or None
+```
+
+### Launch and manage games via Steam URI commands
+
+```python
+from steam_client.commands import Commands, SteamWindows
+
+commands = Commands()
+commands.run_game_id("440")         # Launch a game
+commands.store("440")               # Open store page
+commands.install("440")             # Prompt install
+commands.uninstall("440")           # Prompt uninstall
+commands.open(SteamWindows.FRIENDS) # Open a Steam window
+commands.open_url("https://store.steampowered.com")
+```
+
+Or launch a game directly from a `SteamGame` object:
+
+```python
+game.run()
+```
+
+### Users and shortcuts
+
+```python
+for user in steam.users:
+    print(user.user.data.PersonaName)
+
+for shortcut in steam.library.shortcuts():
+    print(shortcut.appname)
+```
+
+### Steam Web API
+
+```python
+from steam_client.web_api import WebAPI
+
+api = WebAPI()
+apps = api.get_app_list()
+```
+
+---
+
+## Platform Notes
+
+| Platform | Default path                   | Registry helper         |
+|----------|--------------------------------|-------------------------|
+| Windows  | `C:\Program Files (x86)\Steam` | `steam_from_registry()` |
+| Linux    | `~/.local/share/steam`         | Not available           |
+
+Pass a custom path to override the default:
+
+```python
+steam = Steam("/custom/steam/path")
+```
+
+Requires read access to local Steam config files (`libraryfolders.vdf`, `shortcuts.vdf`, appmanifest files).
+
+---
+
+## Development
+
+```bash
+pytest          # Run tests
+flake8 steam_client  # Lint
+mypy steam_client    # Type check
+tox             # Run all environments (lint, type, py311–314)
+```

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/pyproject.toml

@@ -6,7 +6,7 @@ name = "steam-client"
 authors = [
     {name = "William McAllister", email = "dev.garulf@gmail.com"}
 ]
-version = "3.0.0-dev.0"
+version = "4.0.0"
 description = "Steam client library for Python"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -31,7 +31,7 @@ packages = ["steam_client"]
 "steam_client" = ["py.typed"]
 
 [tool.bumpversion]
-current_version = "3.0.0-dev.0"
+current_version = "4.0.0"
 search = "version = \"{current_version}\""
 replace = "version = \"{new_version}\""
 parse = """(?x)

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/app.py

@@ -1,20 +1,14 @@
 from __future__ import annotations
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import TYPE_CHECKING
-
 
 from .commands import Commands
 
-if TYPE_CHECKING:
-    from .steam import Steam
-
 
 class App(ABC):
     """Abstract base class for all Steam apps."""
 
-    def __init__(self, steam: Steam):
-        self._steam = steam
+    def __init__(self):
         self._commands = Commands()
 
     @property

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/commands.py

@@ -1,9 +1,6 @@
-from typing import List
 import webbrowser
 from enum import StrEnum
 
-SCHEME = 'steam'
-
 
 class SteamWindows(StrEnum):
     """Enumeration of Steam client windows."""
@@ -23,47 +20,44 @@ class SteamWindows(StrEnum):
 
 class Command():
 
-    def __init__(self, scheme: str):
-        self._scheme = scheme
-
-    def _create_uri(self, path: List[str], endpoint: str) -> str:
-        return f'{self._scheme}://{"/".join(path)}/{endpoint}'
+    def _create_uri(self, *segments: str) -> str:
+        return f'steam://{"/".join(segments)}'
 
-    def __call__(self, path: List[str], endpoint: str) -> None:
+    def open(self, *segments: str) -> None:
         """Executes the command with the specified endpoint."""
-        webbrowser.open(self._create_uri(path, endpoint))
+        webbrowser.open(self._create_uri(*segments))
 
 
 class Commands:
     """A collection of commands for the Steam client."""
 
     def __init__(self):
-        self._command = Command(SCHEME)
+        self._command = Command()
 
     def run_game_id(self, app_id: str) -> None:
         """Launches game with the specified ID in the Steam client."""
-        self._command(['rungameid'], app_id)
+        self._command.open('rungameid', app_id)
 
     def store(self, app_id: str) -> None:
         """Opens the game's store page in the Steam client."""
-        self._command(['store'], app_id)
+        self._command.open('store', app_id)
 
     def install(self, app_id: str) -> None:
         """Opens the game's install prompt in the Steam client."""
-        self._command(['install'], app_id)
+        self._command.open('install', app_id)
 
     def uninstall(self, app_id: str) -> None:
         """Opens the game's uninstall prompt in the Steam client."""
-        self._command(['uninstall'], app_id)
+        self._command.open('uninstall', app_id)
 
     def update_news(self, app_id: str) -> None:
         """Opens the game's update news in the Steam client."""
-        self._command(['updatenews'], app_id)
+        self._command.open('updatenews', app_id)
 
     def open(self, window: SteamWindows) -> None:
         """Opens the specified window in the Steam client."""
-        self._command(['open'], window)
+        self._command.open('open', window)
 
     def open_url(self, url: str) -> None:
         """Opens the specified URL in the Steam client."""
-        self._command(['openurl'], url)
+        self._command.open('openurl', url)

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/game.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 import functools
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 import vdf  # type: ignore
 
-if TYPE_CHECKING:
-    from .steam import Steam
-
 from .app import App
 
 
@@ -22,19 +18,20 @@ ASSETS = frozenset({
 })
 
 
-class SteamGame(App):
+class Game(App):
     """Represents a Steam game."""
 
-    def __init__(self, steam: Steam, library_path: str, appid: str):
+    def __init__(self, library_cache_path: Path, library_path: str, appid: str):
+        self._library_cache_path = Path(library_cache_path)
         self.library_path = library_path
         self._appid = appid
         self._icon: Path | None = None
         self._name: str | None = None
-        super().__init__(steam)
+        super().__init__()
 
     def __repr__(self) -> str:
         return (
-            f'Game(steam={self._steam.__repr__()}, '
+            f'Game(library_cache_path={self._library_cache_path.__repr__()}, '
             f'library_path={self.library_path.__repr__()}, '
             f'appid={self.appid.__repr__()})'
         )
@@ -42,7 +39,7 @@ class SteamGame(App):
     @property
     def asset_dir(self) -> Path:
         """Returns the path to the game's asset directory."""
-        return Path(self._steam.library_cache).joinpath(self.appid)
+        return self._library_cache_path.joinpath(self.appid)
 
     @property
     def icon(self) -> Path | None:
@@ -61,22 +58,22 @@ class SteamGame(App):
     @property
     def header(self) -> Path:
         """Returns the path to the header image."""
-        return Path(self._steam.library_cache).joinpath(f'{self.appid}_header.jpg')
+        return self._library_cache_path.joinpath(f'{self.appid}_header.jpg')
 
     @property
     def grid(self) -> Path:
         """Returns the path to the 600x900 grid image."""
-        return Path(self._steam.library_cache).joinpath(f'{self.appid}_library_600x900.jpg')
+        return self._library_cache_path.joinpath(f'{self.appid}_library_600x900.jpg')
 
     @property
     def hero(self) -> Path:
         """Returns the path to the hero image."""
-        return Path(self._steam.library_cache).joinpath(f'{self.appid}_library_hero.jpg')
+        return self._library_cache_path.joinpath(f'{self.appid}_library_hero.jpg')
 
     @property
     def hero_blur(self) -> Path:
         """Returns the path to the blurred hero image."""
-        return Path(self._steam.library_cache).joinpath(f'{self.appid}_library_hero_blur.jpg')
+        return self._library_cache_path.joinpath(f'{self.appid}_library_hero_blur.jpg')
 
     @property
     def manifest_path(self) -> Path:
@@ -115,6 +112,10 @@ class SteamGame(App):
         """Opens the game's store page in the Steam client."""
         self._commands.store(self.appid)
 
+    def install(self):
+        """Installs the game."""
+        self._commands.install(self.appid)
+
     def uninstall(self):
         """Uninstalls the game."""
         self._commands.uninstall(self.appid)

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/library.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import hashlib
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union, Generator
 
 import vdf  # type: ignore
 
@@ -8,8 +8,8 @@ from steam_client.shortcut import Shortcut
 
 if TYPE_CHECKING:
     from .steam import Steam
-from .library_directory import LibraryDirectory
-from .game import SteamGame
+from .library_folder import LibraryFolder
+from .game import Game
 
 
 class Library:
@@ -18,7 +18,7 @@ class Library:
     def __init__(self, steam: 'Steam'):
         self._steam = steam
         self._libraries_hash: Optional[str] = None
-        self._libraries: List[LibraryDirectory] = []
+        self._libraries: List[LibraryFolder] = []
 
     def _hash_steam_libraries(self) -> str:
         """Returns the MD5 hash of the Steam library folders file."""
@@ -35,44 +35,46 @@ class Library:
             libraries = vdf.load(f)
         # The is not always formatted the same way, so we grab the first key
         folder_key = list(libraries.keys())[0]
-        self._libraries = [LibraryDirectory(self._steam, libraries[folder_key][item]["path"],
-                                            libraries[folder_key][item]["apps"]) for item in libraries[folder_key]]
+        self._libraries = [LibraryFolder(self._steam.library_cache, libraries[folder_key][item]["path"],
+                                         libraries[folder_key][item]["apps"]) for item in libraries[folder_key]]
 
-    def libraries(self) -> List[LibraryDirectory]:
+    def libraries(self) -> Generator[LibraryFolder, None, None]:
         """Returns the Steam library folders."""
         if self._is_updated():
             self._libraries_hash = self._hash_steam_libraries()
             self._update_libraries()
-        return self._libraries
+        for library in self._libraries:
+            yield library
 
-    def games(self) -> List[SteamGame]:
+    def games(self) -> Generator[Game, None, None]:
         """Returns the games from the Steam library."""
-        games = []
         for library in self.libraries():
-            games.extend(library.get_games())
-        return games
+            for game in library.get_games():
+                yield game
 
-    def game_by_id(self, appid: str) -> Optional[SteamGame]:
+    def game_by_id(self, appid: str) -> Optional[Game]:
         """Returns the game with the specified ID."""
         for game in self.games():
             if game.appid == appid:
                 return game
         return None
 
-    def game_by_name(self, name: str) -> Optional[SteamGame]:
+    def game_by_name(self, name: str) -> Optional[Game]:
         """Returns the game with the specified name."""
         for game in self.games():
             if game.name.casefold() == name.casefold():
                 return game
         return None
 
-    def shortcuts(self) -> List[Shortcut]:
+    def shortcuts(self) -> Generator[Shortcut, None, None]:
         """Returns the Non-Steam shortcuts from the Steam library."""
-        shortcuts = []
         for user in self._steam.users:
-            shortcuts.extend(user.shortcuts())
-        return shortcuts
+            for shortcut in user.shortcuts():
+                yield shortcut
 
-    def all(self) -> List[Union[SteamGame, Shortcut]]:
+    def all(self) -> Generator[Union[Game, Shortcut], None, None]:
         """Returns all the games and shortcuts from the Steam library."""
-        return self.games() + self.shortcuts()
+        for game in self.games():
+            yield game
+        for shortcut in self.shortcuts():
+            yield shortcut

steam_client-4.0.0/steam_client/library_folder.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+
+from .game import Game
+
+
+@dataclass
+class LibraryFolder:
+    """Represents a Steam library folder."""
+    library_cache_path: Path
+    path: str
+    apps: List[str]
+
+    def get_games(self) -> List[Game]:
+        return [Game(self.library_cache_path, self.path, appid) for appid in self.apps]

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/login_users.py

@@ -2,13 +2,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 from typing import List, Optional
-from typing import TYPE_CHECKING
 
 import vdf  # type: ignore
 
-if TYPE_CHECKING:
-    from steam_client.steam import Steam
-
 from .shortcut import Shortcut
 
 STEAM64_OFFSET = 76561197960265728
@@ -35,8 +31,8 @@ class UserData:
 class LoginUser:
     """Represents a current or previous logged in Steam user."""
 
-    def __init__(self, steam: Steam, user: User):
-        self._steam = steam
+    def __init__(self, base_path: str, user: User):
+        self._base_path = Path(base_path)
         self.user = user
 
     @property
@@ -53,7 +49,7 @@ class LoginUser:
     @property
     def user_data_dir(self) -> Path:
         """Returns the path to the userdata folder."""
-        return Path(self._steam.base_path).joinpath('userdata', str(self.steam_id3))
+        return self._base_path.joinpath('userdata', str(self.steam_id3))
 
     @property
     def config(self) -> Path:
@@ -74,25 +70,28 @@ class LoginUser:
         """Returns the data from the shortcuts.vdf file."""
         with open(self.shortcuts_file, 'rb') as f:
             shortcuts = vdf.binary_load(f)
-        return [Shortcut(self._steam, self, shortcuts['shortcuts'][shortcut_idx]) for shortcut_idx in shortcuts['shortcuts']]
+        return [Shortcut(self, shortcuts['shortcuts'][shortcut_idx]) for shortcut_idx in shortcuts['shortcuts']]
 
 
 class LoginUsers:
     """Represents the loginusers.vdf file."""
 
-    def __init__(self, steam: Steam):
-        self._steam = steam
+    def __init__(self, base_path: str):
+        self._base_path = Path(base_path)
 
     @property
     def _path(self) -> Path:
         """Returns the path to the loginusers.vdf file."""
-        return Path(self._steam.base_path).joinpath('config', 'loginusers.vdf')
+        return self._base_path.joinpath('config', 'loginusers.vdf')
 
     def users(self) -> List[LoginUser]:
         """Returns the users from the loginusers.vdf file."""
         with open(self._path, 'r', encoding='utf-8', errors='ignore') as f:
             login_users = vdf.load(f)
-        return [LoginUser(self._steam, User(int(user_id), user_data)) for user_id, user_data in login_users['users'].items()]
+        return [
+            LoginUser(str(self._base_path), User(int(user_id), user_data))
+            for user_id, user_data in login_users['users'].items()
+        ]
 
     def most_recent_user(self) -> Optional[LoginUser]:
         """Returns the most recent user from the loginusers.vdf file."""

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/shortcut.py

@@ -6,7 +6,6 @@ from typing import TypedDict
 import pycrc.algorithms as crc  # type: ignore
 
 if TYPE_CHECKING:
-    from .steam import Steam
     from .login_users import LoginUser
 
 from .app import App
@@ -25,13 +24,13 @@ class ShortcutEntry(TypedDict):
 class Shortcut(App):
     """Represents a Non-Steam Game shortcut."""
 
-    def __init__(self, steam: Steam, user: LoginUser, data: ShortcutEntry):
+    def __init__(self, user: LoginUser, data: ShortcutEntry):
         self._data = data
         self._user = user
-        super().__init__(steam)
+        super().__init__()
 
     def __repr__(self) -> str:
-        return f'Shortcut(steam={self._steam.__repr__()}, data={self._data.__repr__()})'
+        return f'Shortcut(data={self._data.__repr__()})'
 
     @property
     def name(self) -> str:

{steam_client-3.0.0.dev0 → steam_client-4.0.0}/steam_client/steam.py

@@ -39,7 +39,7 @@ class Steam:
 
     @property
     def users(self):
-        return LoginUsers(self).users()
+        return LoginUsers(self.base_path).users()
 
     @property
     def library(self) -> Library: