cs2tracker 2.1.12__py3-none-any.whl → 2.1.14__py3-none-any.whl

cs2tracker/data/get_inventory.js

@@ -0,0 +1,191 @@
+const SteamUser = require("steam-user");
+const CS2 = require("globaloffensive");
+const { argv } = require("process");
+const fs = require("fs");
+
+const ItemNameConverter = require("./convert_inventory.js");
+
+process.stdin.setEncoding("utf-8");
+process.stdout.setEncoding("utf-8");
+process.stderr.setEncoding("utf-8");
+
+const args = argv.slice(2);
+const processedInventoryPath = args[0];
+const importInventory = args[1] === "True" ? true : false;
+const importStorageUnits = args[2] === "True" ? true : false;
+const importCases = args[3] === "True" ? true : false;
+const importStickerCapsules = args[4] === "True" ? true : false;
+const importStickers = args[5] === "True" ? true : false;
+const importOthers = args[6] === "True" ? true : false;
+const userName = args[7];
+const password = args[8];
+const twoFactorCode = args[9];
+
+const paddedLog = (...args) => {
+  console.log(" [+] ", ...args);
+};
+
+const originalConsoleError = console.error;
+console.error = (...args) => {
+  originalConsoleError("    [!] " + args.join(" "));
+};
+
+(async () => {
+  let user = new SteamUser();
+
+  paddedLog("Logging into Steam...");
+
+  user.logOn({
+    accountName: userName,
+    password: password,
+    twoFactorCode: twoFactorCode,
+  });
+
+  user.on("error", (err) => {
+    console.error("Steam Error: " + err);
+    user.logOff();
+    process.exit(1);
+  });
+
+  user.on("loggedOn", (_details, _parental) => {
+    paddedLog("Logged into Steam.");
+    user.gamesPlayed([730]);
+  });
+
+  let cs2 = new CS2(user);
+
+  paddedLog("Connecting to CS2 Game Coordinator...");
+
+  cs2.on("error", (err) => {
+    console.error("CS2 Error: " + err);
+    user.logOff();
+    process.exit(1);
+  });
+
+  let nameConverter = new ItemNameConverter();
+  await nameConverter.initialize();
+
+  cs2.on("connectedToGC", async () => {
+    paddedLog("Connected to CS2 Game Coordinator.");
+    let finalItemCounts = {};
+
+    if (importInventory) {
+      const inventoryItemCounts = await processInventory();
+      for (const [itemName, count] of Object.entries(inventoryItemCounts)) {
+        finalItemCounts[itemName] = (finalItemCounts[itemName] || 0) + count;
+      }
+    }
+
+    if (importStorageUnits) {
+      const storageUnitItemCounts = await processStorageUnits();
+      for (const [itemName, count] of Object.entries(storageUnitItemCounts)) {
+        finalItemCounts[itemName] = (finalItemCounts[itemName] || 0) + count;
+      }
+    }
+
+    paddedLog("Saving config...");
+    fs.writeFileSync(
+      processedInventoryPath,
+      JSON.stringify(finalItemCounts, null, 2),
+    );
+
+    paddedLog("Processing complete.");
+    paddedLog("This window will automatically close in 10 seconds.");
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+    user.logOff();
+    process.exit(0);
+  });
+
+  // TODO: The inventory may contain items that are not marketable or tradable,
+  // so we have to make sure to process these items correctly in the main app.
+  async function processInventory() {
+    try {
+      // filter out items that have the casket_id property set from the inventory
+      // because these are items that should be contained in storage units
+      const prefilteredInventory = cs2.inventory.filter((item) => {
+        return !item.casket_id;
+      });
+
+      const convertedItems =
+        nameConverter.convertInventory(prefilteredInventory);
+      const filteredItems = filterItems(convertedItems);
+      const itemCounts = countItems(filteredItems);
+      paddedLog(`${filteredItems.length} items found in inventory`);
+      console.log(itemCounts);
+      return itemCounts;
+    } catch (err) {
+      console.error("An error occurred while processing the inventory:", err);
+      return {};
+    }
+  }
+
+  async function processStorageUnits() {
+    let finalItemCounts = {};
+    try {
+      const storageUnitIds = getStorageUnitIds();
+      for (const [unitIndex, unitId] of storageUnitIds.entries()) {
+        const items = await getCasketContentsAsync(cs2, unitId);
+        const convertedItems = nameConverter.convertInventory(items);
+        const filteredItems = filterItems(convertedItems);
+        const itemCounts = countItems(filteredItems);
+        for (const [itemName, count] of Object.entries(itemCounts)) {
+          finalItemCounts[itemName] = (finalItemCounts[itemName] || 0) + count;
+        }
+        paddedLog(
+          `${filteredItems.length} items found in storage unit: ${unitIndex + 1}/${storageUnitIds.length}`,
+        );
+        console.log(itemCounts);
+      }
+      return finalItemCounts;
+    } catch (err) {
+      console.error("An error occurred while processing storage units:", err);
+      return {};
+    }
+  }
+
+  function getStorageUnitIds() {
+    let storageUnitIds = [];
+    for (let item of cs2.inventory) {
+      if (item.casket_contained_item_count > 0) {
+        storageUnitIds.push(item.id);
+      }
+    }
+    return storageUnitIds;
+  }
+
+  function getCasketContentsAsync(cs2, unitId) {
+    return new Promise((resolve, reject) => {
+      cs2.getCasketContents(unitId, (err, items) => {
+        if (err) return reject(err);
+        resolve(items);
+      });
+    });
+  }
+
+  function filterItems(items) {
+    let filteredItems = [];
+    items.forEach((item) => {
+      if (
+        (item.item_type === "case" && importCases) ||
+        (item.item_type === "sticker capsule" && importStickerCapsules) ||
+        (item.item_type === "sticker" && importStickers) ||
+        (item.item_type === "other" && importOthers)
+      ) {
+        filteredItems.push(item);
+      }
+    });
+    return filteredItems;
+  }
+
+  function countItems(items) {
+    let itemCounts = {};
+    items.forEach((item) => {
+      if (itemCounts[item.item_name]) {
+        itemCounts[item.item_name]++;
+      } else {
+        itemCounts[item.item_name] = 1;
+      }
+    });
+    return itemCounts;
+  }
+})();

cs2tracker/main.py

@@ -5,7 +5,7 @@ import urllib3
 from cs2tracker.app import Application
 from cs2tracker.constants import AUTHOR_STRING, BANNER, OS, OSType
 from cs2tracker.scraper import Scraper
-from cs2tracker.util import PaddedConsole
+from cs2tracker.util import get_console
 
 
 def main():
@@ -23,7 +23,7 @@ def main():
     if OS == OSType.WINDOWS and sys.stdout is not None:
         sys.stdout.reconfigure(encoding="utf-8-sig")  # type: ignore
 
-    console = PaddedConsole()
+    console = get_console()
     console.print(f"[bold yellow]{BANNER}\n{AUTHOR_STRING}\n")
 
     if "--only-scrape" in sys.argv:

cs2tracker/scraper/background_task.py

@@ -9,7 +9,7 @@ from cs2tracker.constants import (
     RUNNING_IN_EXE,
     OSType,
 )
-from cs2tracker.util import PaddedConsole
+from cs2tracker.util import get_console
 
 WIN_BACKGROUND_TASK_NAME = "CS2Tracker Daily Calculation"
 WIN_BACKGROUND_TASK_SCHEDULE = "DAILY"
@@ -18,7 +18,7 @@ WIN_BACKGROUND_TASK_CMD = (
     f"powershell -WindowStyle Hidden -Command \"Start-Process '{BATCH_FILE}' -WindowStyle Hidden\""
 )
 
-console = PaddedConsole()
+console = get_console()
 
 
 class BackgroundTask:
@@ -85,14 +85,14 @@ class BackgroundTask:
             if return_code == 0:
                 console.print("[bold green][+] Background task enabled.")
             else:
-                console.print("[bold red][!] Failed to enable background task.")
+                console.error("Failed to enable background task.")
         else:
             cmd = ["schtasks", "/delete", "/tn", WIN_BACKGROUND_TASK_NAME, "/f"]
             return_code = call(cmd, stdout=DEVNULL, stderr=DEVNULL)
             if return_code == 0:
                 console.print("[bold green][-] Background task disabled.")
             else:
-                console.print("[bold red][!] Failed to disable background task.")
+                console.error("Failed to disable background task.")
 
     @classmethod
     def toggle(cls, enabled: bool):

cs2tracker/scraper/discord_notifier.py

@@ -1,13 +1,13 @@
 import requests
 from requests.exceptions import RequestException
 
-from cs2tracker.util import PaddedConsole, PriceLogs
+from cs2tracker.util import PriceLogs, get_console
 
 DC_WEBHOOK_USERNAME = "CS2Tracker"
 DC_WEBHOOK_AVATAR_URL = "https://img.icons8.com/?size=100&id=uWQJp2tLXUH6&format=png&color=000000"
 DC_RECENT_HISTORY_LIMIT = 5
 
-console = PaddedConsole()
+console = get_console()
 
 
 class DiscordNotifier:
@@ -81,6 +81,6 @@ class DiscordNotifier:
             response.raise_for_status()
             console.print("[bold steel_blue3][+] Discord notification sent.\n")
         except RequestException as error:
-            console.print(f"[bold red][!] Failed to send Discord notification: {error}\n")
+            console.error(f"Failed to send Discord notification: {error}\n")
         except Exception as error:
-            console.print(f"[bold red][!] An unexpected error occurred: {error}\n")
+            console.error(f"An unexpected error occurred: {error}\n")

cs2tracker/scraper/parsers.py

@@ -0,0 +1,192 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from urllib.parse import unquote
+
+from bs4 import BeautifulSoup
+from bs4.element import Tag
+
+from cs2tracker.constants import CAPSULE_PAGES
+from cs2tracker.util import get_console
+from cs2tracker.util.validated_config import get_config
+
+config = get_config()
+console = get_console()
+
+
+class PriceSource(Enum):
+    STEAM = "steam"
+    BUFF163 = "buff163"
+    SKINPORT = "skinport"
+
+
+class Parser(ABC):
+    @classmethod
+    @abstractmethod
+    def get_item_page_url(cls, item_href, source=PriceSource.STEAM) -> str:
+        """
+        Convert an href of a Steam Community Market item to a Parser-specific market
+        page URL.
+
+        :param item_href: The href of the item listing, typically ending with the item's
+            name.
+        :return: A URL string for the Parser market page of the item.
+        """
+
+    @classmethod
+    @abstractmethod
+    def parse_item_price(cls, item_page, item_href, source=PriceSource.STEAM) -> float:
+        """
+        Parse the price of an item from the given Parser market page and steamcommunity
+        item href.
+
+        :param item_page: The HTTP response object containing the item page content.
+        :param item_href: The href of the item listing to find the price for.
+        :return: The price of the item as a float.
+        :raises ValueError: If the item listing or price span cannot be found.
+        """
+
+
+class SteamParser(Parser):
+    STEAM_MARKET_SEARCH_PAGE_BASE_URL = "https://steamcommunity.com/market/search?q={}"
+    PRICE_INFO = "Owned: {:<10}  {} price: ${:<10}  Total: ${:<10}"
+    NEEDS_TIMEOUT = True
+    SOURCES = [PriceSource.STEAM]
+
+    @classmethod
+    def get_item_page_url(cls, item_href, source=PriceSource.STEAM):
+        _ = source
+
+        # For higher efficiency we want to reuse the same page for sticker capsules (scraper uses caching)
+        # Therefore, if the provided item is a sticker capsule we return a search page defined in CAPSULE_PAGES
+        # where all of the sticker capsules of one section are listed
+        for section in config.sections():
+            if section in ("Custom Items", "Cases", "User Settings", "App Settings"):
+                continue
+            if any(item_href == option for option in config.options(section)):
+                return CAPSULE_PAGES[section]
+
+        url_encoded_name = item_href.split("/")[-1]
+        page_url = cls.STEAM_MARKET_SEARCH_PAGE_BASE_URL.format(url_encoded_name)
+
+        return page_url
+
+    @classmethod
+    def parse_item_price(cls, item_page, item_href, source=PriceSource.STEAM):
+        _ = source
+
+        item_soup = BeautifulSoup(item_page.content, "html.parser")
+        item_listing = item_soup.find("a", attrs={"href": f"{item_href}"})
+        if not isinstance(item_listing, Tag):
+            raise ValueError(f"Steam: Failed to find item listing for: {item_href}")
+
+        item_price_span = item_listing.find("span", attrs={"class": "normal_price"})
+        if not isinstance(item_price_span, Tag):
+            raise ValueError(f"Steam: Failed to find price span in item listing for: {item_href}")
+
+        price_str = item_price_span.text.split()[2]
+        price = float(price_str.replace("$", ""))
+
+        return price
+
+
+class SkinLedgerParser(Parser):
+    SKINLEDGER_PRICE_LIST = ""
+    PRICE_INFO = "Owned: {:<10}  {} price: ${:<10}  Total: ${:<10}"
+    NEEDS_TIMEOUT = False
+    SOURCES = [PriceSource.STEAM, PriceSource.BUFF163, PriceSource.SKINPORT]
+
+    @classmethod
+    def get_item_page_url(cls, item_href, source=PriceSource.STEAM) -> str:
+        _ = source
+        return super().get_item_page_url(item_href)
+
+    @classmethod
+    def parse_item_price(cls, item_page, item_href, source=PriceSource.STEAM) -> float:
+        _, _ = item_href, source
+        return super().parse_item_price(item_page, item_href)
+
+
+class ClashParser(Parser):
+    CLASH_ITEM_API_BASE_URL = "https://inventory.clash.gg/api/GetItemPrice?id={}"
+    PRICE_INFO = "Owned: {:<10}  {} price: ${:<10}  Total: ${:<10}"
+    NEEDS_TIMEOUT = True
+    SOURCES = [PriceSource.STEAM]
+
+    @classmethod
+    def get_item_page_url(cls, item_href, source=PriceSource.STEAM):
+        _ = source
+
+        url_encoded_name = item_href.split("/")[-1]
+        page_url = cls.CLASH_ITEM_API_BASE_URL.format(url_encoded_name)
+
+        return page_url
+
+    @classmethod
+    def parse_item_price(cls, item_page, item_href, source=PriceSource.STEAM):
+        _, _ = item_href, source
+
+        data = item_page.json()
+        if data.get("success", "false") == "false":
+            raise ValueError(f"Clash: Response failed for: {item_href}")
+
+        price = data.get("average_price", None)
+        if not price:
+            raise ValueError(f"Clash: Failed to find item price for: {item_href}")
+
+        price = float(price)
+
+        return price
+
+
+class CSGOTrader(Parser):
+    CSGOTRADER_PRICE_LIST = "https://prices.csgotrader.app/latest/{}.json"
+    PRICE_INFO = "Owned: {:<10}  {:<10}: ${:<10}  Total: ${:<10}"
+    NEEDS_TIMEOUT = False
+    SOURCES = [PriceSource.STEAM, PriceSource.BUFF163, PriceSource.SKINPORT]
+
+    @classmethod
+    def get_item_page_url(cls, item_href, source=PriceSource.STEAM):
+        _ = item_href
+
+        page_url = cls.CSGOTRADER_PRICE_LIST.format(source.value)
+
+        return page_url
+
+    @classmethod
+    def parse_item_price(cls, item_page, item_href, source=PriceSource.STEAM):
+        _ = source
+
+        price_list = item_page.json()
+
+        url_decoded_name = unquote(item_href.split("/")[-1])
+        if source in (PriceSource.BUFF163, PriceSource.SKINPORT):
+            url_decoded_name = url_decoded_name.replace("Holo-Foil", "Holo/Foil")
+
+        price_info = price_list.get(url_decoded_name, None)
+        if not price_info:
+            raise ValueError(f"CSGOTrader: Could not find item price info: {url_decoded_name}")
+
+        if source == PriceSource.STEAM:
+            price = price_info.get("last_24h")
+            if not price:
+                price = price_info.get("last_7d")
+                if not price:
+                    raise ValueError(
+                        f"CSGOTrader: Could not find steam price of the past 7 days: {url_decoded_name}"
+                    )
+        elif source == PriceSource.BUFF163:
+            price = price_info.get("starting_at")
+            if not price:
+                raise ValueError(f"CSGOTrader: Could not find buff163 listing: {url_decoded_name}")
+            price = price.get("price")
+            if not price:
+                raise ValueError(
+                    f"CSGOTrader: Could not find recent buff163 price: {url_decoded_name}"
+                )
+        else:
+            price = price_info.get("starting_at")
+            if not price:
+                raise ValueError(f"CSGOTrader: Could not find skinport listing: {url_decoded_name}")
+
+        price = float(price)
+        return price