cs2tracker 2.1.13__py3-none-any.whl → 2.1.15__py3-none-any.whl

cs2tracker/data/get_inventory.js

@@ -11,24 +11,35 @@ process.stderr.setEncoding("utf-8");
 
 const args = argv.slice(2);
 const processedInventoryPath = args[0];
-const importCases = args[1] === "True" ? true : false;
-const importStickerCapsules = args[2] === "True" ? true : false;
-const importStickers = args[3] === "True" ? true : false;
-const importOthers = args[4] === "True" ? true : false;
-const userName = args[5];
-const password = args[6];
-const twoFactorCode = args[7];
+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);
+  console.log(" [INFO] ", ...args);
 };
 
 const originalConsoleError = console.error;
 console.error = (...args) => {
-  originalConsoleError("    [!] " + args.join(" "));
+  originalConsoleError(" [ERROR] " + args.join(" "));
 };
 
 (async () => {
+  const closeWithError = (message) => {
+    console.error(message);
+    console.error("This window will automatically close in 10 seconds.");
+    setTimeout(() => {
+      user.logOff();
+      process.exit(1);
+    }, 10000);
+  };
+
   let user = new SteamUser();
 
   paddedLog("Logging into Steam...");
@@ -39,25 +50,36 @@ console.error = (...args) => {
     twoFactorCode: twoFactorCode,
   });
 
-  user.on("error", (err) => {
-    console.error("Steam Error: " + err);
-    user.logOff();
-    process.exit(1);
+  const LOGIN_TIMEOUT_MS = 15000;
+  let loginTimeout = setTimeout(() => {
+    closeWithError(
+      "Login timed out. Please check your credentials and try again.",
+    );
+  }, LOGIN_TIMEOUT_MS);
+
+  user.on("steamGuard", (_domain, _callback, lastCodeWrong) => {
+    if (lastCodeWrong) {
+      closeWithError(
+        "The Steam Guard code you entered was incorrect. Please try again.",
+      );
+    }
   });
 
   user.on("loggedOn", (_details, _parental) => {
+    clearTimeout(loginTimeout);
     paddedLog("Logged into Steam.");
     user.gamesPlayed([730]);
+    paddedLog("Connecting to CS2 Game Coordinator...");
   });
 
-  let cs2 = new CS2(user);
+  user.on("error", (err) => {
+    closeWithError(`Steam Error: ${err.message}`);
+  });
 
-  paddedLog("Connecting to CS2 Game Coordinator...");
+  let cs2 = new CS2(user);
 
   cs2.on("error", (err) => {
-    console.error("CS2 Error: " + err);
-    user.logOff();
-    process.exit(1);
+    closeWithError(`CS2 Error: ${err.message}`);
   });
 
   let nameConverter = new ItemNameConverter();
@@ -65,38 +87,77 @@ console.error = (...args) => {
 
   cs2.on("connectedToGC", async () => {
     paddedLog("Connected to CS2 Game Coordinator.");
-    await processInventory();
+    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);
   });
 
   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, false);
+        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}/${storageUnitIds.length}`,
+          `${filteredItems.length} items found in storage unit: ${unitIndex + 1}/${storageUnitIds.length}`,
         );
         console.log(itemCounts);
       }
-      paddedLog("Saving config...");
-      fs.writeFileSync(
-        processedInventoryPath,
-        JSON.stringify(finalItemCounts, null, 2),
-      );
-      paddedLog("Processing complete.");
-      paddedLog("You may close this window now.");
+      return finalItemCounts;
     } catch (err) {
-      console.error("An error occurred during processing:", err);
-    } finally {
-      user.logOff();
-      process.exit(0);
+      console.error("An error occurred while processing storage units:", err);
+      return {};
     }
   }
 
@@ -122,6 +183,9 @@ console.error = (...args) => {
   function filterItems(items) {
     let filteredItems = [];
     items.forEach((item) => {
+      if (!item.item_tradable) {
+        return;
+      }
       if (
         (item.item_type === "case" && importCases) ||
         (item.item_type === "sticker capsule" && importStickerCapsules) ||

cs2tracker/logs.py

@@ -0,0 +1,143 @@
+import csv
+from datetime import datetime
+
+from cs2tracker.config import get_config
+from cs2tracker.constants import OUTPUT_FILE
+from cs2tracker.scraper.parser import Parser
+from cs2tracker.util.currency_conversion import convert, to_symbol
+
+config = get_config()
+
+
+class PriceLogs:
+    @classmethod
+    def _append_latest_calculation(cls, date, usd_totals):
+        """Append the first price calculation of the day."""
+        with open(OUTPUT_FILE, "a", newline="", encoding="utf-8") as price_logs:
+            price_logs_writer = csv.writer(price_logs)
+            price_entries_today = [f"{usd_total:.2f}$" for usd_total in usd_totals]
+            price_logs_writer.writerow([date] + price_entries_today)
+
+    @classmethod
+    def _replace_latest_calculation(cls, date, usd_totals):
+        """Replace the last calculation of today with the most recent one of today."""
+        with open(OUTPUT_FILE, "r+", newline="", encoding="utf-8") as price_logs:
+            price_logs_reader = csv.reader(price_logs)
+            rows = list(price_logs_reader)
+            rows_without_today = rows[:-1]
+            price_logs.seek(0)
+            price_logs.truncate()
+
+            price_logs_writer = csv.writer(price_logs)
+            price_logs_writer.writerows(rows_without_today)
+            price_entries_today = [f"{usd_total:.2f}$" for usd_total in usd_totals]
+            price_logs_writer.writerow([date] + price_entries_today)
+
+    @classmethod
+    def save(cls, usd_totals):
+        """
+        Save the current date and total prices in USD to a CSV file.
+
+        This will append a new entry to the output file if no entry has been made for
+        today.
+
+        :param usd_totals: The total prices in USD to save.
+        :raises FileNotFoundError: If the output file does not exist.
+        :raises IOError: If there is an error writing to the output file.
+        """
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as price_logs:
+            price_logs_reader = csv.reader(price_logs)
+            rows = list(price_logs_reader)
+            last_log_date = rows[-1][0] if rows else ""
+
+        today = datetime.now().strftime("%Y-%m-%d")
+        if last_log_date != today:
+            cls._append_latest_calculation(today, usd_totals)
+        else:
+            cls._replace_latest_calculation(today, usd_totals)
+
+    @classmethod
+    def read(cls, newest_first=False, with_symbols=False):
+        """
+        Parse the output file to extract dates, dollar prices, and the converted
+        currency prices. This data is used for drawing the plot of past prices.
+
+        :param newest_first: If True, the dates and totals will be returned in reverse
+            order
+        :param with_symbols: If True, the prices will be formatted with currency symbols
+        :return: A tuple containing dates and a dictionary of totals for each price
+            source.
+        :raises FileNotFoundError: If the output file does not exist.
+        :raises IOError: If there is an error reading the output file.
+        """
+        conversion_currency = config.conversion_currency
+        dates = []
+        totals = {
+            price_source: {"USD": [], conversion_currency: []} for price_source in Parser.SOURCES
+        }
+
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as price_logs:
+            price_logs_reader = csv.reader(price_logs)
+            for row in price_logs_reader:
+                date, *usd_totals = row
+                date = datetime.strptime(date, "%Y-%m-%d")
+
+                usd_totals = [float(price_usd.rstrip("$")) for price_usd in usd_totals]
+                converted_totals = [
+                    convert(price_usd, "USD", conversion_currency) for price_usd in usd_totals
+                ]
+
+                dates.append(date)
+                for price_source_index, price_source in enumerate(Parser.SOURCES):
+                    totals[price_source]["USD"].append(usd_totals[price_source_index])
+                    totals[price_source][conversion_currency].append(
+                        converted_totals[price_source_index]
+                    )
+
+        if newest_first:
+            dates.reverse()
+            for price_source in Parser.SOURCES:
+                totals[price_source]["USD"].reverse()
+                totals[price_source][conversion_currency].reverse()
+
+        if with_symbols:
+            for price_source in Parser.SOURCES:
+                totals[price_source]["USD"] = [
+                    f"${price:.2f}" for price in totals[price_source]["USD"]
+                ]
+                totals[price_source][conversion_currency] = [
+                    f"{to_symbol(conversion_currency)}{price:.2f}"
+                    for price in totals[price_source][conversion_currency]
+                ]
+
+        return dates, totals
+
+    @classmethod
+    def validate_file(cls, log_file_path):
+        # pylint: disable=expression-not-assigned
+        """
+        Ensures that the provided price log file has the right format. This should be
+        used before importing a price log file to ensure it is valid.
+
+        :param log_file_path: The path to the price log file to validate.
+        :return: True if the price log file is valid, False otherwise.
+        """
+        try:
+            with open(log_file_path, "r", encoding="utf-8") as price_logs:
+                price_logs_reader = csv.reader(price_logs)
+                for row in price_logs_reader:
+                    date_str, *usd_totals = row
+                    datetime.strptime(date_str, "%Y-%m-%d")
+                    [float(price_usd.rstrip("$")) for price_usd in usd_totals]
+        except (FileNotFoundError, IOError, ValueError, TypeError):
+            return False
+        except Exception:
+            return False
+
+        return True
+
+    @classmethod
+    def empty(cls):
+        """Checks if the price history is empty and returns True if it is."""
+        with open(OUTPUT_FILE, "r", encoding="utf-8") as price_logs:
+            return len(list(price_logs)) == 0

cs2tracker/main.py

@@ -1,19 +1,11 @@
 import sys
-from subprocess import DEVNULL
 
 import urllib3
-from nodejs import npm
 
-from cs2tracker.app import Application
-from cs2tracker.constants import (
-    AUTHOR_STRING,
-    BANNER,
-    INVENTORY_IMPORT_SCRIPT_DEPENDENCIES,
-    OS,
-    OSType,
-)
-from cs2tracker.scraper import Scraper
-from cs2tracker.util import get_console
+from cs2tracker.app.app import Application
+from cs2tracker.constants import AUTHOR_STRING, BANNER, OS, OSType
+from cs2tracker.scraper.scraper import Scraper
+from cs2tracker.util.padded_console import get_console
 
 
 def main():
@@ -38,13 +30,6 @@ def main():
         scraper = Scraper()
         scraper.scrape_prices()
     else:
-        # Ensures that the necessary node modules are installed if a user wants
-        # to import their steam inventory via the cs2tracker/data/get_inventory.js Node.js script.
-        # This can be done in a daemon thread on application startup because it is not a very costly operation.
-        npm.Popen(
-            ["install"] + INVENTORY_IMPORT_SCRIPT_DEPENDENCIES, stdout=DEVNULL, stderr=DEVNULL
-        )
-
         application = Application()
         application.run()
 

cs2tracker/scraper/__init__.py

@@ -1,9 +0,0 @@
-from cs2tracker.scraper.background_task import (  # noqa: F401 # pylint:disable=unused-import
-    BackgroundTask,
-)
-from cs2tracker.scraper.discord_notifier import (  # noqa: F401 # pylint:disable=unused-import
-    DiscordNotifier,
-)
-from cs2tracker.scraper.scraper import (  # noqa: F401 # pylint:disable=unused-import
-    Scraper,
-)

cs2tracker/scraper/background_task.py

@@ -9,7 +9,7 @@ from cs2tracker.constants import (
     RUNNING_IN_EXE,
     OSType,
 )
-from cs2tracker.util import get_console
+from cs2tracker.util.padded_console import get_console
 
 WIN_BACKGROUND_TASK_NAME = "CS2Tracker Daily Calculation"
 WIN_BACKGROUND_TASK_SCHEDULE = "DAILY"

cs2tracker/scraper/discord_notifier.py

@@ -1,13 +1,16 @@
 import requests
 from requests.exceptions import RequestException
 
-from cs2tracker.util import PriceLogs, get_console
+from cs2tracker.config import get_config
+from cs2tracker.logs import PriceLogs
+from cs2tracker.util.padded_console import 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 = get_console()
+config = get_config()
 
 
 class DiscordNotifier:
@@ -19,42 +22,41 @@ class DiscordNotifier:
 
         :return: A list of embeds for the Discord message.
         """
-        dates, usd_prices, eur_prices = PriceLogs.read()
-        dates, usd_prices, eur_prices = reversed(dates), reversed(usd_prices), reversed(eur_prices)
+        dates, totals = PriceLogs.read(newest_first=True, with_symbols=True)
 
-        date_history, usd_history, eur_history = [], [], []
-        for date, usd_log, eur_log in zip(dates, usd_prices, eur_prices):
-            if len(date_history) >= DC_RECENT_HISTORY_LIMIT:
-                break
-            date_history.append(date.strftime("%Y-%m-%d"))
-            usd_history.append(f"${usd_log:.2f}")
-            eur_history.append(f"€{eur_log:.2f}")
-
-        date_history = "\n".join(date_history)
-        usd_history = "\n".join(usd_history)
-        eur_history = "\n".join(eur_history)
+        date_field = [
+            {
+                "name": "Date",
+                "value": "\n".join([date.strftime("%Y-%m-%d") for date in dates][:DC_RECENT_HISTORY_LIMIT]),  # type: ignore
+                "inline": True,
+            },
+        ]
+        price_fields = [
+            {
+                "name": f"{price_source.name.title()} (USD | {config.conversion_currency})",
+                "value": "\n".join(
+                    [
+                        f"{usd_total} | {converted_total}"
+                        for usd_total, converted_total in zip(
+                            totals[price_source]["USD"][:DC_RECENT_HISTORY_LIMIT],
+                            totals[price_source][config.conversion_currency][
+                                :DC_RECENT_HISTORY_LIMIT
+                            ],
+                        )
+                    ]
+                ),
+                "inline": True,
+            }
+            for price_source in totals
+        ][
+            :2
+        ]  # Limit to the first two price sources because Discord can only display 3 fields per line (Date + 2 Price Sources)
 
         embeds = [
             {
-                "title": "📊 Recent Price History",
+                "title": "📊 Recent Investment History",
                 "color": 5814783,
-                "fields": [
-                    {
-                        "name": "Date",
-                        "value": date_history,
-                        "inline": True,
-                    },
-                    {
-                        "name": "USD Total",
-                        "value": usd_history,
-                        "inline": True,
-                    },
-                    {
-                        "name": "EUR Total",
-                        "value": eur_history,
-                        "inline": True,
-                    },
-                ],
+                "fields": date_field + price_fields,
             }
         ]
 

cs2tracker/scraper/parser.py

@@ -0,0 +1,189 @@
+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.config import get_config
+from cs2tracker.constants import CAPSULE_PAGES
+from cs2tracker.util.padded_console import get_console
+
+config = get_config()
+console = get_console()
+
+
+class PriceSource(Enum):
+    STEAM = "steam"
+    BUFF163 = "buff163"
+    SKINPORT = "skinport"
+    YOUPIN898 = "youpin"
+    CSFLOAT = "csfloat"
+
+
+class BaseParser(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(BaseParser):
+    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 ("Skins", "Stickers", "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 ClashParser(BaseParser):
+    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 CSGOTraderParser(BaseParser):
+    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.YOUPIN898]
+
+    @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):
+        # pylint: disable=too-many-branches
+        _ = 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:
+            for timestamp in ("last_24h", "last_7d", "last_30d", "last_90d"):
+                price = price_info.get(timestamp)
+                if price:
+                    break
+            else:
+                raise ValueError(
+                    f"CSGOTrader: Could not find steam price info for the past 3 months: {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}"
+                )
+        elif source == PriceSource.YOUPIN898:
+            price = price_info
+            if not price:
+                raise ValueError(
+                    f"CSGOTrader: Could not find recent youpin898 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
+
+
+# Default parser used by the scraper
+Parser = CSGOTraderParser