def test_kwarg_instance(): assert SteamID(id=5, instance=1234).instance == 1234 for type in EType: assert (SteamID(id=5, type=type).instance == 1 if type in ( EType.Individual, EType.GameServer) else SteamID(id=5, type=type).instance == 0)
def get_user(self, user: str): if user.startswith( "https://steamcommunity.com/id/") or user.startswith( "https://steamcommunity.com/profiles/"): u = user.replace("//", "/", 1).split("/", 3)[-1] return steam.steamid.from_url(user), u if u[-1] != "/" else u[:-1] res = self._api.call("ISteamUser.ResolveVanityURL", vanityurl=user, url_type=1) if res["response"]["success"] == 1: return SteamID(res["response"]["steamid"]), user else: # TODO: Logging print(res) pass if user.isnumeric(): res = self._api.call("ISteamUser.GetPlayerSummaries", steamids=user) if isinstance(res["response"]["players"], list) and len( res["response"]["players"]) == 1: u = res["response"]["players"][0] return SteamID(u["steamid"]), u["personaname"] elif isinstance(res["response"]["players"], dict) and len( res["response"]["players"]["player"]) == 1: u = res["response"]["players"]["player"][0] return SteamID(u["steamid"]), u["personaname"] else: print(res) pass pass raise SteamMatchException(f"User {user} not found.")
def test_arg_steam64(): compare(SteamID(76580280500085312), [123456, EType.Individual, EUniverse.Public, 4444]) compare(SteamID("76580280500085312"), [123456, EType.Individual, EUniverse.Public, 4444]) compare(SteamID(103582791429521412), [4, EType.Clan, EUniverse.Public, 0]) compare(SteamID("103582791429521412"), [4, EType.Clan, EUniverse.Public, 0])
def test_kwarg_instance() -> None: assert SteamID( id=5, instance=InstanceFlag.Console).instance == InstanceFlag.Console for type in Type: assert (SteamID(id=5, type=type).instance == InstanceFlag.Desktop if type in (Type.Individual, Type.GameServer) else SteamID( id=5, type=type).instance == InstanceFlag.All)
def convert_from_vanity_url_to_SteamID(self, user_string): """ Tries to create a SteamID object via the URL. """ if user_string.isdigit(): return SteamID.from_url( "http://steamcommunity.com/profiles/{}".format(user_string)) else: return SteamID.from_url( "http://steamcommunity.com/id/{}".format(user_string))
def test_kwarg_type(): with pytest.raises(InvalidSteamID): SteamID(id=5, type="doesn't exist") with pytest.raises(InvalidSteamID): SteamID(id=5, type=99999999) assert SteamID(id=5, type=1).type == EType.Individual assert SteamID(id=5, type="Individual").type == EType.Individual assert SteamID(id=5, type="AnonUser").type == EType.AnonUser
def test_kwarg_universe(): with pytest.raises(InvalidSteamID): SteamID(id=5, universe="doesn't exist") with pytest.raises(InvalidSteamID): SteamID(id=5, universe=99999999) assert SteamID(id=5, universe=1).universe == EUniverse.Public assert SteamID(id=5, universe="Public").universe == EUniverse.Public assert SteamID(id=5, universe="Dev").universe == EUniverse.Dev
async def steamsync(self, ctx: commands.Context, steam_id: str, user: Optional[discord.Member] = None) -> None: """ Sync a Steam profile's games with a Discord ID steam_id: Steam Name (found in your Custom URL -> steamcommunity.com/id/<name>) or Steam ID (64-bit ID -> steamcommunity.com/profiles/<id>) user: If given, sync library to user, otherwise default to user of the message Examples: ``` [p]game steamsync Alyx [p]game steamsync Alyx @Alyx [p]game steamsync 76561198221914843 [p]game steamsync 76561198221914843 @Alyx ``` """ await ctx.trigger_typing() if not user: user = ctx.author steam_user = SteamID(steam_id) if steam_user.is_valid(): # Either use the given 64-bit Steam ID to sync with Steam... steam_id_64 = steam_user.as_64 else: # ...or convert given name to a 64-bit Steam ID steam_client = await self.get_steam_client(ctx) if steam_client is None: return steam_name = steam_client.ISteamUser.ResolveVanityURL( vanityurl=steam_id) if steam_name.get("response", {}).get("success") != 1: await ctx.send( f"There was a problem syncing {user.mention}'s account with Steam ID '{steam_id}'. Please try again with the 64-bit Steam ID instead." ) return steam_id_64 = steam_name.get("response", {}).get("steamid") await self.config.user(user).steam_id.set(steam_id_64) steam_game_list = await self.get_steam_games(ctx, user) if steam_game_list: game_list = await self.config.user(user).games() game_list.extend(steam_game_list) game_list = list(set(game_list)) await self.config.user(user).games.set(game_list) await ctx.send(f"{user.mention}'s account was synced with Steam.")
def test_as_invite_url(): assert SteamID(0, EType.Individual, EUniverse.Public, instance=1).invite_url is None assert SteamID(123456, EType.Individual, EUniverse.Public, instance=1).invite_url == "https://s.team/p/cv-dgb" assert SteamID(123456, EType.Individual, EUniverse.Beta, instance=1).invite_url == "https://s.team/p/cv-dgb" assert SteamID(123456, EType.Invalid, EUniverse.Public, instance=1).invite_url is None assert SteamID(123456, EType.Clan, EUniverse.Public, instance=1).invite_url is None
def test_as_invite_code(): assert SteamID(0, EType.Individual, EUniverse.Public, instance=1).invite_code is None assert SteamID(123456, EType.Individual, EUniverse.Public, instance=1).invite_code == "cv-dgb" assert SteamID(123456, EType.Individual, EUniverse.Beta, instance=1).invite_code == "cv-dgb" assert SteamID(123456, EType.Invalid, EUniverse.Public, instance=1).invite_code is None assert SteamID(123456, EType.Clan, EUniverse.Public, instance=1).invite_code is None
def test_community_url(): # user url assert SteamID( 76580280500085312 ).community_url == "https://steamcommunity.com/profiles/76580280500085312" # group url assert SteamID( "[g:1:4]" ).community_url == "https://steamcommunity.com/gid/103582791429521412" # else None assert SteamID("[A:1:4]").community_url is None
def add_ban(self, target, duration=0, admin=0, reason=None): target_id = SteamID.Parse(uniqueid_from_index(target)).to_uint64() if admin == 0: admin_id = None else: admin_id = SteamID.Parse(uniqueid_from_index(admin)).to_uint64() ban_record = BanRecord(target_id=target_id, admin_id=admin_id, duration=duration, reason=reason) with session_scope() as session: session.add(ban_record)
async def names(self, ctx, member: discord.Member = None, service=None): if member == None: member = ctx.message.author discordID = str(member.id) with open('matchacat/matchacat.json', 'r') as f: matchacatJSON = json.load(f) if matchacatJSON['users'].get(discordID, None) != None: if service == None: UserList = [] if matchacatJSON['users'][discordID].get('steamID') != None: UserList += [ 'Steam: ' + (SteamID(matchacatJSON['users'][discordID] ['steamID']).community_url) ] if matchacatJSON['users'][discordID].get('MCuuid') != None: print(matchacatJSON['users'][discordID].get('MCuuid')) MCuser = mcutil.search(member) print(MCuser) if MCuser != None: UserList += ['Minecraft: ' + MCuser] if matchacatJSON['users'][discordID].get('PSuser') != None: UserList += [ 'Showdown: ' + matchacatJSON['users'][discordID].get('PSuser') ] if UserList != []: await ctx.send('\n'.join(UserList)) else: await ctx.send('This user has no names registered.') if service == self.services[0]: #Steam if matchacatJSON['users'][discordID].get('steamID', None) != None: steamurl = SteamID(matchacatJSON['users'][discordID] ['steamID']).community_url await ctx.send(steamurl) if service == self.services[1]: #Minecraft MCuser = mcutil.search(member) if MCuser == None: await ctx.send('Could not find username.') else: await ctx.send('{}'.format(MCuser)) if service == self.services[2]: #Showdown showdown = matchacatJSON['users'][discordID].get('PSuser') if showdown != None: ctx.send(showdown) else: ctx.send('This user has no pokemon showdown nickname.') else: await ctx.send('This user has no usernames registered')
def test_from_id(): compare(SteamID(1), [1, EType.Individual, EUniverse.Public, 1]) compare(SteamID("1"), [1, EType.Individual, EUniverse.Public, 1]) compare(SteamID(12), [12, EType.Individual, EUniverse.Public, 1]) compare(SteamID("12"), [12, EType.Individual, EUniverse.Public, 1]) compare(SteamID(123), [123, EType.Individual, EUniverse.Public, 1]) compare(SteamID("123"), [123, EType.Individual, EUniverse.Public, 1]) compare(SteamID(12345678), [12345678, EType.Individual, EUniverse.Public, 1]) compare(SteamID("12345678"), [12345678, EType.Individual, EUniverse.Public, 1]) compare(SteamID(0xFFFFFFFF), [0xFFFFFFFF, EType.Individual, EUniverse.Public, 1]) compare(SteamID(str(0xFFFFFFFF)), [0xFFFFFFFF, EType.Individual, EUniverse.Public, 1])
def login_callback(resp): """Callback fired after steam login, log user in the application by generating a refresh token. Also create a basic profil from steam information if this is the first login. Args: resp: OpenID response. Returns: Redirects to the callback url defined in the config with the refresh token as a parameter. """ match = _steam_id_re.search(resp.identity_url) steam_id = SteamID(match.group(1)) token = { 'steamid': str(steam_id.as_64), 'aud': 'refresh', 'exp': datetime.utcnow() + timedelta(days=60) } token = jwt.encode(token, app.config['SECRET_KEY']) UserRefreshToken.upsert(steam_id, token.decode('utf-8')) user = User.get(steam_id) if user is None: user = User(steam_id) api = WebAPI(key=app.config['STEAM_KEY']) resp = api.ISteamUser.GetPlayerSummaries_v2(steamids=steam_id) user.nickname = resp['response']['players'][0]['personaname'] user.avatar = UrlImageToBase64(resp['response']['players'][0]['avatarfull']) db.session.add(user) db.session.commit() url = '{0}?token={1}'.format(app.config['FRONTEND_LOGIN_REDIRECT'], token.decode('utf-8')) return redirect(url)
def login_callback(resp): """Callback fired after steam login, log user in the application by generating a refresh token. Also create a basic user entry from steam id if this is the first login. Args: resp: OpenID response. Returns: Redirects to the callback url defined in the config with the refresh token as a parameter. """ match = _steam_id_re.search(resp.identity_url) steam_id = SteamID(match.group(1)) token = { 'aud': 'refresh', 'client': { 'type': 'user', 'steamid': str(steam_id.as_64) }, 'exp': datetime.utcnow() + timedelta(days=60) } token = jwt.encode(token, app.config['SECRET_KEY']) user = User.get(steam_id) if user is None: user = User(steam_id) db.session.add(user) user.refresh_token = token.decode('utf-8') db.session.commit() url = '{0}?token={1}'.format(app.config['FRONTEND_LOGIN_REDIRECT'], user.refresh_token) return redirect(url)
def get_model_by_steamid(steamid): try: return apps.get_model( "steamauthprovider", "SteamUser").objects.get(steamid64=SteamID(steamid).as_64) except ObjectDoesNotExist: return False
def scan_profile_result(self, account_id, profile_card): """Process the profile information returned by Steam. Extract the SoloMMR from the profile and insert the user in the good ladder. Args: account_id: steam_id (as 32bits) of the profile result profile_card: profile information as a protobuff message """ self.print_info('Processing profile of user %s' % SteamID(account_id).as_64) solo_mmr = None for slot in profile_card.slots: if not slot.HasField('stat'): continue if slot.stat.stat_id != 1: continue solo_mmr = int(slot.stat.stat_score) with self.app.app_context(): user = User.query.filter_by(id=self.job.steam_id).first() user.profile_scan_info.last_scan = datetime.utcnow() if solo_mmr is not None: user.solo_mmr = solo_mmr if user.solo_mmr is None: user.section = None else: if user.solo_mmr > 4500: user.section = constants.LADDER_HIGH else: user.section = constants.LADDER_LOW db.session.commit() self.job.scan_finish = True
async def steam(ctx, *args): """Link your steam account to your profile !steam < steam link >""" author = ctx.author.mention if len(args) == 0: await ctx.send(f"{author}, incorrect format please see !help steam") elif len(args) > 1: await ctx.send(f"{author}, inccorect format please see !help steam") else: steamID = str(SteamID.from_url(f"{args[0]}", http_timeout=10)) if steamID == "None": await ctx.send(f"{author}, sorry that is not a valid link.") else: conn = sql.connect("data.db") cursor = conn.cursor() if cursor.execute( f"SELECT * FROM users WHERE nickname = '{ctx.author}';" ).fetchone() == None: cursor.execute( f"""INSERT INTO users(steamID, nickname) VALUES ('{steamID}','{ctx.author}')""" ) else: cursor.execute( f"UPDATE users SET steamID = '{steamID}' WHERE nickname = '{ctx.author}'" ) conn.commit() await ctx.send(f"{author}, success you're accounts are now linked." )
def get_prof_names(self, args): try: for self.nm, self.u_32 in enumerate(self.get_local_32()): self.url = SteamID(self.u_32).community_url req = requests.get(self.url + '/ajaxaliases') if req.status_code: self.user_name = json.loads(req.content)[0]['newname'] if not self.u_32 in self.cfg['profiles'].keys(): self.cfg['profiles'][self.u_32] = { 'user_name': self.user_name, 'details': {} } else: self.cfg['profiles'][ self.u_32]['user_name'] = self.user_name self.cfg['users'][self.user_name] = self.u_32 print(f'Found : {self.user_name} : {self.u_32}') else: print( f'bad status request for {self.u_32} : {self.user_name}' ) print(f'Found {self.nm+1} accounts...') self.save_cfg() except Exception as error: pass
def chatHistory(request, steamid): if steamid.startswith("STEAM_") or steamid.isdigit(): try: steamid64 = SteamID(steamid) steamid2 = steamid64.as_steam2 except (TypeError, ValueError) as e: content = {'error': 'Please enter a valid steamid or steamid64'} return Response(content, status=status.HTTP_404_NOT_FOUND) else: try: chats = Chatlogs.objects.using('Chatlogs').filter( steamid=steamid2).order_by('-date') if not chats: content = {'error': 'Player not in database'} return Response(content, status=status.HTTP_404_NOT_FOUND) except TypeError: content = { 'error': 'Please enter a valid steamid or steamid64' } return Response(content, status=status.HTTP_404_NOT_FOUND) else: chat = [] for x in chats: chat.append(x.text) return Response({"chatHistory": chat}) else: content = {'error': 'Please enter a valid steamid or steamid64'} return Response(content, status=status.HTTP_404_NOT_FOUND)
def topTen(request): sql = "SELECT id, auth, SUM(duration) duration FROM player_analytics GROUP BY auth ORDER BY duration DESC LIMIT 10" top_players = PlayerAnalytics.objects.using('Analytics').raw(sql) top_ten = defaultdict(dict) i = 0 for x in top_players: i += 1 steamid64 = SteamID(x.auth) steamid2 = steamid64.as_steam2 top_ten[i]['hours'] = int( PlayerAnalytics.objects.using('Analytics').filter( auth=steamid2).aggregate(Sum('duration'))['duration__sum'] / 3600) top_ten[i]['profile'] = "http://steamcommunity.com/profiles/{}".format( steamid64) top_ten[i]['steamid2'] = steamid2 file = urllib.request.urlopen( "http://steamcommunity.com/profiles/{}/?xml=1".format(steamid64)) data = file.read() file.close() data = xmltodict.parse(data) top_ten[i]['picture'] = data["profile"]["avatarIcon"] top_ten[i]['name'] = data["profile"]["steamID"] return Response({'topten': top_ten})
def test_as_steam3(): assert SteamID("[U:1:1234]").id3, "[U:1:1234]" assert SteamID("[U:1:1234:56]").id3, "[U:1:1234:56]" assert SteamID("[g:1:4]").id3, "[g:1:4]" assert SteamID("[A:1:1234:567]").id3 == "[A:1:1234:567]" assert SteamID("[G:1:1234:567]").id3 == "[G:1:1234]" assert SteamID("[T:1:1234]").id3 == "[T:1:1234]" assert SteamID("[c:1:1234]").id3 == "[g:1:1234]" assert SteamID("[L:1:1234]").id3 == "[L:1:1234]"
async def __getSteamProfile(self, uid): async with aiohttp.ClientSession() as session: params = { "key" : keys.STEAM_WEBAPI, "steamids" : SteamID(uid).as_64 } async with session.get(self.steamProfileUrl, params = params) as r: if r.status == 200: js = await r.json() return(js['response']['players'][0])
def process_cart_result(self, edge_task, task_result): succesful_items = task_result.get('items') failed_items = task_result.get('failed_items') failed_shopping_cart_gids = task_result.get( 'failed_shopping_cart_gids') RelationController().rollback_pushed_relations(edge_task.task_id) if len(failed_shopping_cart_gids): log.info( u'Received a list of previously commited shoppingCartGID that failed' ) for shopping_cart_gid in failed_shopping_cart_gids: if shopping_cart_gid is not None: RelationController().rollback_failed_relations( shopping_cart_gid) if len(failed_items): log.info(u'Received a list of relations that fail to add to cart') for item in failed_items: relation_type = item.get('relation_type') relation_id = item.get('relation_id') RelationController().set_relation_commitment( relation_type, relation_id, enums.ERelationCommitment.FailedToAddToCart.value, edge_task.task_id, commited_on_bot=edge_task.edge_bot.network_id) log.info(u'Received {} succesful items'.format(len(succesful_items))) for item in succesful_items: shopping_cart_gid = task_result.get('shoppingCartGID') relation_type = item.get('relation_type') relation_id = item.get('relation_id') RelationController().set_relation_commitment( relation_type, relation_id, enums.ERelationCommitment.AddedToCart.value, shopping_cart_gid=shopping_cart_gid) if len(succesful_items): # Assume there is one cart-push per user, so just grab the first on the list user_id = succesful_items[0].get('user_id') user = self.user_model.get(id=user_id) account_id = SteamID(user.steam).as_32 self.call_checkout(edge_task.edge_bot, edge_task.edge_server, account_id) else: self.set_edge_bot_status(edge_task.edge_bot.network_id, enums.EEdgeBotStatus.StandingBy.value)
async def map(ctx, arg): if ctx.message.channel.id == PLAYER_COMMANDS: sql = "SELECT time, auth FROM playertimes WHERE map = '" + arg + "' ORDER by 'time' ASC" crs = mydb.cursor(buffered=True) crs.execute(sql) maptime = crs.fetchone() user = SteamID(maptime[1]) user = user.community_url await ctx.send("Best time on map: ***" + arg + "*** is ***" + str(maptime[0]) + "*** sekund, ustanowiony przez " + user)
def convert_to_steam_id(user_string): """ Generates valid steam IDs from user input. Keyword arguments: user_string -- input from user """ # Converts URL format to standard format. user_string = user_string.split("/")[-1] steam_id = SteamID(user_string) if steam_id.is_valid(): return steam_id else: # Failure can be due to vanity usernames. steam_id = convert_from_vanity_url_to_steam_id(user_string) if steam_id: return steam_id else: return None
async def steamid(self, ctx, communityid: str): """Gets a steam id in all formats""" await ctx.channel.trigger_typing() steamID = SteamID.from_url( "http://steamcommunity.com/id/{}".format(communityid)) if steamID is None: steamID = SteamID(communityid) try: name = steamAPI.ISteamUser.GetPlayerSummaries_v2( steamids=steamID)["response"]["players"][0]["personaname"] except IndexError: await ctx.send( "User not found! Make sure you are using steam community IDs!") return await ctx.send( xl.format( "Steam ID formats for {}:\nSteamID2: {}\nSteamID2Zero: {}\nSteamID3: {}\nSteamID32: {}\nSteamID64: {}" ).format(name, steamID.as_steam2, steamID.as_steam2_zero, steamID.as_steam3, steamID.as_32, steamID.as_64))
def xmlGetInfo(steamid, query): steamid64 = str(SteamID(steamid)) try: h = httplib2.Http() resp, content = h.request( "http://steamcommunity.com/profiles/{}/?xml=1".format(steamid64), "GET") data = xmltodict.parse(content) return data["profile"][query] except KeyError: return "-"
def xmlGetVac(steamid): steamid64 = str(SteamID(steamid)) try: h = httplib2.Http() resp, content = h.request( "http://steamcommunity.com/profiles/{}/?xml=1".format(steamid64), "GET") data = xmltodict.parse(content) return int(data["profile"]["vacBanned"]) except KeyError: return "-"
async def steamid(self, ctx, communityid:str): """Gets a steam id in all formats""" await ctx.channel.trigger_typing() steamID = SteamID.from_url("http://steamcommunity.com/id/{}".format(communityid)) if steamID is None: steamID = SteamID(communityid) try: name = steamAPI.ISteamUser.GetPlayerSummaries_v2(steamids=steamID)["response"]["players"][0]["personaname"] except IndexError: await ctx.send("User not found! Make sure you are using steam community IDs!") return await ctx.send(xl.format("Steam ID formats for {}:\nSteamID2: {}\nSteamID2Zero: {}\nSteamID3: {}\nSteamID32: {}\nSteamID64: {}").format(name, steamID.as_steam2, steamID.as_steam2_zero, steamID.as_steam3, steamID.as_32, steamID.as_64))
async def steamuser(self, ctx, communityid:str): """Gets steam profile information on a user with the specified community ID""" await ctx.channel.trigger_typing() steamID = SteamID.from_url("http://steamcommunity.com/id/{}".format(communityid)) if steamID is None: steamID = communityid try: steamUser = steamAPI.ISteamUser.GetPlayerSummaries_v2(steamids=steamID)["response"]["players"][0] except IndexError: await ctx.send("User not found! Make sure you are using steam community IDs!") return bans = steamAPI.ISteamUser.GetPlayerBans_v1(steamids=steamID)["players"][0] vacBanned = bans["VACBanned"] communityBanned = bans["CommunityBanned"] ban_info = {"VAC Banned":vacBanned, "Community Banned":communityBanned} if vacBanned: ban_info["VAC Bans"] = bans["NumberOfVACBans"] ban_info["Days Since Last VAC Ban"] = bans["DaysSinceLastBan"] if steamUser["communityvisibilitystate"] != 3: embed = make_list_embed(ban_info) embed.description = "This profile is private." embed.title = steamUser["personaname"] embed.color = 0xFF0000 embed.url = steamUser["profileurl"] embed.set_thumbnail(url=steamUser["avatarfull"]) await ctx.send(embed=embed) return groupCount = len(steamAPI.ISteamUser.GetUserGroupList_v1(steamid=steamID)["response"]["groups"]) games = requests.get("http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key={}&steamid={}&include_played_free_games=1%format=json".format(config._steamAPIKey, steamID)).json()["response"] gamesPlayed = games["game_count"] state = EPersonaState(steamUser["personastate"]).name gameName = None if "gameid" in steamUser.keys(): state = "In-game" gameID = steamUser["gameid"] gameName = requests.get("http://store.steampowered.com/api/appdetails?appids={}".format(gameID)).json()[gameID]["data"]["name"] lastOnline = format_time(datetime.fromtimestamp(steamUser["lastlogoff"])) creationDate = format_time(datetime.fromtimestamp(steamUser["timecreated"])) fields = {"Status":state, "Created on":creationDate, "Group Count":groupCount, "Games Owned":gamesPlayed} if state == EPersonaState.Offline.name: fields["Last Online"] = lastOnline if gameName: fields["Currently Playing"] = gameName if "primaryclanid" in steamUser.keys(): fields["Primary Group Name"] = etree.fromstring(requests.get("http://steamcommunity.com/gid/{}/memberslistxml".format(steamUser["primaryclanid"])).text).find("groupDetails/groupName").text fields.update(ban_info) embed = make_list_embed(fields) embed.title = steamUser["personaname"] embed.color = 0xFF0000 embed.url = steamUser["profileurl"] embed.set_thumbnail(url=steamUser["avatarfull"]) await ctx.send(embed=embed)
def __missing__(self, steamid): """Create, store and return a :class:`PlayerPermissions` object. :param str/int steamid: A SteamID2, SteamID3 or SteamID64 value. """ if not isinstance(steamid, int): steamid64 = SteamID.parse(steamid).to_uint64() if steamid64 in self: return self[steamid64] # We got a SteamID in a string format, so we can store it by using # its SteamID64 value, but keep the original name. instance = self[steamid64] = PlayerPermissions(steamid, steamid64) else: instance = self[steamid] = PlayerPermissions(steamid, steamid) return instance
def com_net_steam_id_from_user(user_name): return SteamID.from_url('https://steamcommunity.com/id/%s', (user_name,))
def _convert_steamid_to_db_format(self, steamid): return str(SteamID.parse(steamid).to_uint64())