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

cs2tracker/data/convert_inventory.js

@@ -0,0 +1,187 @@
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+const VDF = require("@node-steam/vdf");
+
+const translationsLink =
+  "https://raw.githubusercontent.com/SteamDatabase/GameTracking-CS2/master/game/csgo/pak01_dir/resource/csgo_english.txt";
+const itemsGameLink =
+  "https://raw.githubusercontent.com/SteamDatabase/GameTracking-CS2/master/game/csgo/pak01_dir/scripts/items/items_game.txt";
+
+const translationsCacheFile = path.join(__dirname, "translations.json");
+const itemsCacheFile = path.join(__dirname, "items.json");
+
+class ItemNameConverter {
+  constructor() {
+    this.translations = {};
+    this.items = {};
+    this.prefabs = {};
+    this.paintKits = {};
+    this.stickerKits = {};
+  }
+
+  async initialize() {
+    await Promise.all([this.loadTranslations(), this.loadItemsGame()]);
+  }
+
+  async loadTranslations() {
+    if (
+      fs.existsSync(translationsCacheFile) &&
+      fs.statSync(translationsCacheFile).mtime.getDate() ===
+        new Date().getDate()
+    ) {
+      this.translations = require(translationsCacheFile);
+      return;
+    }
+
+    const res = await axios.get(translationsLink);
+    const lines = res.data.split(/\n/);
+    for (const line of lines) {
+      const match = line.match(/"(.+?)"\s+"(.+?)"/);
+      if (match) {
+        this.translations[match[1].toLowerCase()] = match[2];
+      }
+    }
+
+    fs.writeFileSync(
+      translationsCacheFile,
+      JSON.stringify(this.translations, null, 2),
+    );
+  }
+
+  async loadItemsGame() {
+    if (
+      fs.existsSync(itemsCacheFile) &&
+      fs.statSync(itemsCacheFile).mtime.getDate() === new Date().getDate()
+    ) {
+      this.items = require(itemsCacheFile).items;
+      this.prefabs = require(itemsCacheFile).prefabs;
+      this.paintKits = require(itemsCacheFile).paint_kits;
+      this.stickerKits = require(itemsCacheFile).sticker_kits;
+      return;
+    }
+
+    const res = await axios.get(itemsGameLink);
+    const parsed = VDF.parse(res.data).items_game;
+    this.items = parsed.items;
+    this.prefabs = parsed.prefabs;
+    this.paintKits = parsed.paint_kits;
+    this.stickerKits = parsed.sticker_kits;
+
+    fs.writeFileSync(itemsCacheFile, JSON.stringify(parsed, null, 2));
+  }
+
+  translate(key) {
+    if (!key) return "";
+    return this.translations[key.replace("#", "").toLowerCase()] || key;
+  }
+
+  getItemName(item) {
+    const def = this.items[item.def_index];
+    if (!def) return "";
+
+    let baseName = "";
+    if (def.item_name) {
+      baseName = this.translate(def.item_name);
+    } else if (def.prefab && this.prefabs[def.prefab]) {
+      baseName = this.translate(this.prefabs[def.prefab].item_name);
+    }
+
+    let stickerName = "";
+    if (baseName === "Sticker" && item.stickers && item.stickers.length === 1) {
+      stickerName = this.translate(
+        this.stickerKits[String(item.stickers[0].sticker_id)].item_name,
+      );
+    }
+
+    let skinName = "";
+    if (item.paint_index && this.paintKits[item.paint_index]) {
+      skinName = this.translate(
+        this.paintKits[item.paint_index].description_tag,
+      );
+    }
+
+    let wear = "";
+    if (item.paint_wear !== undefined) {
+      wear = this.getWearName(item.paint_wear);
+    }
+
+    // It is a knife / glove
+    if (item.quality === 3) {
+      baseName = "★ " + baseName;
+    }
+
+    // It is a stattrak or souvenir item
+    if (item.attribute && item.attribute.length > 0) {
+      for (let [_attributeName, attributeValue] of Object.entries(
+        item.attribute,
+      )) {
+        switch (attributeValue.def_index) {
+          case 80:
+            baseName = baseName.includes("StatTrak™")
+              ? baseName
+              : "StatTrak™ " + baseName;
+            break;
+          case 140:
+            baseName = baseName.includes("Souvenir")
+              ? baseName
+              : "Souvenir " + baseName;
+            break;
+        }
+      }
+    }
+
+    if (baseName && skinName) {
+      return `${baseName} | ${skinName}${wear ? ` (${wear})` : ""}`;
+    } else if (baseName && stickerName) {
+      return `${baseName} | ${stickerName}`;
+    }
+
+    return baseName;
+  }
+
+  getWearName(paintWear) {
+    const wearLevels = [
+      { max: 0.07, name: "Factory New" },
+      { max: 0.15, name: "Minimal Wear" },
+      { max: 0.38, name: "Field-Tested" },
+      { max: 0.45, name: "Well-Worn" },
+      { max: 1, name: "Battle-Scarred" },
+    ];
+    return wearLevels.find((w) => paintWear <= w.max)?.name || "";
+  }
+
+  getItemType(item) {
+    const def = this.items[item.def_index];
+    if (!def) return "unknown";
+
+    if (def.item_name) {
+      let translatedName =
+        def.item_name.replace("#", "").toLowerCase() || def.item_name;
+      if (
+        translatedName.includes("crate_sticker_pack") ||
+        translatedName.includes("crate_signature_pack")
+      ) {
+        return "sticker capsule";
+      } else if (translatedName.includes("crate_community")) {
+        return "case";
+      } else if (translatedName.includes("csgo_tool_spray")) {
+        return "graffiti kit";
+      } else if (translatedName.includes("csgo_tool_sticker")) {
+        return "sticker";
+      }
+    }
+
+    return "other";
+  }
+
+  convertInventory(inventoryList) {
+    return inventoryList.map((item) => ({
+      ...item,
+      item_name: this.getItemName(item),
+      item_type: this.getItemType(item),
+    }));
+  }
+}
+
+module.exports = ItemNameConverter;

cs2tracker/data/get_inventory.js

@@ -0,0 +1,148 @@
+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 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 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.");
+    await processInventory();
+  });
+
+  async function processInventory() {
+    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 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}`,
+        );
+        console.log(itemCounts);
+      }
+      paddedLog("Saving config...");
+      fs.writeFileSync(
+        processedInventoryPath,
+        JSON.stringify(finalItemCounts, null, 2),
+      );
+      paddedLog("Processing complete.");
+      paddedLog("You may close this window now.");
+    } catch (err) {
+      console.error("An error occurred during processing:", err);
+    } finally {
+      user.logOff();
+      process.exit(0);
+    }
+  }
+
+  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

@@ -1,11 +1,19 @@
 import sys
+from subprocess import DEVNULL
 
 import urllib3
+from nodejs import npm
 
 from cs2tracker.app import Application
-from cs2tracker.constants import AUTHOR_STRING, BANNER, OS, OSType
+from cs2tracker.constants import (
+    AUTHOR_STRING,
+    BANNER,
+    INVENTORY_IMPORT_SCRIPT_DEPENDENCIES,
+    OS,
+    OSType,
+)
 from cs2tracker.scraper import Scraper
-from cs2tracker.util import PaddedConsole
+from cs2tracker.util import get_console
 
 
 def main():
@@ -23,13 +31,20 @@ 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:
         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/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")