Rossen Georgiev
9 years ago
5 changed files with 334 additions and 296 deletions
@ -0,0 +1,170 @@ |
|||
""" |
|||
Reading the leaderboards with :class:`SteamLeaderboard` is as easy as iterating over a list. |
|||
""" |
|||
import logging |
|||
from steam.core.msg import MsgProto |
|||
from steam.enums import EResult, ELeaderboardDataRequest, ELeaderboardSortMethod, ELeaderboardDisplayType |
|||
from steam.enums.emsg import EMsg |
|||
from steam.util import _range, chunks |
|||
from steam.util.throttle import ConstantRateLimit |
|||
|
|||
|
|||
class Leaderboards(object): |
|||
def __init__(self, *args, **kwargs): |
|||
super(Leaderboards, self).__init__(*args, **kwargs) |
|||
|
|||
def get_leaderboard(self, app_id, name): |
|||
""".. versionadded:: 0.8.2 |
|||
|
|||
Find a leaderboard |
|||
|
|||
:param app_id: application id |
|||
:type app_id: :class:`int` |
|||
:param name: leaderboard name |
|||
:type name: :class:`str` |
|||
:return: leaderboard instance |
|||
:rtype: :class:`SteamLeaderboard` |
|||
:raises: :class:`LookupError` on message timeout or error |
|||
""" |
|||
message = MsgProto(EMsg.ClientLBSFindOrCreateLB) |
|||
message.header.routing_appid = app_id |
|||
message.body.app_id = app_id |
|||
message.body.leaderboard_name = name |
|||
message.body.create_if_not_found = False |
|||
|
|||
resp = self.send_job_and_wait(message, timeout=15) |
|||
|
|||
if not resp: |
|||
raise LookupError("Didn't receive response within 15seconds :(") |
|||
if resp.eresult != EResult.OK: |
|||
raise LookupError(EResult(resp.eresult)) |
|||
|
|||
return SteamLeaderboard(self, app_id, name, resp) |
|||
|
|||
|
|||
class SteamLeaderboard(object): |
|||
""".. versionadded:: 0.8.2 |
|||
|
|||
Steam leaderboard object. |
|||
Generated via :meth:`Misc.get_leaderboard()` |
|||
Works more or less like a :class:`list` to access entries. |
|||
|
|||
.. note:: |
|||
Each slice will produce a message to steam. |
|||
Steam and protobufs might not like large slices. |
|||
Avoid accessing individual entries by index and instead use iteration or well sized slices. |
|||
|
|||
Example usage: |
|||
|
|||
.. code:: python |
|||
|
|||
lb = client.get_leaderboard(...) |
|||
|
|||
for entry in lb[:100]: # top 100 |
|||
print entry |
|||
""" |
|||
app_id = 0 |
|||
name = '' #: leaderboard name |
|||
id = 0 #: leaderboard id |
|||
entry_count = 0 |
|||
sort_method = ELeaderboardSortMethod.NONE #: :class:`steam.enums.common.ELeaderboardSortMethod` |
|||
display_type = ELeaderboardDisplayType.NONE #: :class:`steam.enums.common.ELeaderboardDisplayType` |
|||
data_request = ELeaderboardDataRequest.Global #: :class:`steam.enums.common.ELeaderboardDataRequest` |
|||
|
|||
def __init__(self, steam, app_id, name, data): |
|||
self._steam = steam |
|||
self.app_id = app_id |
|||
|
|||
for field in data.DESCRIPTOR.fields: |
|||
if field.name.startswith('leaderboard_'): |
|||
self.__dict__[field.name.replace('leaderboard_', '')] = getattr(data, field.name) |
|||
|
|||
self.sort_method = ELeaderboardSortMethod(self.sort_method) |
|||
self.display_type = ELeaderboardDisplayType(self.display_type) |
|||
|
|||
def __repr__(self): |
|||
return "<%s(%d, %s, %d, %s, %s)>" % ( |
|||
self.__class__.__name__, |
|||
self.app_id, |
|||
repr(self.name), |
|||
len(self), |
|||
self.sort_method, |
|||
self.display_type, |
|||
) |
|||
|
|||
def __len__(self): |
|||
return self.entry_count |
|||
|
|||
def get_entries(self, start=0, end=0, data_request=ELeaderboardDataRequest.Global): |
|||
"""Get leaderboard entries. |
|||
|
|||
:param start: start entry, not index (e.g. rank 1 is `start=1`) |
|||
:type start: :class:`int` |
|||
:param end: end entry, not index (e.g. only one entry then `start=1,end=1`) |
|||
:type end: :class:`int` |
|||
:param data_request: data being requested |
|||
:type data_request: :class:`steam.enums.common.ELeaderboardDataRequest` |
|||
:return: a list of entries, see `CMsgClientLBSGetLBEntriesResponse` |
|||
:rtype: :class:`list` |
|||
:raises: :class:`LookupError` on message timeout or error |
|||
""" |
|||
message = MsgProto(EMsg.ClientLBSGetLBEntries) |
|||
message.body.app_id = self.app_id |
|||
message.body.leaderboard_id = self.id |
|||
message.body.range_start = start |
|||
message.body.range_end = end |
|||
message.body.leaderboard_data_request = data_request |
|||
|
|||
resp = self._steam.send_job_and_wait(message, timeout=15) |
|||
|
|||
if not resp: |
|||
raise LookupError("Didn't receive response within 15seconds :(") |
|||
if resp.eresult != EResult.OK: |
|||
raise LookupError(EResult(resp.eresult)) |
|||
|
|||
return resp.entries |
|||
|
|||
def __getitem__(self, x): |
|||
if isinstance(x, slice): |
|||
stop_max = len(self) |
|||
start = 0 if x.start is None else x.start if x.start >= 0 else max(0, x.start + stop_max) |
|||
stop = stop_max if x.stop is None else x.stop if x.stop >= 0 else max(0, x.stop + stop_max) |
|||
step = x.step or 1 |
|||
if step < 0: |
|||
start, stop = stop, start |
|||
step = abs(step) |
|||
else: |
|||
start, stop, step = x, x + 1, 1 |
|||
|
|||
if start >= stop: return [] |
|||
|
|||
entries = self.get_entries(start+1, stop, self.data_request) |
|||
|
|||
return [entries[i] for i in _range(0, len(entries), step)] |
|||
|
|||
def get_iter(self, times, seconds, chunk_size=2000): |
|||
"""Make a iterator over the entries |
|||
|
|||
See :class:`steam.util.throttle.ConstantRateLimit` for ``times`` and ``seconds`` parameters. |
|||
|
|||
:param chunk_size: number of entries per request |
|||
:type chunk_size: :class:`int` |
|||
:returns: generator object |
|||
:rtype: :class:`generator` |
|||
|
|||
The iterator essentially buffers ``chuck_size`` number of entries, and ensures |
|||
we are not sending messages too fast. |
|||
For example, the ``__iter__`` method on this class uses ``get_iter(1, 1, 2000)`` |
|||
""" |
|||
def entry_generator(): |
|||
with ConstantRateLimit(times, seconds, use_gevent=True) as r: |
|||
for entries in chunks(self, chunk_size): |
|||
if not entries: |
|||
raise StopIteration |
|||
for entry in entries: |
|||
yield entry |
|||
r.wait() |
|||
return entry_generator() |
|||
|
|||
def __iter__(self): |
|||
return self.get_iter(1, 1, 2000) |
|||
@ -0,0 +1,145 @@ |
|||
""" |
|||
:class:`SteamUnifiedMessages` provides a simply API to send and receive unified messages. |
|||
|
|||
Example code: |
|||
|
|||
.. code:: python |
|||
|
|||
# the easy way |
|||
response = client.unified_messages.send_and_wait('Player.GetGameBadgeLevels#1', { |
|||
'property': 1, |
|||
'something': 'value', |
|||
}) |
|||
|
|||
# the other way |
|||
jobid = client.unified_message.send('Player.GetGameBadgeLevels#1', {'something': 1}) |
|||
response, = client.unified_message.wait_event(jobid) |
|||
|
|||
# i know what im doing, alright? |
|||
message = client.unified_message.get('Player.GetGameBadgeLevels#1') |
|||
message.something = 1 |
|||
response = client.unified_message.send_and_wait(message) |
|||
""" |
|||
import logging |
|||
from eventemitter import EventEmitter |
|||
from steam.core.msg import MsgProto, get_um |
|||
from steam.enums import EResult |
|||
from steam.enums.emsg import EMsg |
|||
from steam.util import WeakRefKeyDict, proto_fill_from_dict |
|||
|
|||
|
|||
class UnifiedMessages(object): |
|||
def __init__(self, *args, **kwargs): |
|||
super(UnifiedMessages, self).__init__(*args, **kwargs) |
|||
|
|||
name = "%s.unified_messages" % self.__class__.__name__ |
|||
self.unified_messages = SteamUnifiedMessages(self, name) #: instance of :class:`SteamUnifiedMessages` |
|||
|
|||
|
|||
class SteamUnifiedMessages(EventEmitter): |
|||
"""Simple API for send/recv of unified messages |
|||
|
|||
Incoming messages are emitted as events once with their ``jobid`` |
|||
and once with their method name (e.g. ``Player.GetGameBadgeLevels#1``) |
|||
""" |
|||
def __init__(self, steam, logger_name=None): |
|||
self._LOG = logging.getLogger(logger_name if logger_name else self.__class__.__name__) |
|||
self._steam = steam |
|||
self._data = WeakRefKeyDict() |
|||
|
|||
steam.on(EMsg.ServiceMethod, self._handle_service_method) |
|||
steam.on(EMsg.ClientServiceMethodResponse, self._handle_client_service_method) |
|||
|
|||
def emit(self, event, *args): |
|||
if event is not None: |
|||
self._LOG.debug("Emit event: %s" % repr(event)) |
|||
EventEmitter.emit(self, event, *args) |
|||
|
|||
def _handle_service_method(self, message): |
|||
self.emit(message.header.target_job_name, message.body) |
|||
|
|||
def _handle_client_service_method(self, message): |
|||
method_name = message.body.method_name |
|||
proto = get_um(method_name, response=True) |
|||
|
|||
if proto is None: |
|||
self._LOG("Unable to find proto for %s" % repr(method_name)) |
|||
return |
|||
|
|||
resp = proto() |
|||
resp.ParseFromString(message.body.serialized_method_response) |
|||
|
|||
self.emit(method_name, resp) |
|||
|
|||
jobid = message.header.jobid_target |
|||
if jobid not in (-1, 18446744073709551615): |
|||
self.emit("job_%d" % jobid, resp) |
|||
|
|||
def get(self, method_name): |
|||
"""Get request proto instance for given methed name |
|||
|
|||
:param method_name: name for the method (e.g. ``Player.GetGameBadgeLevels#1``) |
|||
:type method_name: :class:`str` |
|||
:return: proto message instance, or :class:`None` if not found |
|||
""" |
|||
proto = get_um(method_name) |
|||
if proto is None: |
|||
return None |
|||
message = proto() |
|||
self._data[message] = method_name |
|||
return message |
|||
|
|||
def send(self, message, params=None): |
|||
"""Send service method request |
|||
|
|||
:param message: |
|||
proto message instance (use :meth:`SteamUnifiedMessages.get`) |
|||
or method name (e.g. ``Player.GetGameBadgeLevels#1``) |
|||
:type message: :class:`str`, proto message instance |
|||
:param params: message parameters |
|||
:type params: :class:`dict` |
|||
:return: ``jobid`` event identifier |
|||
:rtype: :class:`str` |
|||
|
|||
Listen for ``jobid`` on this object to catch the response. |
|||
|
|||
.. note:: |
|||
If you listen for ``jobid`` on the client instance you will get the encapsulated message |
|||
""" |
|||
if isinstance(message, str): |
|||
message = self.get(message) |
|||
if message not in self._data: |
|||
raise ValueError("Supplied message seems to be invalid. Did you use 'get' method?") |
|||
|
|||
if params: |
|||
proto_fill_from_dict(message, params) |
|||
|
|||
capsule = MsgProto(EMsg.ClientServiceMethod) |
|||
capsule.body.method_name = self._data[message] |
|||
capsule.body.serialized_method = message.SerializeToString() |
|||
|
|||
return self._steam.send_job(capsule) |
|||
|
|||
def send_and_wait(self, message, params=None, timeout=None, raises=False): |
|||
"""Send service method request and wait for response |
|||
|
|||
:param message: |
|||
proto message instance (use :meth:`SteamUnifiedMessages.get`) |
|||
or method name (e.g. ``Player.GetGameBadgeLevels#1``) |
|||
:type message: :class:`str`, proto message instance |
|||
:param params: message parameters |
|||
:type params: :class:`dict` |
|||
:param timeout: (optional) seconds to wait |
|||
:type timeout: :class:`int` |
|||
:param raises: (optional) On timeout if :class:`False` return :class:`None`, else raise :class:`gevent.Timeout` |
|||
:type raises: :class:`bool` |
|||
:return: response proto message instance |
|||
:rtype: proto message, :class:`None` |
|||
:raises: :class:`gevent.Timeout` |
|||
""" |
|||
job_id = self.send(message, params) |
|||
resp = self.wait_event(job_id, timeout, raises=raises) |
|||
if resp is None and not raises: |
|||
return None |
|||
else: |
|||
return resp[0] |
|||
Loading…
Reference in new issue