From 3aec9020dd253d4d3c6cc4c41bb628690cf6fe1f Mon Sep 17 00:00:00 2001 From: Rossen Georgiev Date: Tue, 8 Nov 2016 15:20:03 +0200 Subject: [PATCH] added Apps builtin cotains various methods related to apps --- docs/api/steam.client.builtins.rst | 8 ++ steam/client/builtins/__init__.py | 3 +- steam/client/builtins/apps.py | 182 +++++++++++++++++++++++++++++ 3 files changed, 192 insertions(+), 1 deletion(-) create mode 100644 steam/client/builtins/apps.py diff --git a/docs/api/steam.client.builtins.rst b/docs/api/steam.client.builtins.rst index fded53e..7f52493 100644 --- a/docs/api/steam.client.builtins.rst +++ b/docs/api/steam.client.builtins.rst @@ -3,6 +3,14 @@ builtins .. automodule:: steam.client.builtins +Apps +---- + +.. automodule:: steam.client.builtins.apps + :members: + :undoc-members: + :show-inheritance: + User ---- diff --git a/steam/client/builtins/__init__.py b/steam/client/builtins/__init__.py index b2a79ea..c9f3d55 100644 --- a/steam/client/builtins/__init__.py +++ b/steam/client/builtins/__init__.py @@ -7,8 +7,9 @@ from steam.client.builtins.unified_messages import UnifiedMessages from steam.client.builtins.leaderboards import Leaderboards from steam.client.builtins.gameservers import GameServers from steam.client.builtins.friends import Friends +from steam.client.builtins.apps import Apps -class BuiltinBase(User, Web, UnifiedMessages, Leaderboards, GameServers, Friends): +class BuiltinBase(User, Web, UnifiedMessages, Leaderboards, GameServers, Friends, Apps): """ This object is used as base to implement all high level functionality. The features are separated into submodules. diff --git a/steam/client/builtins/apps.py b/steam/client/builtins/apps.py new file mode 100644 index 0000000..4cb12ad --- /dev/null +++ b/steam/client/builtins/apps.py @@ -0,0 +1,182 @@ +import vdf +from steam.enums import EResult +from steam.enums.emsg import EMsg +from steam.core.msg import MsgProto + + +class Apps(object): + def __init__(self, *args, **kwargs): + super(Apps, self).__init__(*args, **kwargs) + + def get_player_count(self, app_id): + """Get numbers of players for app id + + :param app_id: app id + :type app_id: :class:`int` + :return: number of players + :rtype: :class:`int`, :class:`None` + """ + resp = self.send_job_and_wait(MsgProto(EMsgClientGetNumberOfCurrentPlayersDP), + {'appid': appid}, + timeout=15 + ) + return resp.player_count if resp and resp.eresult == EResult.OK else None + + def get_product_info(self, apps=[], packages=[]): + """Get product info for apps and packages + + :param apps: items in the list should be either just ``app_id``, or ``(app_id, access_token)`` + :type apps: :class:`list` + :param packages: items in the list should be either just ``package_id``, or ``(package_id, access_token)`` + :type packages: :class:`list` + :return: dict with ``apps`` and ``packages`` containing their info, see example below + :rtype: :class:`dict`, :class:`None` + + .. code:: python + + {'apps': {570: {...}, ...}, + 'packages': {123: {...}, ...} + } + """ + if not apps and not packages: return + + message = MsgProto(EMsg.ClientPICSProductInfoRequest) + + for app in apps: + app_info = message.body.apps.add() + app_info.only_public = False + if isinstance(app, tuple): + app_info.appid, app_info.access_token = app + else: + app_info.appid = app + + for package in packages: + package_info = message.body.packages.add() + if isinstance(package, tuple): + package_info.appid, package_info.access_token = package + else: + package_info.packageid = package + + message.body.meta_data_only = False + + job_id = self.send_job(message) + + data = dict(apps={}, packages={}) + + while True: + chunk = self.wait_event(job_id, timeout=15) + + if chunk is None: return + chunk = chunk[0].body + + for app in chunk.apps: + data['apps'][app.appid] = vdf.loads(app.buffer[:-1])['appinfo'] + for pkg in chunk.packages: + data['packages'][pkg.packageid] = vdf.binary_loads(pkg.buffer[4:])[str(pkg.packageid)] + + if not chunk.response_pending: + break + + return data + + def get_changes_since(self, change_number, app_changes=True, package_changes=False): + """Get changes since a change number + + :param change_number: change number to use as stating point + :type change_number: :class:`int` + :param app_changes: whether to inclued app changes + :type app_changes: :class:`bool` + :param package_changes: whether to inclued package changes + :type package_changes: :class:`bool` + :return: `CMsgClientPICSChangesSinceResponse `_ + :rtype: proto message instance, or :class:`None` on timeout + """ + return self.send_job_and_wait(MsgProto(EMsg.ClientPICSChangesSinceRequest), + { + 'since_change_number': change_number, + 'send_app_info_changes': app_changes, + 'send_package_info_changes': package_changes, + }, + timeout=15 + ) + + def get_app_ticket(self, app_id): + """Get app ownership ticket + + :param app_id: app id + :type app_id: :class:`int` + :return: `CMsgClientGetAppOwnershipTicketResponse `_ + :rtype: proto message + """ + return self.send_job_and_wait(MsgProto(EMsg.ClientGetAppOwnershipTicket), + {'app_id': app_id}, + timeout=15 + ) + + def get_depot_key(self, depot_id, app_id=0): + """Get depot decryption key + + :param depot_id: depot id + :type depot_id: :class:`int` + :param app_id: app id + :type app_id: :class:`int` + :return: `CMsgClientGetDepotDecryptionKeyResponse `_ + :rtype: proto message + """ + return self.send_job_and_wait(MsgProto(EMsg.ClientGetDepotDecryptionKey), + { + 'depot_id': depot_id, + 'app_id': app_id, + }, + timeout=15 + ) + + def get_cdn_auth_token(self, app_id, hostname): + """Get CDN authentication token + + :param app_id: app id + :type app_id: :class:`int` + :param hostname: cdn hostname + :type hostname: :class:`str` + :return: `CMsgClientGetCDNAuthTokenResponse `_ + :rtype: proto message + """ + return self.send_job_and_wait(MsgProto(EMsg.ClientGetCDNAuthToken), + { + 'app_id': app_id, + 'host_name': hostname, + }, + timeout=15 + ) + + def get_product_access_tokens(self, app_ids=[], package_ids=[]): + """Get access tokens + + :param app_ids: list of app ids + :type app_ids: :class:`list` + :param package_ids: list of package ids + :type package_ids: :class:`list` + :return: dict with ``apps`` and ``packages`` containing their access tokens, see example below + :rtype: :class:`dict`, :class:`None` + + .. code:: python + + {'apps': {123: 'token', ...}, + 'packages': {456: 'token', ...} + } + """ + if not app_ids and not package_ids: return + + resp = self.send_job_and_wait(MsgProto(EMsg.ClientPICSAccessTokenRequest), + { + 'appids': map(int, app_ids), + 'packageids': map(int, package_ids), + }, + timeout=15 + ) + + if resp: + return {'apps': dict(map(lambda app: (app.appid, app.access_token), resp.app_access_tokens)), + 'packages': dict(map(lambda pkg: (pkg.appid, pkg.access_token), resp.package_access_tokens)), + } +