tf2schema-py 0.4.4__tar.gz

tf2schema_py-0.4.4/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: tf2schema-py
+Version: 0.4.4
+Summary: A Python package to interact with the Team Fortress 2 Schema
+Home-page: https://github.com/Osc44r/tf2schema/
+Author: Osc44r
+Keywords: Team Fortress 2,TF2,Steam,Schema,API
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: httpx
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: pytest-asyncio
+Requires-Dist: fake-useragent
+Requires-Dist: vdf
+
+# tf2schema
+
+tf2schema is a Python package for interacting with the Team Fortress 2 (TF2) Schema. It provides an easy-to-use
+`SchemaManager` class that allows fetching, updating, and managing the TF2 Schema from Steam's API or from a local file.
+The package includes features such as automatic updates, file-based schema storage, and async support for better
+performance.
+
+The library builds on the work from [python-tf2-utilities](https://github.com/dixon2004/python-tf2-utilities) but
+extends it with additional features, including async fetch operations and more Pythonic naming conventions.
+
+## Features
+
+- Fetch the TF2 schema asynchronously from Steam's API or a local file.
+- Automatic schema updates (optional).
+- Pythonic snake_case naming for schema functions.
+- Integration with file-based schema management for environments where file-only mode is preferred.
+- Uses `httpx` for async HTTP requests.
+
+## Installation
+
+...coming soon...
+
+Make sure your environment has the following dependencies installed:
+
+- `httpx`
+- `python-dotenv`
+- `pytest`
+- `pytest-asyncio`
+
+## Usage
+
+Head to the [Examples](examples) directory for a quick start guide on how to use the `SchemaManager` & `Schema` classes.
+
+### Basic Example
+
+By default, when using the `async with` syntax, the `SchemaManager` will start the auto-update loop. If you prefer not
+to have auto-update enabled, you should manually call `fetch_schema` or `get` to fetch the schema.
+
+Here’s a basic example of how to use the `SchemaManager`:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    async with SchemaManager(
+            steam_api_key=steam_api_key,
+            file_path=Path(__file__).parent / "schema.json",
+            save_to_file=True
+    ) as manager:
+        # Wait until the schema is fetched
+        await manager.wait_for_schema()
+
+        # Get the name of an item from the schema using its SKU
+        sku = "30911;5;u144"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 30911;5;u144: Snowblinded Fat Man's Field Cap"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Disabling Auto-Update
+
+If you do **not** want auto-update to be enabled, you should avoid using `async with` to create the `SchemaManager`.
+Instead, create an instance and manually fetch the schema.
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    # Create the SchemaManager instance
+    manager = SchemaManager(
+        steam_api_key=steam_api_key,
+        file_path=Path(__file__).parent / "schema.json",
+        save_to_file=True
+    )
+
+    # Manually fetch the schema from Steam's API or file if it exists
+    await manager.get()
+
+    # Example: Get the name of an item from the schema using its SKU
+    sku = "160;3;u4"
+    item_name = manager.schema.get_name_from_sku(sku)
+    print(f"Item name for SKU {sku}: {item_name}")
+    # Expected output: "Item name for SKU 160;3;u4: Vintage Community Sparkle Lugermorph"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Auto-Updating Schema
+
+The `SchemaManager` supports an auto-update feature that checks for schema updates at regular intervals. If you want to
+enable the auto-update loop explicitly, you can do so with the `run` method:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    async with SchemaManager(
+            steam_api_key=steam_api_key,
+            file_path=Path(__file__).parent / "schema.json",
+            save_to_file=True,
+            update_interval=timedelta(hours=12)  # Update every 12 hours
+    ) as manager:
+        # The manager will automatically update the schema in the background
+        await manager.wait_for_schema()
+
+        # Example: Get the name for another item from the schema using its SKU
+        sku = "817;5;u13"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 817;5;u13: Burning Flames Human Cannonball"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### File-Only Mode
+
+If you want to use the package in environments where the schema should only be fetched from a file (e.g., in Docker
+containers), you can enable `file_only_mode`:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    async with SchemaManager(
+            file_path=Path(__file__).parent / "schema.json",
+            file_only_mode=True
+    ) as manager:
+        try:
+            await manager.wait_for_schema()
+        except FileNotFoundError:
+            print("Schema file not found. Please make sure it exists.")
+            return
+
+        # Example: Get the name of an item from the schema using its SKU
+        sku = "996;6"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 996;6: The Loose Cannon"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Running Tests
+
+To run the tests, you need to set the `STEAM_API_KEY` as an environment variable:
+
+1. Create a `.env` file with your Steam API key:
+
+    ```
+    STEAM_API_KEY=your_steam_api_key_here
+    ```
+
+2. Run the tests using `pytest`:
+
+    ```bash
+    pytest
+    ```
+
+The tests include checks for schema fetching, conversion from SKU to name, and vice versa.
+
+## Contributing
+
+If you'd like to contribute to this package, feel free to submit a pull request or open an issue. Contributions are
+always welcome!
+
+## License
+
+This project is licensed under the MIT License.

tf2schema_py-0.4.4/README.md

@@ -0,0 +1,196 @@
+# tf2schema
+
+tf2schema is a Python package for interacting with the Team Fortress 2 (TF2) Schema. It provides an easy-to-use
+`SchemaManager` class that allows fetching, updating, and managing the TF2 Schema from Steam's API or from a local file.
+The package includes features such as automatic updates, file-based schema storage, and async support for better
+performance.
+
+The library builds on the work from [python-tf2-utilities](https://github.com/dixon2004/python-tf2-utilities) but
+extends it with additional features, including async fetch operations and more Pythonic naming conventions.
+
+## Features
+
+- Fetch the TF2 schema asynchronously from Steam's API or a local file.
+- Automatic schema updates (optional).
+- Pythonic snake_case naming for schema functions.
+- Integration with file-based schema management for environments where file-only mode is preferred.
+- Uses `httpx` for async HTTP requests.
+
+## Installation
+
+...coming soon...
+
+Make sure your environment has the following dependencies installed:
+
+- `httpx`
+- `python-dotenv`
+- `pytest`
+- `pytest-asyncio`
+
+## Usage
+
+Head to the [Examples](examples) directory for a quick start guide on how to use the `SchemaManager` & `Schema` classes.
+
+### Basic Example
+
+By default, when using the `async with` syntax, the `SchemaManager` will start the auto-update loop. If you prefer not
+to have auto-update enabled, you should manually call `fetch_schema` or `get` to fetch the schema.
+
+Here’s a basic example of how to use the `SchemaManager`:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    async with SchemaManager(
+            steam_api_key=steam_api_key,
+            file_path=Path(__file__).parent / "schema.json",
+            save_to_file=True
+    ) as manager:
+        # Wait until the schema is fetched
+        await manager.wait_for_schema()
+
+        # Get the name of an item from the schema using its SKU
+        sku = "30911;5;u144"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 30911;5;u144: Snowblinded Fat Man's Field Cap"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Disabling Auto-Update
+
+If you do **not** want auto-update to be enabled, you should avoid using `async with` to create the `SchemaManager`.
+Instead, create an instance and manually fetch the schema.
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    # Create the SchemaManager instance
+    manager = SchemaManager(
+        steam_api_key=steam_api_key,
+        file_path=Path(__file__).parent / "schema.json",
+        save_to_file=True
+    )
+
+    # Manually fetch the schema from Steam's API or file if it exists
+    await manager.get()
+
+    # Example: Get the name of an item from the schema using its SKU
+    sku = "160;3;u4"
+    item_name = manager.schema.get_name_from_sku(sku)
+    print(f"Item name for SKU {sku}: {item_name}")
+    # Expected output: "Item name for SKU 160;3;u4: Vintage Community Sparkle Lugermorph"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Auto-Updating Schema
+
+The `SchemaManager` supports an auto-update feature that checks for schema updates at regular intervals. If you want to
+enable the auto-update loop explicitly, you can do so with the `run` method:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    steam_api_key = "YOUR_STEAM_API_KEY"
+
+    async with SchemaManager(
+            steam_api_key=steam_api_key,
+            file_path=Path(__file__).parent / "schema.json",
+            save_to_file=True,
+            update_interval=timedelta(hours=12)  # Update every 12 hours
+    ) as manager:
+        # The manager will automatically update the schema in the background
+        await manager.wait_for_schema()
+
+        # Example: Get the name for another item from the schema using its SKU
+        sku = "817;5;u13"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 817;5;u13: Burning Flames Human Cannonball"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### File-Only Mode
+
+If you want to use the package in environments where the schema should only be fetched from a file (e.g., in Docker
+containers), you can enable `file_only_mode`:
+
+```python
+import asyncio
+from tf2schema import SchemaManager
+from pathlib import Path
+
+
+async def main():
+    async with SchemaManager(
+            file_path=Path(__file__).parent / "schema.json",
+            file_only_mode=True
+    ) as manager:
+        try:
+            await manager.wait_for_schema()
+        except FileNotFoundError:
+            print("Schema file not found. Please make sure it exists.")
+            return
+
+        # Example: Get the name of an item from the schema using its SKU
+        sku = "996;6"
+        item_name = manager.schema.get_name_from_sku(sku)
+        print(f"Item name for SKU {sku}: {item_name}")
+        # Expected output: "Item name for SKU 996;6: The Loose Cannon"
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Running Tests
+
+To run the tests, you need to set the `STEAM_API_KEY` as an environment variable:
+
+1. Create a `.env` file with your Steam API key:
+
+    ```
+    STEAM_API_KEY=your_steam_api_key_here
+    ```
+
+2. Run the tests using `pytest`:
+
+    ```bash
+    pytest
+    ```
+
+The tests include checks for schema fetching, conversion from SKU to name, and vice versa.
+
+## Contributing
+
+If you'd like to contribute to this package, feel free to submit a pull request or open an issue. Contributions are
+always welcome!
+
+## License
+
+This project is licensed under the MIT License.

tf2schema_py-0.4.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tf2schema_py-0.4.4/setup.py

@@ -0,0 +1,38 @@
+import pathlib
+
+from setuptools import setup, find_packages
+
+path = pathlib.Path(__file__).parent
+
+README = (path / "README.md").read_text()
+
+setup(
+    name="tf2schema-py",
+    version="0.4.4",
+    description="A Python package to interact with the Team Fortress 2 Schema",
+    long_description=README,
+    long_description_content_type="text/markdown",
+    author="Osc44r",
+    url="https://github.com/Osc44r/tf2schema/",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    keywords=[
+        "Team Fortress 2",
+        "TF2",
+        "Steam",
+        "Schema",
+        "API",
+    ],
+    install_requires=[
+        "httpx",
+        "python-dotenv",
+        "pytest",
+        "pytest-asyncio",
+        "fake-useragent",
+        "vdf"
+    ]
+)

tf2schema_py-0.4.4/tests/conftest.py

@@ -0,0 +1,59 @@
+import asyncio
+import os
+
+import pytest
+import pytest_asyncio
+from dotenv import load_dotenv
+
+from tf2schema import SchemaManager
+
+
+@pytest.fixture(scope="session")
+def session():
+    """Load environment variables for the session."""
+    load_dotenv()
+    yield
+
+
+@pytest.fixture(scope="session")
+def steam_api_key(session):
+    """Get the Steam API key from the environment."""
+    key = os.getenv("STEAM_API_KEY")
+    if not key:
+        raise ValueError("STEAM_API_KEY is not set in the environment.")
+
+    return key
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create an asyncio event loop for the session."""
+    # Create a new event loop for the session
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    yield loop
+
+    loop.close()
+
+
+@pytest_asyncio.fixture(scope="session")
+async def schema_manager(steam_api_key, tmp_path_factory):
+    """Fixture to create and initialize the SchemaManager for testing."""
+    temp_dir = tmp_path_factory.mktemp("test_schema")
+    file_path = temp_dir / "schema.json"
+
+    # Initialize SchemaManager and use it as an async context manager
+    async with SchemaManager(
+            steam_api_key=steam_api_key,
+            file_path=file_path,
+            save_to_file=True,
+    ) as manager:
+        await manager.wait_for_schema(timeout=90)
+        yield manager
+
+
+@pytest.fixture(scope="session")
+def schema(schema_manager):
+    """Fixture to provide the fetched schema for the session."""
+    return schema_manager.schema

tf2schema_py-0.4.4/tests/test_schema.py

@@ -0,0 +1,47 @@
+from tf2schema import Schema
+
+DATA_SKUS_NAMES = {
+    "30911;5;u144": "Snowblinded Fat Man's Field Cap",
+    "30881;11": "Strange Croaking Hazard",
+    "9258;5;uncraftable;td-31154": "Non-Craftable Unusual Taunt: Time Out Therapy Unusualifier",
+    "341;5;u39": "Cauldron Bubbles A Rather Festive Tree",
+    "30114;5;u87": "Frostbite Valley Forge",
+    "199;15;w3;pk120": "Iron Wood Mk.II Shotgun (Field-Tested)",
+    "30609;5;u3108": "Festivized Formation Taunt: The Killer Solo",
+    "463;5;u3015": "Infernal Flames Taunt: The Schadenfreude",
+    "382;5;u35": "Smoking Big Country",
+    "996;6": "The Loose Cannon",
+    "817;5;u13": "Burning Flames Human Cannonball",
+    "30755;5;u263": "Forever And Forever! Berlin Brain Bowl",
+    "31374;6": "Hazard Handler",
+    "31374;3": "Vintage Hazard Handler",
+    "160;3;u4": "Vintage Community Sparkle Lugermorph",
+    "61;6;strange": "Strange Unique Ambassador",
+    "5778;9": "Self-Made Duck Token",
+    "267;5": "Unusual Haunted Metal Scrap",
+    "5009;3": "Vintage Class Token - Pyro",
+    "5020;6": "Name Tag"
+}
+
+
+def test_schema_creation(schema: Schema):
+    assert isinstance(schema, Schema), "Schema is not an instance of Schema."
+    assert schema.fetch_time, "Schema fetch time is not set."
+    assert schema.raw, "Schema raw data is not set."
+    assert schema.crate_series_list, "Schema crate series list is not set."
+    assert schema.munition_crates_list, "Schema munition crates list is not set."
+    assert schema.weapon_skins_list, "Schema weapon skins list is not set."
+    assert schema.qualities, "Schema qualities list is not set."
+    assert schema.effects, "Schema effects list is not set."
+    assert schema.paint_kits, "Schema paint kits list is not set."
+    assert schema.paints, "Schema paints list is not set."
+
+
+def test_sku_to_name(schema: Schema):
+    for sku, name in DATA_SKUS_NAMES.items():
+        assert schema.get_name_from_sku(sku) == name, f"SKU {sku} does not match name {name}"
+
+
+def test_name_to_sku(schema: Schema):
+    for sku, name in DATA_SKUS_NAMES.items():
+        assert schema.get_sku_from_name(name) == sku, f"Name {name} does not match SKU {sku}"

tf2schema_py-0.4.4/tests/test_schema_manager.py

@@ -0,0 +1,29 @@
+import pytest
+
+from tests.conftest import schema_manager
+from tf2schema import SchemaManager, Schema
+
+
+@pytest.mark.asyncio
+async def test_schema_fetching(schema_manager: SchemaManager):
+    assert schema_manager.has_schema, "Schema was not fetched."
+
+    schema = schema_manager.schema
+
+    assert isinstance(schema, Schema), "Schema is not an instance of Schema."
+    assert schema.fetch_time, "Schema fetch time is not set."
+    assert schema.raw, "Schema raw data is not set."
+
+
+@pytest.mark.asyncio
+async def test_get_schema_from_file(schema_manager):
+    new_manager = SchemaManager(
+        file_path=schema_manager.file_path,
+        file_only_mode=True
+    )
+
+    schema = new_manager.get_schema_from_file()
+
+    assert isinstance(schema, Schema), "Schema is not an instance of Schema."
+    assert schema.fetch_time, "Schema fetch time is not set."
+    assert schema.raw, "Schema raw data is not set."

tf2schema_py-0.4.4/tf2schema/__init__.py

@@ -0,0 +1,8 @@
+from . import sku
+from .schema import Schema, SchemaManager
+
+__all__ = [
+    "Schema",
+    "SchemaManager",
+    "sku"
+]

tf2schema_py-0.4.4/tf2schema/schema/__init__.py

@@ -0,0 +1,2 @@
+from .manager import SchemaManager
+from .schema import Schema