Merge pull request #19 from offish/v2.0.2

update trade data, prepare for stock

Author: offish

express/__init__.py

@@ -1,4 +1,4 @@
 __title__ = "tf2-express"
 __author__ = "offish"
 __license__ = "MIT"
-__version__ = "2.0.0"
+__version__ = "2.0.2"

express/database.py

@@ -24,6 +24,7 @@ def insert_trade(self, data: dict) -> None:
     def get_trades(
         self, start_index: int, amount: int
     ) -> tuple[list[dict], int, int, int]:
+        # sort newest trades first
         all_trades = list(self.trades.find().sort("time_updated", -1))
         total = len(all_trades)
         intended_end_index = start_index + amount
@@ -65,6 +66,33 @@ def get_item(self, sku: str) -> dict | None:
     def get_pricelist(self) -> list[dict]:
         return self.items.find()
 
+    def get_stock(self, sku: str) -> list[int, int]:
+        """returns in_stock, max_stock"""
+        data = self.__get_data(sku)
+
+        return (data.get("in_stock", 0), data.get("max_stock", 0))
+
+    def replace_item(self, data: dict) -> None:
+        self.items.replace_one({"sku": data["sku"]}, data)
+
+    def update_stocks(self, stock: dict) -> None:
+        all_items = self.items.find()
+
+        for item in all_items:
+            sku = item["sku"]
+
+            if sku not in stock:
+                continue
+
+            in_stock = stock[sku]
+
+            # in_stock is the same, no need to update
+            if item.get("in_stock", 0) == in_stock:
+                continue
+
+            item["in_stock"] = in_stock
+            self.replace_item(item)
+
     def add_price(self, sku: str, color: str, image: str, name: str) -> None:
         self.items.insert_one(
             {

express/express.py

@@ -1,14 +1,23 @@
+from .inventory import get_inventory_stock
 from .database import Database
 from .options import Options
-from .offer import valuate
+from .offer import valuate, OfferData
 
+from dataclasses import asdict
 from json import dumps
 import logging
 import time
 
 from steampy.exceptions import InvalidCredentials
 from steampy.client import SteamClient
-from tf2_utils import Offer, to_refined, refinedify, PricesTF
+from tf2_utils import (
+    Offer,
+    Inventory,
+    PricesTF,
+    to_refined,
+    refinedify,
+    account_id_to_steam_id,
+)
 
 
 class Express:
@@ -21,15 +30,17 @@ def __init__(self, bot: dict, options: Options) -> None:
         self.client = SteamClient(bot["api_key"])
         self.db = Database(options.database)
         self.pricer = PricesTF()
+        self.inventory = Inventory("steamcommunity")  # use apikey?
 
-        # TODO: make processed and values into offers list[Offer]
-        self.values = {}
-        self.processed = []
+        self.stock = {}
+        self.processed: list[OfferData] = []
         self.last_offer_fetch = 0
         self.options = options
 
         self.is_enabled = True
-        # TODO: add processed_offers, accepted_offers, active_offers for status
+        self.active_offers = 0
+        self.processed_offers = 0
+        self.accepted_offers = 0
 
         self.prices_to_check = []
 
@@ -90,7 +101,7 @@ def __get_offers(self) -> list[dict]:
                 "trade_offers_received"
             ]
         except Exception as e:
-            logging.error(f"Did not get wanted response when getting offers: {e}")
+            logging.error(f"{e}")
             return [{}]
 
     def __get_offer(self, offer_id: str) -> dict:
@@ -126,17 +137,24 @@ def __process_offer(self, offer: dict) -> None:
         if not offer_id:
             return
 
-        if offer_id in self.processed:
+        for offer_data in self.processed:
+            if offer_id != offer_data.offer_id:
+                continue
+
             logging.debug(f"({offer_id}) has already been processed")
             return
 
         self.__log_trade("Processing offer", offer_id)
 
         # we assume we wont crash, add to processed now
         # so if we return early, we wont process again
-        self.processed.append(offer_id)
+        offer_data = OfferData(offer_id)
+        self.processed.append(offer_data)
         logging.debug(f"Added offer {offer_id} to processed list")
 
+        self.active_offers += 1
+        self.processed_offers += 1
+
         trade = Offer(offer)
 
         if not trade.is_active():
@@ -153,10 +171,13 @@ def __process_offer(self, offer: dict) -> None:
         their_items = offer["items_to_receive"]
         our_items = offer["items_to_give"]
 
-        self.values[offer_id] = {
-            "their_items": their_items,
-            "our_items": our_items,
-        }
+        # add offer data
+        offer_data.message = offer["message"]
+        offer_data.steam_id_other = account_id_to_steam_id(offer["accountid_other"])
+        offer_data.time_created = offer["time_created"]
+        offer_data.time_updated = offer["time_updated"]
+        offer_data.their_items = their_items
+        offer_data.our_items = our_items
 
         # is owner
         if partner_steam_id in self.options.owners:
@@ -188,6 +209,10 @@ def __process_offer(self, offer: dict) -> None:
             # get mann co key buy and sell price
             key_prices = self.db.get_item("5021;6")
 
+            # TODO: handle if in_stock + new items would
+            # surpass max_stock. -100;6 is edge case
+            # max_stock = -1 is unlimited
+
             # we dont care about unpriced items on their side
             their_value, _ = valuate(
                 self.db, their_items, "buy", all_skus, key_prices, self.options
@@ -213,8 +238,9 @@ def __process_offer(self, offer: dict) -> None:
                 )
             )
 
-            self.values[offer_id]["our_value"] = our_value
-            self.values[offer_id]["their_value"] = their_value
+            offer_data.their_value = their_value
+            offer_data.our_value = our_value
+            offer_data.has_unpriced = has_unpriced
 
             self.__log_trade(summary)
 
@@ -244,52 +270,45 @@ def __process_offers(self) -> None:
             logging.info("No new offers available")
             return
 
-        logging.info(f"Processing {amount} offers")
+        # logging.info(f"Processing {amount} offers")
 
         for offer in offers:
             self.__process_offer(offer)
 
     def __update_offer_states(self) -> None:
-        active_offers = 0
+        if self.active_offers:
+            logging.info(f"{self.active_offers} offer(s) are still active")
 
-        for offer_id in self.processed:
-            offer = self.__get_offer(offer_id)
+        for offer_data in self.processed.copy():
+            offer = self.__get_offer(offer_data.offer_id)
             trade = Offer(offer)
 
+            offer_data.state = trade.get_state()
+
             if trade.is_active():
-                active_offers += 1
                 continue
 
-            if not trade.is_active():
-                self.__log_trade(
-                    f"Offer state changed to {trade.get_state()}", offer_id
-                )
-                # we have processed the offer if its not active anymore
-                self.processed.remove(offer_id)
+            self.active_offers -= 1
+
+            self.__log_trade(
+                f"Offer state changed to {trade.get_state()}", offer_data.offer_id
+            )
 
             if trade.is_accepted():
+                self.accepted_offers += 1
+
+                # TODO: increment in_stock, -100;6 edge case
+
                 if self.options.save_trades:
                     logging.info("Saving offer data...")
 
-                    if offer_id in self.values:
-                        offer["their_items"] = self.values[offer_id]["their_items"]
-                        offer["our_items"] = self.values[offer_id]["our_items"]
-                        offer["our_value"] = self.values[offer_id].get("our_value", 0.0)
-                        offer["their_value"] = self.values[offer_id].get(
-                            "their_value", 0.0
-                        )
-
                     if offer.get("tradeid") and self.options.save_receipt:
-                        offer["receipt"] = self.__get_receipt(offer["tradeid"])
+                        offer_data.receipt = self.__get_receipt(offer["tradeid"])
 
-                    self.db.insert_trade(offer)
+                    self.db.insert_trade(asdict(offer_data))
                     logging.info("Offer was added to the database")
 
-            if offer_id in self.values:
-                self.values.pop(offer_id)
-
-        if active_offers:
-            logging.info(f"{active_offers} offer(s) are still active")
+            self.processed.remove(offer_data)
 
     def __append_autopriced_items(self) -> None:
         autopriced_items = self.db.get_autopriced()
@@ -308,6 +327,13 @@ def run(self) -> None:
         self.__append_autopriced_items()
         self.__update_prices()
 
+        inventory = self.inventory.fetch(self.steam_id)
+        self.stock = get_inventory_stock(inventory)
+
+        self.db.update_stocks(self.stock)
+
+        del inventory
+
         while True:
             # bot is disabled
             if not self.is_enabled:

express/inventory.py

@@ -0,0 +1,19 @@
+from tf2_utils import map_inventory
+
+
+def get_inventory_stock(inventory: dict) -> dict:
+    # {sku: amount}
+    stock = {}
+
+    for item in map_inventory(inventory, True):
+        sku = item["sku"]
+
+        if item["tradable"] != True:
+            continue
+
+        if sku not in stock:
+            stock[sku] = 1
+        else:
+            stock[sku] += 1
+
+    return stock

express/offer.py

@@ -2,11 +2,28 @@
 from .options import Options
 from .items import Item
 
+from dataclasses import dataclass, field
 import logging
 
 from tf2_utils import get_sku, to_scrap
 
 
+@dataclass
+class OfferData:
+    offer_id: str
+    steam_id_other: str = ""
+    message: str = ""
+    time_created: int = 0
+    time_updated: int = 0
+    their_items: dict = field(default_factory=dict)
+    our_items: dict = field(default_factory=dict)
+    our_value: float = 0.0
+    their_value: float = 0.0
+    state: str = "Processed"
+    has_unpriced: bool = True
+    receipt: dict = field(default_factory=dict)
+
+
 def valuate(
     db: Database,
     items: dict,

express/utils.py

@@ -34,6 +34,7 @@ def summarize_trades(trades: list[dict]) -> list[dict]:
         their_items_summary = summarize_items(trade.get("their_items", []))
         our_items_summary = summarize_items(trade.get("our_items", []))
 
+        # add this to the db so it does not need to be done again?
         summary.append(
             {
                 **trade,

templates/trades.html

@@ -20,10 +20,15 @@ <h1>Trades</h1>
 {% for trade in trades %}
 <div>
     <br><br>
-    <h2>Trade #{{ trade.tradeofferid }}</h2>
+    <h2>Offer #{{ trade.offer_id }}</h2>
     {% if trade.message %}
     <p>Message: {{ trade.message }}</p>
     {% endif %}
+    <ul>
+        <li><a href="https://steamcommunity.com/profiles/{{ trade.steam_id_other }}">Steam Profile</a></li>
+        <li><a href="https://backpack.tf/profiles/{{ trade.steam_id_other }}">BackpackTF</a></li>
+        <li><a href="https://rep.tf/{{ trade.steam_id_other }}">RepTF</a></li>
+    </ul>
     <p>Created: {{ trade.time_created }}</p>
     <p>Accepted: {{ trade.time_updated }}</p>