steam-client 0.0.1.dev1__py3-none-any.whl

steam_client/app.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+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
+
+    @property
+    @abstractmethod
+    def appid(self) -> str:
+        """Returns the game's appid."""
+        pass
+
+    @property
+    @abstractmethod
+    def icon(self) -> Path:
+        """Returns the path to the icon image."""
+        pass
+
+    @property
+    @abstractmethod
+    def header(self) -> Path:
+        pass
+
+    @property
+    @abstractmethod
+    def grid(self) -> Path:
+        pass
+
+    @property
+    @abstractmethod
+    def hero(self) -> Path:
+        pass
+
+    def run(self):
+        """Launches app with the specified app ID in the Steam client."""
+        self._steam.commands.run_game_id(self.appid)

steam_client/commands.py

@@ -0,0 +1,49 @@
+from typing import Literal
+import os
+
+
+SteamWindow = Literal[
+    'main',
+    'games',
+    'games/details',
+    'games/grid',
+    'games/list',
+    'friends',
+    'chat',
+    'bigpicture',
+    'news',
+    'settings',
+    'tools',
+    'console'
+]
+
+
+class Commands:
+
+    def run_game_id(self, app_id: str) -> None:
+        """Launches game with the specified ID in the Steam client."""
+        os.startfile(f'steam://rungameid/{app_id}')
+
+    def store(self, app_id: str) -> None:
+        """Opens the game's store page in the Steam client."""
+        os.startfile(f'steam://store/{app_id}')
+
+    def install(self, app_id: str) -> None:
+        """Opens the game's install prompt in the Steam client."""
+        os.startfile(f'steam://install/{app_id}')
+
+    def uninstall(self, app_id: str) -> None:
+        """Opens the game's uninstall prompt in the Steam client."""
+        os.startfile(f'steam://uninstall/{app_id}')
+
+    def update_news(self, app_id: str) -> None:
+        """Opens the game's update news in the Steam client."""
+        os.startfile(f'steam://updatenews/{app_id}')
+
+    def open(self, window: SteamWindow) -> None:
+        """Opens the specified window in the Steam client."""
+        os.startfile(f'steam://open/{window}')
+
+    def open_url(self, url: str) -> None:
+        """Opens the specified URL in the Steam client."""
+        os.startfile(f'steam://openurl/{url}')

steam_client/game.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+import functools
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import vdf
+
+if TYPE_CHECKING:
+    from .steam import Steam
+
+from .app import App
+
+
+UNKNOWN_GAME_NAME = 'UNKNOWN'
+
+
+class SteamGame(App):
+    """Represents a Steam game."""
+
+    def __init__(self, steam: Steam, library_path: str, appid: str):
+        self.library_path = library_path
+        self._appid = appid
+        super().__init__(steam)
+
+    def __repr__(self) -> str:
+        return f'Game(steam={self._steam.__repr__()}, library_path={self.library_path.__repr__()}, appid={self.appid.__repr__()})'
+
+    @property
+    def icon(self) -> Path:
+        """Returns the path to the icon image."""
+        return Path(self._steam.library_cache).joinpath(f'{self.appid}_icon.jpg')
+
+    @property
+    def header(self) -> Path:
+        """Returns the path to the header image."""
+        return Path(self._steam.library_cache).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')
+
+    @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')
+
+    @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')
+
+    @property
+    def manifest_path(self) -> Path:
+        """Returns the path to the game's appmanifest."""
+        return Path(self.library_path).joinpath('steamapps', f'appmanifest_{self.appid}.acf')
+
+    @functools.cached_property
+    def _manifest(self) -> dict:
+        """Returns the data from the game's appmanifest."""
+        try:
+            with open(self.manifest_path, 'r', encoding='utf-8', errors='ignore') as f:
+                manifest = vdf.load(f)
+            return manifest
+        except FileNotFoundError:
+            return {}
+
+    @functools.cached_property
+    def name(self) -> str:
+        """Returns the name of the game."""
+        try:
+            return self._manifest['AppState']['name']
+        except KeyError:
+            return UNKNOWN_GAME_NAME
+
+    @property
+    def appid(self) -> str:
+        """Returns the app ID."""
+        return self._appid
+
+    def open_store_page(self):
+        """Opens the game's store page in the Steam client."""
+        self._steam.commands.store(self.appid)
+
+    def uninstall(self):
+        """Uninstalls the game."""
+        self._steam.commands.uninstall(self.appid)

steam_client/library.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from pathlib import Path
+import hashlib
+from typing import TYPE_CHECKING, List, Optional, Union
+
+import vdf
+
+from steam_client.shortcut import Shortcut
+
+if TYPE_CHECKING:
+    from .steam import Steam
+from .library_directory import LibraryDirectory
+from .game import SteamGame
+
+
+class Library:
+    """Represents the Steam library."""
+
+    def __init__(self, steam: 'Steam'):
+        self._steam = steam
+        self._libraries_hash: Optional[str] = None
+        self._libraries: List[LibraryDirectory] = []
+
+    def _hash_steam_libraries(self) -> str:
+        """Returns the MD5 hash of the Steam library folders file."""
+        with open(str(self._steam.library_folders), 'rb') as f:
+            return hashlib.md5(f.read()).hexdigest()
+
+    def _is_updated(self) -> bool:
+        """Returns whether the Steam library folders have been updated."""
+        return self._libraries_hash != self._hash_steam_libraries()
+
+    def _update_libraries(self):
+        """Updates the Steam library folders."""
+        with open(self._steam.library_folders, 'r', encoding='utf-8', errors='ignore') as f:
+            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]]
+
+    def libraries(self) -> List[LibraryDirectory]:
+        """Returns the Steam library folders."""
+        if self._is_updated():
+            self._libraries_hash = self._hash_steam_libraries()
+            self._update_libraries()
+        return self._libraries
+
+    def games(self) -> List[SteamGame]:
+        """Returns the games from the Steam library."""
+        games = []
+        for library in self.libraries():
+            games.extend(library.get_games())
+        return games
+
+    def game_by_id(self, appid: str) -> Optional[SteamGame]:
+        """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]:
+        """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]:
+        """Returns the Non-Steam shortcuts from the Steam library."""
+        shortcuts = []
+        for user in self._steam.login_users.users():
+            shortcuts.extend(user.shortcuts())
+        return shortcuts
+
+    def all(self) -> List[Union[SteamGame, Shortcut]]:
+        """Returns all the games and shortcuts from the Steam library."""
+        return self.games() + self.shortcuts()

steam_client/library_directory.py

@@ -0,0 +1,21 @@
+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
+from .game import SteamGame
+
+
+@dataclass
+class LibraryDirectory:
+    """Represents a Steam library folder."""
+    _steam: Steam
+    path: str
+    apps: List[str]
+
+    def get_games(self) -> List[SteamGame]:
+        return [SteamGame(self._steam, self.path, appid) for appid in self.apps]

steam_client/login_users.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+from typing import TYPE_CHECKING
+from typing import TypedDict
+
+import vdf
+
+if TYPE_CHECKING:
+    from steam_client.steam import Steam
+
+from .shortcut import Shortcut
+
+STEAM64_OFFSET = 76561197960265728
+
+
+class UserData(TypedDict):
+    AccountName: str
+    PersonaName: str
+    RememberPassword: str
+    WantsOfflineMode: str
+    SkipOfflineModeWarning: str
+    AllowAutoLogin: str
+    MostRecent: str
+    Timestamp: str
+
+
+UserLoginsFile = Dict[str, Dict[str, UserData]]
+
+
+class User:
+    """Represents a current or previous logged in Steam user."""
+
+    def __init__(self, steam: Steam, steam_id64: str, user_data: UserData):
+        self._steam = steam
+        self.steam_id64 = steam_id64
+        self._user_data = user_data
+
+    def __repr__(self) -> str:
+        return f'User(steam={self._steam.__repr__()}, steam_id64={self.steam_id64.__repr__()}, user_data={self._user_data.__repr__()})'
+
+    @property
+    def is_most_recent(self) -> bool:
+        """Returns whether the user is the most recent user."""
+        return self._user_data['MostRecent'] == '1'
+
+    @property
+    def steam_id3(self) -> int:
+        """Returns the last portion of the user's SteamID3."""
+        steamidacct = (int(self.steam_id64) - STEAM64_OFFSET)
+        return steamidacct
+
+    @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))
+
+    @property
+    def config(self) -> Path:
+        """Returns the path to the config folder."""
+        return Path(self.user_data_dir).joinpath('config')
+
+    @property
+    def shortcuts_file(self) -> Path:
+        """Returns the path to the shortcuts.vdf file."""
+        return Path(self.config).joinpath('shortcuts.vdf')
+
+    @property
+    def grid_path(self) -> Path:
+        """Returns the path to the user's shortcut grid images."""
+        return Path(self.user_data_dir).joinpath('config', 'grid')
+
+    def shortcuts(self) -> List[Shortcut]:
+        """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']]
+
+
+class LoginUsers:
+    """Represents the loginusers.vdf file."""
+
+    def __init__(self, steam: Steam):
+        self._steam = steam
+
+    @property
+    def _path(self) -> Path:
+        """Returns the path to the loginusers.vdf file."""
+        return Path(self._steam.base_path).joinpath('config', 'loginusers.vdf')
+
+    def users(self) -> List[User]:
+        """Returns the users from the loginusers.vdf file."""
+        with open(self._path, 'r', encoding='utf-8', errors='ignore') as f:
+            login_users: UserLoginsFile = vdf.load(f)
+        return [User(self._steam, steam_id64, user_data) for steam_id64, user_data in login_users['users'].items()]
+
+    def most_recent_user(self) -> Optional[User]:
+        """Returns the most recent user from the loginusers.vdf file."""
+        return next((user for user in self.users() if user.is_most_recent), None)

steam_client/shortcut.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict
+from typing import TypedDict
+
+import pycrc.algorithms as crc
+
+if TYPE_CHECKING:
+    from .steam import Steam
+    from .login_users import User
+
+from .app import App
+
+
+class ShortcutEntry(TypedDict):
+    appid: int
+    appname: str
+    exe: str
+    StartDir: str
+    LaunchOptions: str
+    icon: str
+    tags: Dict[str, str]
+
+
+class Shortcut(App):
+    """Represents a Non-Steam Game shortcut."""
+
+    def __init__(self, steam: Steam, user: User, data: ShortcutEntry):
+        self._data = data
+        self._user = user
+        super().__init__(steam)
+
+    def __repr__(self) -> str:
+        return f'Shortcut(steam={self._steam.__repr__()}, data={self._data.__repr__()})'
+
+    @property
+    def name(self) -> str:
+        return self._data["appname"]
+
+    @property
+    def appid(self) -> str:
+        algorithm = crc.Crc(width=32, poly=0x04C11DB7, reflect_in=True,
+                            xor_in=0xffffffff, reflect_out=True, xor_out=0xffffffff)
+        input_string = ''.join([self._data["exe"], self._data["appname"]])
+        top_32 = algorithm.bit_by_bit(input_string) | 0x80000000
+        full_64 = (top_32 << 32) | 0x02000000
+        return str(full_64)
+
+    def _short_id(self) -> str:
+        """
+        Return Steam shortened App ID.
+        This is primarily used for shortcuts in the grid.
+        """
+        return str(int(self.appid) >> int(32))
+
+    @property
+    def icon(self) -> str:
+        return self._data["icon"] or str(self._user.grid_path.joinpath(f"{self._short_id()}_icon.png"))
+
+    @property
+    def header(self) -> str:
+        return str(self._user.grid_path.joinpath(f"{self._short_id()}.png"))
+
+    @property
+    def grid(self) -> str:
+        return str(self._user.grid_path.joinpath(f"{self._short_id()}p.png"))
+
+    @property
+    def hero(self) -> str:
+        return str(self._user.grid_path.joinpath(f"{self._short_id()}_hero.png"))

steam_client/steam.py

@@ -0,0 +1,41 @@
+import functools
+from pathlib import Path
+
+from .library import Library
+from .commands import Commands
+from .login_users import LoginUsers
+
+DEFAULT_WIN_STEAM_PATH = r"c:\Program Files (x86)\Steam"
+
+
+class Steam:
+    """Represents the Steam client."""
+
+    def __init__(self, base_path: str = DEFAULT_WIN_STEAM_PATH):
+        self.base_path: str = base_path
+        self.login_users = LoginUsers(self)
+        self.commands = Commands()
+        self.library = Library(self)
+
+    def __repr__(self) -> str:
+        return f'Steam(base_path={self.base_path.__repr__()})'
+
+    @property
+    def app_cache(self) -> Path:
+        """Returns the path to the appcache folder."""
+        return Path(self.base_path).joinpath('appcache')
+
+    @property
+    def user_data(self) -> Path:
+        """Returns the path to the userdata folder."""
+        return Path(self.base_path).joinpath('userdata')
+
+    @property
+    def library_folders(self) -> Path:
+        """Returns the path to the libraryfolders.vdf file."""
+        return Path(self.base_path).joinpath('config', 'libraryfolders.vdf')
+
+    @property
+    def library_cache(self) -> Path:
+        """Returns the path to the librarycache folder."""
+        return Path(self.base_path).joinpath('appcache', 'librarycache')

steam_client/utils.py

@@ -0,0 +1,13 @@
+import winreg as reg
+from winreg import HKEY_LOCAL_MACHINE
+
+from .steam import Steam
+
+
+STEAM_SUB_KEY = r'SOFTWARE\WOW6432Node\Valve\Steam'
+
+
+def steam_from_registry() -> Steam:
+    """Returns a Steam instance from the Windows registry."""
+    with reg.OpenKey(HKEY_LOCAL_MACHINE, STEAM_SUB_KEY) as hkey:
+        return Steam(reg.QueryValueEx(hkey, "InstallPath")[0])

steam_client/web_api.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict
+
+import requests  # type: ignore
+
+
+BASE_URL = "https://api.steampowered.com"
+
+
+class WebAPI:
+
+    def __init__(self):
+        self._session = requests.Session()
+
+    def _request(self, method: str, endpoint: str, base_url: str = BASE_URL, **kwargs) -> requests.Response:
+        """Makes a request to the Steam API."""
+        url = f'{base_url}/{endpoint}'
+        r = self._session.request(method, url, **kwargs)
+        r.raise_for_status()
+        return r
+
+    def get_app_list(self) -> Dict[Any, Any]:
+        """Returns a list of all Steam apps."""
+        r = self._request('GET', 'ISteamApps/GetAppList/v2')
+        return r.json()

steam_client-0.0.1.dev1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Garulf
+
+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.

steam_client-0.0.1.dev1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: steam-client
+Version: 0.0.1.dev1
+Summary: Steam client library for Python
+Author-email: William McAllister <dev.garulf@gmail.com>
+License: MIT
+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
+

steam_client-0.0.1.dev1.dist-info/RECORD

@@ -0,0 +1,16 @@
+steam_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+steam_client/app.py,sha256=A93hYLT_sEKpfmScGBliL6tD7REpbEYPeMf61RC7xzM,931
+steam_client/commands.py,sha256=nYYInY3Nxpyc7DGQ1WKDmxRYsWmsODC-pYDOArPski8,1394
+steam_client/game.py,sha256=nww5sGmHJRimCnqZwIcrw-ToU2mB9d5gFTtTEj-htag,2694
+steam_client/library.py,sha256=ruRNC5b-p_H7fEiyZ58O24fOWCHKVl3RAWOQROXO-dY,2916
+steam_client/library_directory.py,sha256=p06iBw9xsuZjCJUTPWmUXhGhDqkx4hUchNGLxU1j5aY,481
+steam_client/login_users.py,sha256=yYbQETSI1gZnwJqJcu5TeREyXY2UKwKiWnNVkajiejw,3288
+steam_client/shortcut.py,sha256=Q07i31KB6u-FSAs0LXxDPnEfHWZUUKEei6Vnsyq3jvU,1976
+steam_client/steam.py,sha256=bXdosPBGpj2ZiIsIk8y142fumh-0LvSnnxBwRbsN0GE,1266
+steam_client/utils.py,sha256=nvRlaYsiUH2VXGXgE-bEvEHWLg7XC2Xopr7KFBYWy4A,367
+steam_client/web_api.py,sha256=7RcVyNGkNqVw5j2Yzu4lO5Pctrd8W00Di_j_h-T4T-k,670
+steam_client-0.0.1.dev1.dist-info/LICENSE,sha256=qIIHsmhBULNOOo_bvd1fFU-vVUDwJ-Dxg0Kl_kwtWnM,1063
+steam_client-0.0.1.dev1.dist-info/METADATA,sha256=De69RGZMH2cYDa_oxCETb98-iupLkCGYGQ8CyWKj88Q,412
+steam_client-0.0.1.dev1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+steam_client-0.0.1.dev1.dist-info/top_level.txt,sha256=nyNYK9O4l8s61ogUSz422nEbSumzgI8D_KbXfXGBMgk,13
+steam_client-0.0.1.dev1.dist-info/RECORD,,

steam_client-0.0.1.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

steam_client-0.0.1.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+steam_client