mrkts 0.2.0__tar.gz

mrkts-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aiofake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mrkts-0.2.0/PKG-INFO

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: mrkts
+Version: 0.2.0
+Summary: Asynchronous Python client for the MRKT API
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/aiofake/mrkts
+Project-URL: Repository, https://github.com/aiofake/mrkts
+Project-URL: Issues, https://github.com/aiofake/mrkts/issues
+Keywords: telegram,markets,sdk,mrkt
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: kurigram
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# MRKT Python Client
+
+An asynchronous Python library for the [MRKT](https://t.me/mrkt) API.
+`MrktClient` provides the main transport, while the API is organized into
+separate Market, Steam, and User classes. These API classes can be used with
+the main client or directly with a custom HTTP transport.
+
+## Features
+
+- Access token and Telegram session authentication
+- Market methods for gifts, orders, and offers
+- Steam methods, including CS2
+- User profile, balance, and transaction methods
+- Raw requests through the available HTTP session
+- Concurrent multi-account operations with `MrktPool`
+
+## Installation
+
+Python 3.10 or newer is required.
+
+```bash
+python -m pip install mrkts
+```
+
+The importable module is named `mrkts`.
+
+## Quick Start
+
+The client and its API modules are asynchronous. Provide an access token and
+list the modules you need in `preload`:
+
+```python
+import asyncio
+
+from mrkts import MrktClient
+
+
+async def main() -> None:
+    async with MrktClient(
+        token="YOUR_ACCESS_TOKEN",
+        preload=("market", "user"),
+    ) as client:
+        gifts = await client.market.gifts.collections()
+        profile = await client.user.me()
+        print(gifts)
+        print(profile)
+
+
+asyncio.run(main())
+```
+
+`preload` is empty by default. Available values are `"market"`, `"steam"`, and
+`"user"`. Use `client.steam` for Steam methods; CS2 methods are available under
+`client.steam.cs2`, for example `client.steam.cs2.skins`.
+
+The HTTP session is created when entering `async with` or calling
+`await client.start()`, and is closed when exiting the context. If you do not
+use the context manager, make sure to call `await client.close()`.
+
+## Authentication
+
+### Access Token
+
+```python
+async with MrktClient(
+    token="YOUR_ACCESS_TOKEN",
+    preload=("market",),
+) as client:
+    listings = await client.market.gifts.saling(count=10)
+```
+
+### Telegram Session
+
+To authenticate with a Telegram session, install the project dependencies and
+provide the session name and the directory containing the session files:
+
+```python
+import asyncio
+
+from mrkts import MrktClient
+
+
+async def main() -> None:
+    client = await MrktClient.session(
+        "my_telegram_session",
+        workdir=".",
+        preload=("user",),
+    )
+    async with client:
+        print(await client.user.me())
+
+
+asyncio.run(main())
+```
+
+## API Methods
+
+### Market
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN", preload=("market",)) as client:
+    collections = await client.market.gifts.collections()
+    listings = await client.market.gifts.saling(
+        collectionNames=["Plush Pepe"],
+        count=20,
+        ordering="Price",
+        lowToHigh=True,
+    )
+    inventory = await client.market.gifts.inventory(isListed=False, count=20)
+    orders = await client.market.orders.list(
+        collectionNames=["Plush Pepe"],
+        count=10,
+    )
+    activities = await client.market.offers.activities(count=20)
+```
+
+`client.market` provides `gifts`, `orders`, and `offers`. Gift methods include
+`collections`, `models`, `backdrops`, `saling`, `inventory`, `history`, `feed`,
+`buy`, and `sale`.
+
+### User
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN", preload=("user",)) as client:
+    profile = await client.user.me()
+    balance = await client.user.balance()
+    transactions = await client.user.transactions()
+```
+
+### Steam / CS2
+
+```python
+async with MrktClient(
+    token="YOUR_ACCESS_TOKEN",
+    preload=("steam", "user"),
+) as client:
+    steam_link = await client.steam.connect()
+    is_connected = await client.steam.connected
+    # Use client.steam.cs2.skins to query the CS2 catalog.
+```
+
+## Raw HTTP Requests
+
+After `MrktClient` starts, its `http` attribute is an `aiohttp.ClientSession`
+configured with the API base URL and authentication headers. Use it to call
+endpoints that are not yet covered by the library's API methods:
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN") as client:
+    response = await client.http.get("gifts/collections")
+    response.raise_for_status()
+    collections = await response.json()
+    print(collections)
+```
+
+For POST requests, pass the request body through `json`:
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN") as client:
+    response = await client.http.post(
+        "gifts/saling",
+        json={"count": 10, "collectionNames": ["Plush Pepe"]},
+    )
+    response.raise_for_status()
+    listings = await response.json()
+```
+
+Pass paths relative to the client's base URL:
+`https://api.tgmrkt.io/api/v1/`. Raw requests should also be made inside the
+client context so that the HTTP session has been initialized.
+
+## Using API Classes Without `preload` or `MrktClient`
+
+With this approach, you are responsible for the base URL, authentication
+headers, and closing the HTTP session. To use the built-in authentication and
+transport while still creating API classes independently of `preload`, pass
+an instance of `MrktClient` to them:
+
+```python
+from mrkts import MrktClient
+from mrkts.market.gifts import Gifts
+
+
+async def main() -> None:
+    async with MrktClient(token="YOUR_ACCESS_TOKEN") as transport:
+        gifts = Gifts(transport)
+        print(await gifts.collections())
+```
+
+## Multiple Accounts
+
+`MrktPool` runs one coroutine for each client in the pool. Open each client
+with `async with` inside the callback:
+
+```python
+import asyncio
+
+from mrkts import MrktPool
+
+
+async def get_balance(client) -> dict:
+    async with client as api:
+        response = await api.http.get("balance")
+        response.raise_for_status()
+        return await response.json()
+
+
+async def main() -> None:
+    async with MrktPool(tokens=["TOKEN_1", "TOKEN_2"]) as pool:
+        results = await pool.map(get_balance, concurrency=2)
+        for result in results:
+            if isinstance(result, Exception):
+                print(f"Request failed: {result}")
+            else:
+                print(result)
+
+
+asyncio.run(main())
+```
+
+To create a pool from Telegram sessions, use
+`await MrktPool.from_sessions(...)`.
+
+## API Structure
+
+```text
+MrktClient
+├── market
+│   ├── gifts
+│   ├── orders
+│   └── offers
+├── steam
+│   └── cs2
+│       ├── skins
+│       ├── orders
+│       └── offers
+└── user
+```
+
+Specify `"market"`, `"steam"`, or `"user"` in `preload` to access the
+corresponding module through `MrktClient`.

mrkts-0.2.0/README.md

@@ -0,0 +1,241 @@
+# MRKT Python Client
+
+An asynchronous Python library for the [MRKT](https://t.me/mrkt) API.
+`MrktClient` provides the main transport, while the API is organized into
+separate Market, Steam, and User classes. These API classes can be used with
+the main client or directly with a custom HTTP transport.
+
+## Features
+
+- Access token and Telegram session authentication
+- Market methods for gifts, orders, and offers
+- Steam methods, including CS2
+- User profile, balance, and transaction methods
+- Raw requests through the available HTTP session
+- Concurrent multi-account operations with `MrktPool`
+
+## Installation
+
+Python 3.10 or newer is required.
+
+```bash
+python -m pip install mrkts
+```
+
+The importable module is named `mrkts`.
+
+## Quick Start
+
+The client and its API modules are asynchronous. Provide an access token and
+list the modules you need in `preload`:
+
+```python
+import asyncio
+
+from mrkts import MrktClient
+
+
+async def main() -> None:
+    async with MrktClient(
+        token="YOUR_ACCESS_TOKEN",
+        preload=("market", "user"),
+    ) as client:
+        gifts = await client.market.gifts.collections()
+        profile = await client.user.me()
+        print(gifts)
+        print(profile)
+
+
+asyncio.run(main())
+```
+
+`preload` is empty by default. Available values are `"market"`, `"steam"`, and
+`"user"`. Use `client.steam` for Steam methods; CS2 methods are available under
+`client.steam.cs2`, for example `client.steam.cs2.skins`.
+
+The HTTP session is created when entering `async with` or calling
+`await client.start()`, and is closed when exiting the context. If you do not
+use the context manager, make sure to call `await client.close()`.
+
+## Authentication
+
+### Access Token
+
+```python
+async with MrktClient(
+    token="YOUR_ACCESS_TOKEN",
+    preload=("market",),
+) as client:
+    listings = await client.market.gifts.saling(count=10)
+```
+
+### Telegram Session
+
+To authenticate with a Telegram session, install the project dependencies and
+provide the session name and the directory containing the session files:
+
+```python
+import asyncio
+
+from mrkts import MrktClient
+
+
+async def main() -> None:
+    client = await MrktClient.session(
+        "my_telegram_session",
+        workdir=".",
+        preload=("user",),
+    )
+    async with client:
+        print(await client.user.me())
+
+
+asyncio.run(main())
+```
+
+## API Methods
+
+### Market
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN", preload=("market",)) as client:
+    collections = await client.market.gifts.collections()
+    listings = await client.market.gifts.saling(
+        collectionNames=["Plush Pepe"],
+        count=20,
+        ordering="Price",
+        lowToHigh=True,
+    )
+    inventory = await client.market.gifts.inventory(isListed=False, count=20)
+    orders = await client.market.orders.list(
+        collectionNames=["Plush Pepe"],
+        count=10,
+    )
+    activities = await client.market.offers.activities(count=20)
+```
+
+`client.market` provides `gifts`, `orders`, and `offers`. Gift methods include
+`collections`, `models`, `backdrops`, `saling`, `inventory`, `history`, `feed`,
+`buy`, and `sale`.
+
+### User
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN", preload=("user",)) as client:
+    profile = await client.user.me()
+    balance = await client.user.balance()
+    transactions = await client.user.transactions()
+```
+
+### Steam / CS2
+
+```python
+async with MrktClient(
+    token="YOUR_ACCESS_TOKEN",
+    preload=("steam", "user"),
+) as client:
+    steam_link = await client.steam.connect()
+    is_connected = await client.steam.connected
+    # Use client.steam.cs2.skins to query the CS2 catalog.
+```
+
+## Raw HTTP Requests
+
+After `MrktClient` starts, its `http` attribute is an `aiohttp.ClientSession`
+configured with the API base URL and authentication headers. Use it to call
+endpoints that are not yet covered by the library's API methods:
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN") as client:
+    response = await client.http.get("gifts/collections")
+    response.raise_for_status()
+    collections = await response.json()
+    print(collections)
+```
+
+For POST requests, pass the request body through `json`:
+
+```python
+async with MrktClient(token="YOUR_ACCESS_TOKEN") as client:
+    response = await client.http.post(
+        "gifts/saling",
+        json={"count": 10, "collectionNames": ["Plush Pepe"]},
+    )
+    response.raise_for_status()
+    listings = await response.json()
+```
+
+Pass paths relative to the client's base URL:
+`https://api.tgmrkt.io/api/v1/`. Raw requests should also be made inside the
+client context so that the HTTP session has been initialized.
+
+## Using API Classes Without `preload` or `MrktClient`
+
+With this approach, you are responsible for the base URL, authentication
+headers, and closing the HTTP session. To use the built-in authentication and
+transport while still creating API classes independently of `preload`, pass
+an instance of `MrktClient` to them:
+
+```python
+from mrkts import MrktClient
+from mrkts.market.gifts import Gifts
+
+
+async def main() -> None:
+    async with MrktClient(token="YOUR_ACCESS_TOKEN") as transport:
+        gifts = Gifts(transport)
+        print(await gifts.collections())
+```
+
+## Multiple Accounts
+
+`MrktPool` runs one coroutine for each client in the pool. Open each client
+with `async with` inside the callback:
+
+```python
+import asyncio
+
+from mrkts import MrktPool
+
+
+async def get_balance(client) -> dict:
+    async with client as api:
+        response = await api.http.get("balance")
+        response.raise_for_status()
+        return await response.json()
+
+
+async def main() -> None:
+    async with MrktPool(tokens=["TOKEN_1", "TOKEN_2"]) as pool:
+        results = await pool.map(get_balance, concurrency=2)
+        for result in results:
+            if isinstance(result, Exception):
+                print(f"Request failed: {result}")
+            else:
+                print(result)
+
+
+asyncio.run(main())
+```
+
+To create a pool from Telegram sessions, use
+`await MrktPool.from_sessions(...)`.
+
+## API Structure
+
+```text
+MrktClient
+├── market
+│   ├── gifts
+│   ├── orders
+│   └── offers
+├── steam
+│   └── cs2
+│       ├── skins
+│       ├── orders
+│       └── offers
+└── user
+```
+
+Specify `"market"`, `"steam"`, or `"user"` in `preload` to access the
+corresponding module through `MrktClient`.

mrkts-0.2.0/mrkts/__init__.py

@@ -0,0 +1,6 @@
+"""Asynchronous Python client for the MRKT API."""
+
+from .client import MrktClient
+from .pool import MrktPool
+
+__all__ = ["MrktClient", "MrktPool"]

mrkts-0.2.0/mrkts/auth.py

@@ -0,0 +1,12 @@
+async def get_token(init_data: str, *, proxy: str | None = None) -> str:
+    from .client import MrktClient
+
+    async with MrktClient(token=None, proxy=proxy) as client:
+        return await client.auth(init_data)
+
+
+async def refresh_token(session: str, *, workdir: str = ".", proxy: str | None = None) -> str:
+    from .utils import get_init_data
+
+    init_data = await get_init_data(session, workdir=workdir, proxy=proxy)
+    return await get_token(init_data, proxy=proxy)

mrkts-0.2.0/mrkts/client.py

@@ -0,0 +1,145 @@
+"""Main object of MRKT client"""
+
+from importlib import import_module
+import random
+from aiohttp import ClientSession
+from .auth import get_token, refresh_token
+
+_preloads = {
+    "market": (".market.client", "MarketClient"),
+    "steam": (".steam.client", "SteamClient"),
+    "user": (".user", "User"),
+}
+
+class MrktClient:
+    def __init__(
+        self,
+        token: str | None = None,
+        *,
+        session: str | None = None,
+        preload: tuple[str, ...] | None = None,
+        workdir: str = ".",
+        proxy: str | None = None,
+        headers: dict | None = None,
+    ):
+        self.token = token
+        self._session = session
+        self.workdir = workdir
+        self.proxy = proxy
+        self.headers = headers or {}
+        self._closed = False
+        self.http: ClientSession | None = None
+        self.web = ClientSession | None = None
+
+        for name in preload or []:
+            self._preload(name)
+
+    def _setup_http(self):
+        chrome, edge = random.randint(120, 145), random.randint(120, 145)
+
+        headers = {
+            "accept": "application/json, text/plain, */*",
+            "accept-encoding": "gzip, deflate",
+            "accept-language": "ru,en;q=0.9,en-GB;q=0.8,en-US;q=0.7",
+            "content-type": "application/json",
+            "origin": "https://cdn.tgmrkt.io",
+            "priority": "u=1, i",
+            "referer": "https://cdn.tgmrkt.io/",
+            "sec-ch-ua": f'"Not=A?Brand";v="8", "Chromium";v="{chrome}", "Microsoft Edge";v="{edge}"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": random.choice(['"Windows"', '"macOS"', '"Linux"']),
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "sec-fetch-storage-access": "active",
+            "user-agent": f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{chrome}.0.0.0 Safari/537.36 Edg/{edge}.0.0.0",
+        }
+        if self.token:
+            headers["authorization"] = f"Bearer {self.token}"
+            headers["cookie"] = f"access_token={self.token}"
+        self.headers.update(headers)
+
+        self.http = ClientSession(
+            base_url="https://api.tgmrkt.io/api/v1/",
+            headers=self.headers,
+            proxy=self.proxy,
+        )
+        self._closed = False
+
+    async def auth(self, tgWebAppData: str) -> str:
+        if not self.http:
+            self._setup_http()
+        response = await self.http.post("auth", json={"data": tgWebAppData})
+        response.raise_for_status()
+        data = response.json()
+        token = data.get("token")
+        if not token:
+            raise ValueError(f"Auth failed: {data}")
+        return token
+
+    async def start(self) -> "MrktClient":
+        if not self.token and self._session:
+            self.token = await refresh_token(session=self._session, workdir=self.workdir, proxy=self.proxy)
+        if not self.http and self.token:
+            self._setup_http()
+        return self
+
+    @classmethod
+    async def session(
+        cls, 
+        session: str, 
+        *, 
+        workdir: str = ".", 
+        proxy: str | None = None, 
+        **kwargs
+    ):
+        token = await refresh_token(session, workdir=workdir, proxy=proxy)
+        return cls(token=token, workdir=workdir, proxy=proxy, **kwargs)
+
+    @classmethod
+    async def init_data(
+        cls,
+        init_data: str,
+        *,
+        workdir: str = ".",
+        proxy: str | None = None,
+        impersonate: str = "chrome124",
+        **kwargs,
+    ) -> "MrktClient":
+        token = await get_token(init_data, proxy=proxy)
+        return cls(token=token, workdir=workdir, proxy=proxy, impersonate=impersonate, **kwargs)
+
+    def set_token(self, token: str) -> None:
+        self.token = token
+        self.headers["authorization"] = f"Bearer {token}"
+        self.headers["cookie"] = f"access_token={token}"
+
+        if self.http is None:
+            self._setup_http()
+        else:
+            self.http.headers.update({
+                "authorization": f"Bearer {token}",
+                "cookie": f"access_token={token}",
+            })
+        
+    def _preload(self, name: str) -> None:
+        try:
+            module_name, class_name = _preloads[name]
+        except KeyError:
+            raise ValueError(f"Unknown preload: {name!r}") from None
+
+        module = import_module(module_name, package=__package__)
+        cls = getattr(module, class_name)
+
+        setattr(self, name, cls(self))
+
+    async def __aenter__(self):
+        return await self.start()
+
+    async def __aexit__(self, *args):
+        await self.close()
+
+    async def close(self):
+        if not self._closed and self.http:
+            await self.http.close()
+            self._closed = True

mrkts-0.2.0/mrkts/market/client.py

@@ -0,0 +1,11 @@
+'''Market object of MRKT client'''
+
+from .gifts import Gifts
+from .orders import Orders
+from .offers import Offers
+
+class MarketClient:
+    def __init__(self, client):
+        self.gifts = Gifts(client)
+        self.orders = Orders(client)
+        self.offers = Offers(client)