def test_get_partner_inventory(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password, self.steam_guard_file)
partner_id = ''
game = GameOptions.CS
client.get_my_inventory(game)
inventory = client.get_partner_inventory(partner_id, game)
self.assertIsNotNone(inventory)
def test_create_and_remove_sell_listing(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password,
self.steam_guard_file)
game = GameOptions.DOTA2
inventory = client.get_my_inventory(game)
asset_id_to_sell = None
for asset_id, item in inventory.items():
if item.get("marketable") == 1:
asset_id_to_sell = asset_id
break
self.assertIsNotNone(
asset_id_to_sell,
"You need at least 1 marketable item to pass this test")
response = client.market.create_sell_order(asset_id_to_sell, game,
"10000")
self.assertTrue(response["success"])
sell_listings = client.market.get_my_market_listings()["sell_listings"]
listing_to_cancel = None
for listing in sell_listings.values():
if listing["description"]["id"] == asset_id_to_sell:
listing_to_cancel = listing["listing_id"]
break
self.assertIsNotNone(listing_to_cancel)
response = client.market.cancel_sell_order(listing_to_cancel)
def test_make_offer(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password, self.steam_guard_file)
partner_id = ''
game = GameOptions.CS
my_items = client.get_my_inventory(game)
partner_items = client.get_partner_inventory(partner_id, game)
my_first_item = next(iter(my_items.values()))
partner_first_item = next(iter(partner_items.values()))
my_asset = Asset(my_first_item['id'], game)
partner_asset = Asset(partner_first_item['id'], game)
response = client.make_offer([my_asset], [partner_asset], partner_id, 'TESTOWA OFERTA')
self.assertIsNotNone(response)
def test_make_offer_with_trade_url(self):
sample_trade_url="https://steamcommunity.com/tradeoffer/new/?partner=314218906&token=sgA4FdNm"
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password, self.steam_guard_file)
partner_id = '76561198274484634'
game = GameOptions.CS
my_items = client.get_my_inventory(game)
partner_items = client.get_partner_inventory(partner_id, game)
my_first_item = next(iter(my_items.values()))
partner_first_item = next(iter(partner_items.values()))
my_asset = Asset(my_first_item['id'], game)
partner_asset = Asset(partner_first_item['id'], game)
response = client.make_offer_url([my_asset], [partner_asset],sample_trade_url, 'TESTOWA OFERTA')
self.assertIsNotNone(response)
def test_make_offer_url(self):
partner_account_id = '32384925'
partner_token = '7vqRtBpC'
sample_trade_url = 'https://steamcommunity.com/tradeoffer/new/?partner=' + partner_account_id + '&token=' + partner_token
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password,
self.steam_guard_file)
client._session.request('HEAD', 'http://steamcommunity.com')
partner_steam_id = account_id_to_steam_id(partner_account_id)
game = GameOptions.CS
my_items = client.get_my_inventory(game, merge=False)['rgInventory']
partner_items = client.get_partner_inventory(
partner_steam_id, game, merge=False)['rgInventory']
my_first_item = next(iter(my_items.values()))
partner_first_item = next(iter(partner_items.values()))
my_asset = Asset(my_first_item['id'], game)
partner_asset = Asset(partner_first_item['id'], game)
response = client.make_offer_with_url([my_asset], [partner_asset],
sample_trade_url,
'TESTOWA OFERTA')
self.assertIsNotNone(response)
def test_create_and_remove_sell_listing(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password, self.steam_guard_file)
game = GameOptions.DOTA2
inventory = client.get_my_inventory(game)
asset_id_to_sell = None
for asset_id, item in inventory.items():
if item.get("marketable") == 1:
asset_id_to_sell = asset_id
break
self.assertIsNotNone(asset_id_to_sell, "You need at least 1 marketable item to pass this test")
response = client.market.create_sell_order(asset_id_to_sell, game, "10000")
self.assertTrue(response["success"])
sell_listings = client.market.get_my_market_listings()["sell_listings"]
listing_to_cancel = None
for listing in sell_listings.values():
if listing["description"]["id"] == asset_id_to_sell:
listing_to_cancel = listing["listing_id"]
break
self.assertIsNotNone(listing_to_cancel)
response = client.market.cancel_sell_order(listing_to_cancel)
def executeTrade(u1, u2, item_ID):
success = False
MY_API_KEY = os.environ['MY_API_KEY']
PATH_TO_STEAMGUARD_FILE = os.environ['PATH_TO_STEAMGUARD_FILE']
OFFER_NAME = getTradeID(u1, u2, item_ID)
u1_username = u1.steam
u1_password = u1.pwd
u1_id = u1.steam_ID
u2_username = u2.steam
u2_password = u2.pwd
u2_id = u2.steam_ID
steam_client_u1 = SteamClient(MY_API_KEY)
steam_client_u1.login(u1_username, u1_password, PATH_TO_STEAMGUARD_FILE)
steam_client_u2 = SteamClient(MY_API_KEY)
steam_client_u2.login(u2_username, u2_password, PATH_TO_STEAMGUARD_FILE)
game = GameOptions.CS
my_items = steam_client_u1.get_my_inventory(game)
partner_items = steam_client_u1.get_partner_inventory(u2_id, game)
my_first_item = next(iter(my_items.values()))
partner_first_item = next(iter(partner_items.values()))
my_asset = Asset(my_first_item['id'], game)
partner_asset = Asset(partner_first_item['id'], game)
retDict = steam_client_u1.make_offer([my_asset], [partner_asset],
partner_id, OFFER_NAME)
if retDict:
tradeofferid = retDict['tradeofferid']
steam_client_u2.accept_trade_offer(tradeofferid)
success = True # return success
steam_client_u1.logout()
steam_client_u2.logout()
return success
def test_get_my_inventory(self):
client = SteamClient(self.credentials.api_key)
client.login(self.credentials.login, self.credentials.password,
self.steam_guard_file)
inventory = client.get_my_inventory(GameOptions.CS)
self.assertIsNotNone(inventory)
class TradeBoost:
GAME = GameOptions.STEAM
def __init__(self, cfg_account: str, recipient_id: str) -> None:
self.cfg_account = json.load(open(cfg_account))
self.login = self.cfg_account["login"]
self.api_token = self.cfg_account['API']
self.password = self.cfg_account['password']
self.recipient_id = recipient_id
self.partner_id = int(self.recipient_id) - 76561197960265728
self.adapter = CustomAdapter(logger, {'account': self.login})
try:
self.account = SteamClient(self.api_token)
self.account.login(self.login, self.password, cfg_account)
self.adapter.info(translate.word('good_auth'))
self.decline_all_trades()
except steampy.exceptions.InvalidCredentials as e:
self.adapter.warning(translate.word('bad_auth').format(e))
def decline_all_trades(self):
params = {
'key': self.api_token,
'get_sent_offers': 1,
'get_received_offers': 0,
'get_descriptions': 0,
'language': 'english',
'active_only': 1,
'historical_only': 0,
'time_historical_cutoff': ''
}
response = (self.account.api_call('GET', 'IEconService',
'GetTradeOffers', 'v1',
params).json()['response'])
count_decline = 0
if 'trade_offers_sent' in response:
for offer in response['trade_offers_sent'][:5]:
if offer['accountid_other'] == self.partner_id:
self.account.cancel_trade_offer(offer['tradeofferid'])
count_decline += 1
self.adapter.info(
translate.word('trade_decline').format(count_decline))
def get_item(self) -> str:
try:
items = self.account.get_my_inventory(game=self.GAME, count=15)
item_id = choice(list(items.keys()))
about_item = items[item_id]
if item_id and state.not_in(
item_id) and about_item['tradable'] == 1:
self.adapter.info(
translate.word('item_received').format(
item_id, about_item["name"]))
state.add(item_id)
return item_id
else:
return ''
except Exception as e:
self.adapter.warning(translate.word('bad_send').format(e))
return ''
def send_trades(self) -> str:
item_id = ''
while item_id in ['', None]:
item_id = self.get_item()
asset_one = Asset(item_id, self.GAME)
trade = self.account.make_offer([asset_one], [], self.recipient_id)
if validate_api_response(trade):
self.adapter.info(
translate.word('sent_trade').format(trade["tradeofferid"]))
return trade['tradeofferid']
else:
self.adapter.warning(
translate.word('bad_send').format(list(trade.values())[0]))
self.decline_all_trades()
def accept_trade(self, trade_id: str) -> None:
trade_info = self.account.get_trade_offer(trade_id)
if 'offer' in trade_info['response']:
if int(trade_info['response']['offer']
['accountid_other']) == self.partner_id:
resp = self.account.accept_trade_offer(trade_id)
if validate_api_response(resp):
self.adapter.info(
translate.word('accepted_trade').format(trade_id))
item = trade_info['response']['offer']['items_to_receive'][
0]['assetid']
state.remove(item)
else:
self.adapter.warning(
translate.word('bad_accept').format(
trade_id,
list(resp.values())[0]))
else:
self.adapter.warning(translate.word('bad_send').format(trade_info))
params={'appid': '730'})
return resp.json()['response']
if __name__ == '__main__':
logger.setLevel(level=logging.INFO)
file_handler = logging.FileHandler('data/skypebot.log', encoding='utf-8')
formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
ops = OpSkins('e4f2d89cdbac56b132b68cef2c53e5')
steam_client = SteamClient()
steam_client.login(
'immunepzw', 'arigold4172409',
r'C:\Users\sham\Desktop\sda\maFiles\76561198177211015.maFile')
my_skins = steam_client.get_my_inventory(game=GameOptions.CS)
items = []
lowest_prices = ops.get_lowest_sale_prices()
prices_db = shelve.open('./data/pricehistory.dat')
box_classids = ('520025252', '2048553988', '1544067968', '1432174707',
'1293508920', '926978479', '1690096482', '991959905',
'1797256701', '1923037342')
for id_, skin_descr in my_skins.items():
if not skin_descr['tradable'] or skin_descr['classid'] in box_classids:
continue
skin_name = skin_descr['market_hash_name']
lowest_price = lowest_prices[skin_name]['price']
if lowest_price != 2: # lowest price on opskins is 2 cents
lowest_price -= 1
# average_price = prices_db[skin_name][0]
# if lowest_price / average_price < 0.99:
try:
steam_client.login(username, password, steam_guard_path)
except (ValueError, InvalidCredentials):
print('Your login credentials are invalid')
exit(1)
print("Finished! Logged into steam")
#we will ask them for the game's app id and context id of the inventory
if not app_id:
app_id = input('What is the app id?\n')
if not context_id:
context_id = input(
'What is the context id of that game\'s inventory? (usually 2)\n')
#get all the items in inventory, and save each name of item and the amount
print('Obtaining inventory...')
item_amounts = {}
inventory = steam_client.get_my_inventory(GameOptions(app_id, context_id))
for item in inventory.values():
if item["market_name"] in item_amounts:
item_amounts[item['market_name']] += 1
else:
item_amounts[item['market_name']] = 1
print('Done reading inventory for game: {}'.format(app_id))
#dump all the information into inventory_(app_id)_(context_id).json file
print('Saving information....')
with open('inventory_{0}_{1}.json'.format(app_id, context_id), 'w') as file:
dump(item_amounts, file)
print('Done! Saved to file: inventory_{0}_{1}.json'.format(app_id, context_id))
