tf2-sku-to-name 1.0.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

sku/__init__.py

@@ -0,0 +1,13 @@
+from sku.parser import Sku, get_schema
+from sku.models import itemClass
+from sku.schema import Schema
+
+__version__ = "2.0.0"
+__all__ = ["Sku", "itemClass", "Schema", "get_schema", "update_schema"]
+
+# Main functions
+object_to_sku = Sku.object_to_sku
+sku_to_object = Sku.sku_to_object
+sku_to_name = Sku.sku_to_name
+name_to_sku = Sku.name_to_sku
+update_schema = Sku.update_schema 

sku/parser.py

@@ -1,12 +1,18 @@
-from sku.models import itemClass as itemClass
+from sku.models import itemClass
+from sku.schema import Schema
 from typing import List
 from collections import deque
-import requests
-from bs4 import BeautifulSoup as bs
-import sqlite3
-import pkg_resources
+import re
 
-DB_FILE = pkg_resources.resource_filename(__name__, 'data/data.db')
+# Initialize schema (will load from cache or fetch from autobot.tf by default)
+_schema = None
+
+def get_schema(api_key=None, use_autobot=True):
+    """Get or initialize the schema instance"""
+    global _schema
+    if _schema is None:
+        _schema = Schema(api_key=api_key, use_autobot=use_autobot)
+    return _schema
 
 
 class Sku:
@@ -115,108 +121,529 @@ class Sku:
             item.OutputQuality = int(attr[2:])
 
     @staticmethod
-    def sku_to_name(sku: str) -> str:
-        json_data = Sku.get_json_data(sku=sku)
-        if json_data:
-            return json_data
-
-        req = requests.get(f"https://www.tf2autobot.com/items/{sku}")
-        title = bs(req.text, "html.parser").find("title").text
-
-        Sku.update_json_data(sku, title.lstrip())
-        return title.lstrip()
+    def sku_to_name(sku: str, proper_name: bool = True) -> str:
+        """Convert SKU to item name using the schema"""
+        item = Sku.sku_to_object(sku)
+        schema = get_schema()
+        
+        item_dict = {
+            'defindex': item.Defindex,
+            'quality': item.Quality,
+            'craftable': item.Craftable,
+            'australium': item.Australium,
+            'festive': item.Festive,
+            'killstreak': item.Killstreak,
+            'effect': item.Effect,
+            'paintkit': item.PaintKit,
+            'wear': item.Wear,
+            'quality2': item.ElevatedQuality,
+            'target': item.Target,
+            'craftnumber': item.CraftNum,
+            'crateseries': item.CrateSn,
+            'output': item.Output,
+            'outputQuality': item.OutputQuality,
+            'tradable': True,  # SKUs don't track tradability
+            'paint': None  # SKUs don't track paint
+        }
+        
+        name = schema.get_name(item_dict, proper_name)
+        if not name:
+            raise ValueError(f"Failed to get name from SKU: {sku}")
+        
+        return name
 
     @staticmethod
     def name_to_sku(name: str) -> str:
-        json_data = Sku.get_json_data(name=name)
-        if json_data:
-            return json_data
-
-        req = requests.get(f"https://www.tf2autobot.com/items/{name}")
-        title = bs(req.text, "html.parser").find("h3").text
-
-        Sku.update_json_data(title.lstrip(), name)
-        return title.lstrip()
-
+        schema = get_schema()
+        
+        # Convert name to lowercase for processing
+        name = name.strip()
+        name_lower = name.lower()
+        
+        # Initialize item dict
+        item = {
+            'defindex': None,
+            'quality': None,
+            'craftable': True,
+            'australium': False,
+            'festive': False,
+            'killstreak': 0,
+            'effect': None,
+            'paintkit': None,
+            'wear': None,
+            'quality2': None,
+            'target': None,
+            'craftnumber': None,
+            'crateseries': None,
+            'output': None,
+            'outputQuality': None,
+            'tradable': True,
+            'paint': None
+        }
+        
+        if any(x in name_lower for x in ['strange part:', 'strange cosmetic part:', 'strange filter:', 
+                                         'strange count transfer tool', 'strange bacon grease']):
+            schema_item = schema.get_item_by_item_name(name)
+            if schema_item:
+                item['defindex'] = schema_item['defindex']
+                item['quality'] = schema_item.get('item_quality', 6)
+                return Sku._dict_to_sku(item)
+        
+        # Process wear
+        wears = {
+            '(factory new)': 1,
+            '(minimal wear)': 2,
+            '(field-tested)': 3,
+            '(well-worn)': 4,
+            '(battle scarred)': 5
+        }
+        
+        for wear_text, wear_value in wears.items():
+            if wear_text in name_lower:
+                name_lower = name_lower.replace(wear_text, '').strip()
+                item['wear'] = wear_value
+                break
+        
+        if 'strange(e)' in name_lower:
+            item['quality2'] = 11
+            name_lower = name_lower.replace('strange(e)', '').strip()
+        
+        if 'strange' in name_lower:
+            item['quality'] = 11
+            name_lower = name_lower.replace('strange', '').strip()
+        
+        name_lower = name_lower.replace('uncraftable', 'non-craftable')
+        if 'non-craftable' in name_lower:
+            name_lower = name_lower.replace('non-craftable', '').strip()
+            item['craftable'] = False
+        
+        name_lower = name_lower.replace('untradeable', 'non-tradable').replace('untradable', 'non-tradable')
+        if 'non-tradable' in name_lower:
+            name_lower = name_lower.replace('non-tradable', '').strip()
+            item['tradable'] = False
+        
+        if 'unusualifier' in name_lower:
+            name_lower = name_lower.replace('unusual ', '').replace(' unusualifier', '').strip()
+            item['defindex'] = 9258
+            item['quality'] = 5
+            
+            schema_item = schema.get_item_by_item_name(name_lower)
+            if schema_item:
+                item['target'] = schema_item['defindex']
+            
+            return Sku._dict_to_sku(item)
+        
+        killstreaks = {
+            'professional killstreak': 3,
+            'specialized killstreak': 2,
+            'killstreak': 1
+        }
+        
+        for ks_text, ks_value in killstreaks.items():
+            if ks_text in name_lower:
+                name_lower = name_lower.replace(ks_text + ' ', '').strip()
+                item['killstreak'] = ks_value
+                break
+        
+        if 'australium' in name_lower and 'australium gold' not in name_lower:
+            name_lower = name_lower.replace('australium', '').strip()
+            item['australium'] = True
+        
+        if 'festivized' in name_lower and 'festivized formation' not in name_lower:
+            name_lower = name_lower.replace('festivized', '').strip()
+            item['festive'] = True
+        
+        exception = [
+            'haunted ghosts', 'haunted phantasm jr', 'haunted phantasm', 'haunted metal scrap',
+            'haunted hat', 'unusual cap', 'vintage tyrolean', 'vintage merryweather',
+            'haunted kraken', 'haunted forever!', 'haunted cremation', 'haunted wick'
+        ]
+        
+        quality_search = name_lower
+        for ex in exception:
+            if ex in name_lower:
+                quality_search = name_lower.replace(ex, '').strip()
+                break
+        
+        if quality_search not in exception:
+            for quality_name, quality_id in schema.qualities.items():
+                quality_lower = quality_name.lower()
+                
+                if quality_lower == "collector's" and "collector's" in quality_search and 'chemistry set' in quality_search:
+                    continue
+                
+                if quality_lower == 'community' and quality_search.startswith('community sparkle'):
+                    continue
+                
+                if quality_search.startswith(quality_lower):
+                    name_lower = name_lower.replace(quality_lower, '').strip()
+                    item['quality2'] = item['quality']
+                    item['quality'] = quality_id
+                    break
+        
+
+        effect_short_forms = {
+            'burning': 'Burning Flames',
+            'scorching': 'Scorching Flames',
+            'green energy': 'Green Energy',
+            'purple energy': 'Purple Energy',
+            'circling tf': 'Circling TF Logo',
+            'massed': 'Massed Flies',
+            'nuts': 'Nuts n\' Bolts',
+            'p fetti': 'Purple Confetti',
+            'g fetti': 'Green Confetti',
+            'haunted': 'Haunted Ghosts',
+            'green black hole': 'Green Black Hole',
+            'roboactive': 'Roboactive',
+            'sulph': 'Sulphurous',
+            'phos': 'Phosphorous',
+            'c&d': 'Circling Peace Sign',
+            'peace': 'Circling Peace Sign',
+            'logo': 'Circling TF Logo',
+            'hearts': 'Circling Heart',
+            'tf logo': 'Circling TF Logo',
+            'heart': 'Circling Heart',
+            'frostbite': 'Frostbite',
+            'scorching': 'Scorching Flames',
+            'plasma': 'Vivid Plasma',
+            'searing': 'Searing Plasma',
+            'miami': 'Miami Nights',
+            'disco': 'Disco Beat Down',
+            'phosph': 'Phosphorous',
+            'sulph': 'Sulphurous',
+            'memory': 'Memory Leak',
+            'overclocked': 'Overclocked',
+            'electrostatic': 'Electrostatic',
+            'harvest': 'Harvest Moon',
+            'bonzo': 'Bonzo The All-Gnawing',
+            'antifreeze': 'Anti-Freeze',
+            'arcana': 'Arcana',
+            'spellbound': 'Spellbound',
+        }
+        
+        for short_form, full_effect in effect_short_forms.items():
+            if short_form in name_lower:
+                for effect_name, effect_id in schema.effects.items():
+                    if effect_name == full_effect:
+                        name_lower = name_lower.replace(short_form, '').strip()
+                        item['effect'] = effect_id
+                        if item['quality'] != 5:
+                            item['quality2'] = item['quality'] or item['quality2']
+                            item['quality'] = 5
+                        break
+                if item['effect']:
+                    break
+        
+        if not item['effect']:
+            for effect_name, effect_id in schema.effects.items():
+                effect_lower = effect_name.lower()
+
+                if effect_lower == 'stardust' and 'starduster' in name_lower:
+                    if 'starduster' in name_lower.replace('stardust', ''):
+                        continue
+                
+                if effect_lower == 'showstopper' and 'taunt: ' not in name_lower and 'shred alert' not in name_lower:
+                    continue
+                
+                if effect_lower == 'smoking' and name_lower in ['smoking jacket', 'the smoking skid lid'] or 'smoking skid lid' in name_lower:
+                    if not name_lower.startswith('smoking smoking'):
+                        continue
+                
+                if effect_lower in ['haunted ghosts', 'pumpkin patch', 'stardust'] and item['wear']:
+                    continue
+                
+                if effect_lower == 'atomic' and ('subatomic' in name_lower or any(x in name_lower for x in ['bonk! atomic punch', 'atomic accolade'])):
+                    continue
+                
+                if effect_lower == 'spellbound' and ('taunt:' in name_lower or 'shred alert' in name_lower):
+                    continue
+                
+                if effect_lower == 'accursed' and 'accursed apparition' in name_lower:
+                    continue
+                
+                if effect_lower == 'haunted' and 'haunted kraken' in name_lower:
+                    continue
+                
+                if effect_lower == 'frostbite' and 'frostbite bonnet' in name_lower:
+                    continue
+                
+                if effect_lower == 'hot' and not item['wear']:
+                    continue
+                
+                if effect_lower == 'cool' and not item['wear']:
+                    continue
+                
+                if effect_lower in name_lower:
+                    name_lower = name_lower.replace(effect_lower, '').strip()
+                    item['effect'] = effect_id
+                    
+                    if effect_id == 4:  # Community Sparkle
+                        if not item['quality']:
+                            item['quality'] = 5
+                    elif item['quality'] != 5:
+                        item['quality2'] = item['quality'] or item['quality2']
+                        item['quality'] = 5
+                    
+                    break
+        
+        if item['wear']:
+            for paintkit_name, paintkit_id in schema.paintkits.items():
+                paintkit_lower = paintkit_name.lower()
+                
+                if 'mk.ii' in name_lower and 'mk.ii' not in paintkit_lower:
+                    continue
+                
+                if '(green)' in name_lower and '(green)' not in paintkit_lower:
+                    continue
+                
+                if 'chilly' in name_lower and 'chilly' not in paintkit_lower:
+                    continue
+                
+                if paintkit_lower in name_lower:
+                    name_lower = name_lower.replace(paintkit_lower, '').replace(' | ', '').strip()
+                    item['paintkit'] = paintkit_id
+                    
+                    if item['effect'] is not None:
+                        if item['quality'] == 5 and item['quality2'] == 11:
+                            if 'strange(e)' not in name.lower():
+                                item['quality'] = 11
+                                item['quality2'] = None
+                            else:
+                                item['quality'] = 15
+                        elif item['quality'] == 5 and not item['quality2']:
+                            item['quality'] = 15
+                    
+                    if not item['quality']:
+                        item['quality'] = 15
+                    
+                    break
+            
+            if 'war paint' not in name_lower and item['paintkit']:
+                Sku._handle_weapon_skins(name_lower, item, schema)
+        
+        if '(paint: ' in name_lower:
+            name_lower = name_lower.replace('(paint: ', '').replace(')', '').strip()
+            
+            paint_key = f"(paint: {name_lower})"
+            if paint_key in schema.PAINT_MAPPINGS:
+                item['paint'] = schema.PAINT_MAPPINGS[paint_key]
+                # Remove paint name from name_lower
+                for paint_name, paint_value in schema.paints.items():
+                    if paint_value == item['paint'] and paint_name.lower() in name_lower:
+                        name_lower = name_lower.replace(paint_name.lower(), '').strip()
+                        break
+
+        name_lower = Sku._process_special_items(name_lower, item, schema)
+        
+        name_lower = name_lower.replace(' series ', ' ').replace(' series#', ' #')
+        
+        if 'salvaged mann co. supply crate #' in name_lower:
+            item['crateseries'] = int(name_lower[32:])
+            item['defindex'] = 5068
+            item['quality'] = 6
+            return Sku._dict_to_sku(item)
+        
+        elif 'select reserve mann co. supply crate #' in name_lower:
+            item['defindex'] = 5660
+            item['crateseries'] = 60
+            item['quality'] = 6
+            return Sku._dict_to_sku(item)
+        
+        elif 'mann co. supply crate #' in name_lower:
+            crateseries = int(name_lower[23:])
+            
+            if crateseries in [1, 3, 7, 12, 13, 18, 19, 23, 26, 31, 34, 39, 43, 47, 54, 57, 75]:
+                item['defindex'] = 5022
+            elif crateseries in [2, 4, 8, 11, 14, 17, 20, 24, 27, 32, 37, 42, 44, 49, 56, 71, 76]:
+                item['defindex'] = 5041
+            elif crateseries in [5, 9, 10, 15, 16, 21, 25, 28, 29, 33, 38, 41, 45, 55, 59, 77]:
+                item['defindex'] = 5045
+            
+            item['crateseries'] = crateseries
+            item['quality'] = 6
+            return Sku._dict_to_sku(item)
+        
+        elif 'mann co. supply munition #' in name_lower:
+            crateseries = int(name_lower[26:])
+            item['defindex'] = schema.MUNITION_CRATES.get(crateseries)
+            item['crateseries'] = crateseries
+            item['quality'] = 6
+            return Sku._dict_to_sku(item)
+        
+        number = None
+        if '#' in name_lower:
+            match = re.search(r'#(\d+)', name_lower)
+            if match:
+                number = match.group(1)
+                name_lower = re.sub(r'#\d+', '', name_lower).strip()
+        
+        retired_key_names = [key['name'].lower() for key in schema.RETIRED_KEYS.values()]
+        if name_lower in retired_key_names:
+            for key in schema.RETIRED_KEYS.values():
+                if key['name'].lower() == name_lower:
+                    item['defindex'] = key['defindex']
+                    item['quality'] = item['quality'] or 6
+                    return Sku._dict_to_sku(item)
+        
+        schema_item = schema.get_item_by_item_name_with_the(name_lower)
+        if not schema_item:
+            raise ValueError(f"Failed to get SKU from name: {name}")
+        
+        item['defindex'] = schema_item['defindex']
+        item['quality'] = item['quality'] or schema_item.get('item_quality', 6)
+        
+        if item['quality'] == 1 and item['defindex'] in schema.EXCLUSIVE_GENUINE:
+            item['defindex'] = schema.EXCLUSIVE_GENUINE[item['defindex']]
+        
+        if schema_item.get('item_class') == 'supply_crate':
+            item['crateseries'] = schema.crate_series_list.get(item['defindex'])
+        elif number:
+            item['craftnumber'] = int(number)
+        
+        return Sku._dict_to_sku(item)
+    
     @staticmethod
-    def _create_tables_if_not_exist(conn):
-        cursor = conn.cursor()
-        # Create the "sku" and "name" tables if they don't exist
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS sku (
-                sku TEXT PRIMARY KEY,
-                name TEXT NOT NULL
-            )
-        """)
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS name (
-                name TEXT PRIMARY KEY,
-                sku TEXT NOT NULL
-            )
-        """)
-        conn.commit()
-
+    def _process_special_items(name_lower: str, item: dict, schema: Schema) -> str:
+
+        if 'kit fabricator' in name_lower and item['killstreak'] > 1:
+            name_lower = name_lower.replace('kit fabricator', '').strip()
+            item['defindex'] = 20003 if item['killstreak'] > 2 else 20002
+            
+            if name_lower:
+                schema_item = schema.get_item_by_item_name(name_lower)
+                if schema_item:
+                    item['target'] = schema_item['defindex']
+                    item['quality'] = item['quality'] or schema_item.get('item_quality', 6)
+            
+            if not item['quality']:
+                item['quality'] = 6
+            
+            item['output'] = 6526 if item['killstreak'] > 2 else 6523
+            item['outputQuality'] = 6
+        
+        elif (("collector's" not in name_lower or 'strangifier chemistry set' not in name_lower) and 
+              'chemistry set' in name_lower):
+            name_lower = name_lower.replace("collector's ", '').replace('chemistry set', '').strip()
+            
+            if 'festive' in name_lower and 'a rather festive tree' not in name_lower:
+                item['defindex'] = 20007
+            else:
+                item['defindex'] = 20006
+            
+            schema_item = schema.get_item_by_item_name(name_lower)
+            if schema_item:
+                item['output'] = schema_item['defindex']
+                item['outputQuality'] = 14
+                item['quality'] = item['quality'] or schema_item.get('item_quality', 6)
+        
+        elif 'strangifier chemistry set' in name_lower:
+            name_lower = name_lower.replace('strangifier chemistry set', '').strip()
+            
+            schema_item = schema.get_item_by_item_name(name_lower)
+            if schema_item:
+                item['defindex'] = 20000
+                item['target'] = schema_item['defindex']
+                item['quality'] = 6
+                item['output'] = 6522
+                item['outputQuality'] = 6
+        
+        elif 'strangifier' in name_lower:
+            name_lower = name_lower.replace('strangifier', '').strip()
+            item['defindex'] = 6522
+            
+            schema_item = schema.get_item_by_item_name(name_lower)
+            if schema_item:
+                item['target'] = schema_item['defindex']
+                item['quality'] = item['quality'] or schema_item.get('item_quality', 6)
+        
+        elif 'kit' in name_lower and item['killstreak']:
+            name_lower = name_lower.replace('kit', '').strip()
+            
+            if item['killstreak'] == 1:
+                item['defindex'] = 6527
+            elif item['killstreak'] == 2:
+                item['defindex'] = 6523
+            elif item['killstreak'] == 3:
+                item['defindex'] = 6526
+            
+            if name_lower:
+                schema_item = schema.get_item_by_item_name(name_lower)
+                if schema_item:
+                    item['target'] = schema_item['defindex']
+            
+            if not item['quality']:
+                item['quality'] = 6
+        
+        elif item['paintkit'] and 'war paint' in name_lower:
+            name_lower = f"Paintkit {item['paintkit']}"
+            if not item['quality']:
+                item['quality'] = 15
+            
+            for schema_item in schema.raw['schema']['items']:
+                if schema_item.get('name') == name_lower:
+                    item['defindex'] = schema_item['defindex']
+                    break
+        
+        return name_lower
+    
     @staticmethod
-    def get_json_data(sku: str = str(), name: str = str()) -> str:
-        conn = sqlite3.connect(DB_FILE)
-        Sku._create_tables_if_not_exist(conn)  # Ensure tables exist
-        cursor = conn.cursor()
-
-        if sku:
-            cursor.execute("SELECT name FROM sku WHERE sku=?", (sku,))
-            result = cursor.fetchone()
-            return result[0] if result else ""
-
-        if name:
-            cursor.execute("SELECT sku FROM name WHERE name=?", (name,))
-            result = cursor.fetchone()
-            return result[0] if result else ""
-
-        conn.close()
-        return ""
-
+    def _handle_weapon_skins(name_lower: str, item: dict, schema: Schema):
+        """Handle weapon skin defindex mapping"""
+        if 'pistol' in name_lower and item['paintkit'] in schema.PISTOL_SKINS:
+            item['defindex'] = schema.PISTOL_SKINS[item['paintkit']]
+        elif 'rocket launcher' in name_lower and item['paintkit'] in schema.ROCKET_LAUNCHER_SKINS:
+            item['defindex'] = schema.ROCKET_LAUNCHER_SKINS[item['paintkit']]
+        elif 'medi gun' in name_lower and item['paintkit'] in schema.MEDIGUN_SKINS:
+            item['defindex'] = schema.MEDIGUN_SKINS[item['paintkit']]
+        elif 'revolver' in name_lower and item['paintkit'] in schema.REVOLVER_SKINS:
+            item['defindex'] = schema.REVOLVER_SKINS[item['paintkit']]
+        elif 'stickybomb launcher' in name_lower and item['paintkit'] in schema.STICKYBOMB_SKINS:
+            item['defindex'] = schema.STICKYBOMB_SKINS[item['paintkit']]
+        elif 'sniper rifle' in name_lower and item['paintkit'] in schema.SNIPER_RIFLE_SKINS:
+            item['defindex'] = schema.SNIPER_RIFLE_SKINS[item['paintkit']]
+        elif 'flame thrower' in name_lower and item['paintkit'] in schema.FLAME_THROWER_SKINS:
+            item['defindex'] = schema.FLAME_THROWER_SKINS[item['paintkit']]
+        elif 'minigun' in name_lower and item['paintkit'] in schema.MINIGUN_SKINS:
+            item['defindex'] = schema.MINIGUN_SKINS[item['paintkit']]
+        elif 'scattergun' in name_lower and item['paintkit'] in schema.SCATTERGUN_SKINS:
+            item['defindex'] = schema.SCATTERGUN_SKINS[item['paintkit']]
+        elif 'shotgun' in name_lower and item['paintkit'] in schema.SHOTGUN_SKINS:
+            item['defindex'] = schema.SHOTGUN_SKINS[item['paintkit']]
+        elif 'smg' in name_lower and item['paintkit'] in schema.SMG_SKINS:
+            item['defindex'] = schema.SMG_SKINS[item['paintkit']]
+        elif 'grenade launcher' in name_lower and item['paintkit'] in schema.GRENADE_LAUNCHER_SKINS:
+            item['defindex'] = schema.GRENADE_LAUNCHER_SKINS[item['paintkit']]
+        elif 'wrench' in name_lower and item['paintkit'] in schema.WRENCH_SKINS:
+            item['defindex'] = schema.WRENCH_SKINS[item['paintkit']]
+        elif 'knife' in name_lower and item['paintkit'] in schema.KNIFE_SKINS:
+            item['defindex'] = schema.KNIFE_SKINS[item['paintkit']]
+    
     @staticmethod
-    def update_json_data(sku: str, name: str) -> None:
-        conn = sqlite3.connect(DB_FILE)
-        Sku._create_tables_if_not_exist(conn)  # Ensure tables exist
-        cursor = conn.cursor()
-
-        try:
-            cursor.execute("INSERT INTO sku (sku, name) VALUES (?, ?)", (sku, name))
-            cursor.execute("INSERT INTO name (name, sku) VALUES (?, ?)", (name, sku))
-        except sqlite3.IntegrityError:
-            # If the name already exists, update the corresponding sku instead of inserting
-            cursor.execute("UPDATE name SET sku=? WHERE name=?", (sku, name))
-
-        conn.commit()
-        conn.close()
-
+    def _dict_to_sku(item: dict) -> str:
+        """Convert item dict to SKU string"""
+        item_obj = itemClass()
+        item_obj.Defindex = item['defindex']
+        item_obj.Quality = item['quality']
+        item_obj.Craftable = item['craftable']
+        item_obj.Australium = item['australium']
+        item_obj.Festive = item['festive']
+        item_obj.Killstreak = item['killstreak']
+        item_obj.Effect = item['effect']
+        item_obj.PaintKit = item['paintkit']
+        item_obj.Wear = item['wear']
+        item_obj.ElevatedQuality = item['quality2']
+        item_obj.Target = item['target']
+        item_obj.CraftNum = item['craftnumber']
+        item_obj.CrateSn = item['crateseries']
+        item_obj.Output = item['output']
+        item_obj.OutputQuality = item['outputQuality']
+        
+        return Sku.object_to_sku(item_obj)
+    
     @staticmethod
-    def update_autobot_pricelist() -> None:
-        req = requests.get("https://autobot.tf/json/pricelist-array").json()
-
-        conn = sqlite3.connect(DB_FILE)
-        Sku._create_tables_if_not_exist(conn)  # Ensure tables exist
-        cursor = conn.cursor()
-
-        for item in req.get("items"):
-            name = item.get("name")
-            sku = item.get("sku")
-
-            # Check if the name already exists in the database
-            cursor.execute("SELECT sku FROM name WHERE name=?", (name,))
-            existing_sku = cursor.fetchone()
-
-            # If the name exists, update the existing entry
-            if existing_sku:
-                existing_sku = existing_sku[0]
-                if existing_sku != sku:
-                    # Update the SKU for the existing name
-                    cursor.execute("UPDATE name SET sku=? WHERE name=?", (sku, name))
-            else:
-                # If the name doesn't exist, insert a new entry
-                cursor.execute("INSERT OR IGNORE INTO name (name, sku) VALUES (?, ?)", (name, sku))
-                cursor.execute("INSERT OR IGNORE INTO sku (sku, name) VALUES (?, ?)", (sku, name))
-
-        conn.commit()
-        conn.close()
+    def update_schema(api_key: str = None, use_autobot: bool = True):
+        global _schema
+        cache_file = Schema.SCHEMA_CACHE_FILE
+        if cache_file.exists():
+            cache_file.unlink()
+        _schema = Schema(api_key=api_key, use_autobot=use_autobot)