mrkts 0.2.0__py3-none-any.whl

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/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/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/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)

mrkts/market/gifts.py

@@ -0,0 +1,195 @@
+'''Gifts object of MRKT client'''
+
+class Gifts:
+    def __init__(self, client):
+        self._client = client
+
+    async def saling(
+        self,
+        *,
+        count: int = 20,
+        cursor: str = "",
+        collectionNames: list[str] | None = None,
+        modelNames: list[str] | None = None,
+        backdropNames: list[str] | None = None,
+        symbolNames: list[str] | None = None,
+        number: int | None = None,
+        isNew: bool | None = None,
+        isPremarket: bool | None = None,
+        luckyBuy: bool | None = None,
+        giftType: str | None = None,
+        craftable: bool | None = None,
+        isCrafted: bool | None = None,
+        tgCanBeCraftedFrom: bool | None = None,
+        removeSelfSales: bool | None = None,
+        isTransferable: bool | None = None,
+        availableForStaking: bool | None = None,
+        forGame: bool | None = None,
+        minPrice: int | None = None,
+        maxPrice: int | None = None,
+        ordering: str = "Price",
+        lowToHigh: bool = True,
+        query: str | None = None,
+        **kwargs
+    ) -> dict:
+        payload = {
+            "count": count,
+            "cursor": cursor,
+            "collectionNames": collectionNames or [],
+            "modelNames": modelNames or [],
+            "backdropNames": backdropNames or [],
+            "symbolNames": symbolNames or [],
+            "number": number,
+            "isNew": isNew,
+            "isPremarket": isPremarket,
+            "luckyBuy": luckyBuy,
+            "giftType": giftType,
+            "craftable": craftable,
+            "isCrafted": isCrafted,
+            "tgCanBeCraftedFrom": tgCanBeCraftedFrom,
+            "removeSelfSales": removeSelfSales,
+            "isTransferable": isTransferable,
+            "availableForStaking": availableForStaking,
+            "forGame": forGame,
+            "minPrice": minPrice,
+            "maxPrice": maxPrice,
+            "ordering": ordering,
+            "lowToHigh": lowToHigh,
+            "query": query,
+            **kwargs
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        response = await self._client.http.post("gifts/saling", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+    async def buy(self, *, ids: list):
+        response = await self._client.http.post("gifts/buy", json={"ids": ids})
+        response.raise_for_status()
+        return await response.json()
+        
+    async def sale(self, *, ids: list, price: int):
+        response = await self._client.http.post("gifts/sale", json={"ids": ids, "price": price})
+        response.raise_for_status()
+        return await response.json()
+    
+    async def collections(self) -> list[dict]:
+        response = await self._client.http.get("gifts/collections")
+        response.raise_for_status()
+        return await response.json()
+
+    async def models(self, collections: list[str]) -> list[dict]:
+        response = await self._client.http.post("gifts/models", json={"collections": collections})
+        response.raise_for_status()
+        return await response.json()
+
+    async def backdrops(self, collections: list[str]) -> list[dict]:
+        response = await self._client.http.post("gifts/backdrops", json={"collections": collections})
+        response.raise_for_status()
+        return await response.json()
+
+    async def inventory(
+        self,
+        *,
+        isListed: bool = False,
+        count: int = 20,
+        cursor: str = "",
+        collectionNames: list[str] | None = None,
+        modelNames: list[str] | None = None,
+        backdropNames: list[str] | None = None,
+        symbolNames: list[str] | None = None,
+        number: int | None = None,
+        isNew: bool | None = None,
+        isPremarket: bool | None = None,
+        luckyBuy: bool | None = None,
+        giftType: str | None = None,
+        craftable: bool | None = None,
+        isCrafted: bool | None = None,
+        tgCanBeCraftedFrom: bool | None = None,
+        removeSelfSales: bool | None = None,
+        isTransferable: bool | None = None,
+        availableForStaking: bool | None = None,
+        forGame: bool | None = None,
+        minPrice: int | None = None,
+        maxPrice: int | None = None,
+        ordering: str = "None",
+        lowToHigh: bool = False,
+        query: str | None = None,
+        **kwargs
+    ) -> dict:
+        payload = {
+            "isListed": isListed,
+            "count": count,
+            "cursor": cursor,
+            "collectionNames": collectionNames or [],
+            "modelNames": modelNames or [],
+            "backdropNames": backdropNames or [],
+            "symbolNames": symbolNames or [],
+            "number": number,
+            "isNew": isNew,
+            "isPremarket": isPremarket,
+            "luckyBuy": luckyBuy,
+            "giftType": giftType,
+            "craftable": craftable,
+            "isCrafted": isCrafted,
+            "tgCanBeCraftedFrom": tgCanBeCraftedFrom,
+            "removeSelfSales": removeSelfSales,
+            "isTransferable": isTransferable,
+            "availableForStaking": availableForStaking,
+            "forGame": forGame,
+            "minPrice": minPrice,
+            "maxPrice": maxPrice,
+            "ordering": ordering,
+            "lowToHigh": lowToHigh,
+            "query": query,
+            **kwargs
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        response = await self._client.http.post("gifts", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+    async def history(self, *, limit: int = 20, type: str = "Gift", **kwargs) -> dict:
+        response = await self._client.http.get("history", json={"limit": limit, "type": type, **kwargs})
+        response.raise_for_status()
+        return await response.json()
+    
+    async def feed(
+        self,
+        *,
+        count: int = 20,
+        cursor: str = "",
+        collectionNames: list[str] | None = None,
+        modelNames: list[str] | None = None,
+        backdropNames: list[str] | None = None,
+        number: int | None = None,
+        type: list[str] | None = None,          # "listing", "sale", "return", "unlisting", "changeprice", "withdraw"
+        minPrice: int | None = None,
+        maxPrice: int | None = None,
+        ordering: str = "Latest",
+        lowToHigh: bool = False,
+        query: str | None = None,
+        **kwargs
+    ) -> dict:
+        payload = {
+            "count": count,
+            "cursor": cursor,
+            "collectionNames": collectionNames or [],
+            "modelNames": modelNames or [],
+            "backdropNames": backdropNames or [],
+            "number": number,
+            "type": type or [],
+            "minPrice": minPrice,
+            "maxPrice": maxPrice,
+            "ordering": ordering,
+            "lowToHigh": lowToHigh,
+            "query": query,
+            **kwargs
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        response = await self._client.http.post("feed", json=payload)
+        response.raise_for_status()
+        return await response.json()

mrkts/market/offers.py

@@ -0,0 +1,29 @@
+"""Offers object of MRKT client"""
+
+class Offers:
+    def __init__(self, client):
+        self._client = client
+
+    async def create(self, price: int, giftSaleId: str):
+        payload = {
+            "price": price,
+            "giftSaleId": giftSaleId
+        }
+        response = await self._client.http.post("offers/create", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+    async def cancel(self, offerId: str):
+        response = await self._client.http.post(f"offers/cancel?offerId={offerId}")
+        response.raise_for_status()
+        return await response.json()
+    
+    async def activities(self, *, count: int = 20, isActive: bool = True, filters: list = ["Offers", "ChannelOffers", "GiftsCollectionOffers"]):
+        response = await self._client.http.get("activities/with-totals", params={"count": count, "isActive": str(isActive).lower(), "filters": filters})
+        response.raise_for_status()
+        return await response.json()
+
+    async def myOffersByGift(self, id: str, count: int = 20):
+        response = await self._client.http.get(f"offers/by-gift/{id}?count={count}")
+        response.raise_for_status()
+        return await response.json()

mrkts/market/orders.py

@@ -0,0 +1,155 @@
+"""Orders object of MRKT client"""
+from aiohttp import ClientResponseError
+
+class Orders:
+    def __init__(self, client):
+        self._client = client
+
+
+    async def create(
+        self,
+        *,
+        collectionName: str = None,
+        modelName: str = None,
+        backdropName: str = None,
+        symbolName: str = None,
+        priceMinNanoTONs: int = 500000000,
+        priceMaxNanoTONs: int = 1000000000,
+        quantity: int = 1,
+        isTransferable: bool = False,
+        **kwargs
+    ):
+        payload = {
+            "collectionName": collectionName,
+            "modelName": modelName,
+            "backdropName": backdropName,
+            "symbolName": symbolName,
+            "priceMinNanoTONs": priceMinNanoTONs,
+            "priceMaxNanoTONs": priceMaxNanoTONs,
+            "quantity": quantity,
+            "isTransferable": isTransferable,
+            **kwargs
+        }
+        response = await self._client.http.post("orders/create", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+
+    async def cancel(self, orderId: str):
+        try:
+            response = await self._client.http.post(f"orders/cancel/{orderId}")
+            response.raise_for_status()
+            return True
+        except ClientResponseError:
+            return False
+        except Exception as e:
+            raise e
+
+
+    async def list(
+        self,
+        *, 
+        collectionNames: list[str],
+        modelNames: list[str] = [],
+        backdropNames: list[str] = [],
+        symbolNames: list[str] = [],
+        availableForStaking: bool = None,
+        minPrice: float = None,
+        maxPrice: float = None,
+        ordering: str = "Price",
+        lowToHigh: bool = False,
+        query: str = None,
+        cursor: str = "",
+        count: int = 20,
+        **kwargs
+    ) -> list[dict]:
+        payload = {
+            "collectionNames": collectionNames,
+            "modelNames": modelNames,
+            "backdropNames": backdropNames,
+            "symbolNames": symbolNames,
+            "availableForStaking": availableForStaking,
+            "minPrice": minPrice,
+            "maxPrice": maxPrice,
+            "ordering": ordering,
+            "lowToHigh": lowToHigh,
+            "query": query,
+            "cursor": cursor,
+            "count": count,
+            **kwargs
+        }
+        response = await self._client.http.post("orders", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+    
+    async def fill(self, *, orderId: str, giftIds: str):
+        response = await self._client.http.post("orders/fill", json={"orderId": orderId, "giftIds": giftIds})
+        response.raise_for_status()
+        return await response.json()
+
+
+    async def getMyOrders(
+        self,
+        *, 
+        collectionNames: list = [],
+        modelNames: list = [],
+        backdropNames: list = [],
+        symbolNames: list = [],
+        availableForStaking: bool = None, 
+        minPrice: float = None, 
+        maxPrice: float = None, 
+        ordering: str = "PublicationTime",
+        lowToHigh: bool = False,
+        query: str = None,
+        cursor: str = "", 
+        count: int = 20,
+        **kwargs
+    ):
+        payload = {
+            "collectionNames": collectionNames,
+            "modelNames": modelNames,
+            "backdropNames": backdropNames,
+            "symbolNames": symbolNames,
+            "availableForStaking": availableForStaking,
+            "minPrice": minPrice,
+            "maxPrice": maxPrice,
+            "ordering": ordering,
+            "lowToHigh": lowToHigh,
+            "query": query,
+            "cursor": cursor,
+            "count": count,
+            **kwargs
+        }
+        response = await self._client.http.post("orders/get-my-orders", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+
+    async def allCollectionTop(self):
+        response = await self._client.http.get("orders/all-collection-top")
+        response.raise_for_status()
+        return await response.json()
+
+
+    async def giftsHistory(self, *, st_from: str = "", limit: int = 20, **kwargs):
+        payload = {
+            "from": st_from,
+            "limit": limit,
+            **kwargs
+        }
+        response = await self._client.http.post("orders/gifts-history", json=payload)
+        response.raise_for_status()
+        return await response.json()
+
+
+    async def top(self, *, collectionName: str, modelName: str = None, backdropName: str = None, symbolName: str = None):
+        payload = {
+            "collectionName": collectionName,
+            "modelName": modelName,
+            "backdropName": backdropName,
+            "symbolName": symbolName
+        }
+        response = await self._client.http.post("orders/top", json=payload)
+        response.raise_for_status()
+        return await response.json()

mrkts/pool.py

@@ -0,0 +1,101 @@
+import asyncio
+from typing import *
+
+from .client import MrktClient
+from .utils import get_tokens
+
+
+class MrktPool:
+    def __init__(
+        self,
+        *,
+        tokens: list[str] | None = None,
+        sessions: list[str] | None = None,
+        workdir: str = ".",
+        tasks: list[tuple[str, dict]] | None = None,
+        proxy: str | None = None,
+        unlimited: bool = False
+    ):
+        self.clients: list["MrktClient"] = []
+        self._tasks = tasks
+        self.proxy = proxy
+        self.workdir = workdir
+        self._kwargs = {
+            "proxy": self.proxy,
+            "workdir": self.workdir
+        }
+        self._unlimited = unlimited
+
+        if tokens and sessions:
+            raise ValueError("Client can not run with tokens and sessions both")
+        
+        if tokens:
+            self.clients = [MrktClient(token=token, **self._kwargs) for token in tokens]
+        elif sessions:
+            self._load_sessions(sessions)
+        else:
+            raise ValueError("Client can not run without tokens or sessions")
+
+    @classmethod
+    async def from_sessions(
+        cls,
+        sessions: list[str],
+        *,
+        workdir: str = ".",
+        proxy: str | None = None,
+        concurrency: int = 5,
+        **kwargs: Any,
+    ) -> "MrktPool":
+        tokens = await get_tokens(
+            sessions,
+            workdir=workdir,
+            proxy=proxy,
+            concurrency=concurrency,
+        )
+        return cls(
+            tokens=tokens,
+            workdir=workdir,
+            proxy=proxy,
+            **kwargs,
+        )
+
+    def _load_sessions(self, sessions: list[str]):
+        async def load():
+            tokens = await get_tokens(sessions, workdir=self.workdir, proxy=self.proxy)
+            self.clients = [MrktClient(token=t, **self._kwargs) for t in tokens]
+
+        self._token_future = load()
+
+    async def start(self):
+        if not self.clients and hasattr(self, "_token_future"):
+            await self._token_future
+            self.clients = [MrktClient(token=t, **self._kwargs) for t in self.clients]
+
+    async def map(
+            self,
+            coro_func: Callable[[MrktClient], Awaitable[Any]],
+            *,
+            concurrency: int = 5,
+        ) -> list[Any | Exception]:
+            if concurrency < 1 and not self._unlimited:
+                raise ValueError("concurrency must be greater than zero")
+    
+            sem = asyncio.Semaphore(concurrency)
+    
+            async def worker(client):
+                async with sem:
+                    return await coro_func(client)
+    
+            return await asyncio.gather(*(worker(c) for c in self.clients), return_exceptions=True)
+
+    async def close(self):
+        if self.clients:
+            await asyncio.gather(*[c.close() for c in self.clients], return_exceptions=True)
+            self.clients.clear()
+
+    async def __aenter__(self) -> "MrktPool":
+        await self.start()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()