aiosellers 0.1.0__py3-none-any.whl

aiosellers/playerok/__init__.py

@@ -0,0 +1,3 @@
+from .core import exceptions
+
+__all__ = ["exceptions"]

aiosellers/playerok/core/__init__.py

@@ -0,0 +1,5 @@
+from .client import PlayerokClient
+from .config import PlayerokConfig
+from .utils import _dig, _raise_on_gql_errors
+
+__all__ = ["PlayerokClient", "PlayerokConfig", "_dig", "_raise_on_gql_errors"]

aiosellers/playerok/core/client.py

@@ -0,0 +1,64 @@
+import os
+from typing import Any, Literal
+
+from tls_requests import AsyncClient, Response
+
+from .config import PlayerokConfig
+from .constants import CLOUDFLARE_SIGNATURES
+from .exceptions import CloudflareDetected
+
+
+class PlayerokClient:
+    def __init__(self, access_token: str | None = None, config: PlayerokConfig | None = None):
+        self._access_token = access_token or os.getenv("PLAYEROK_ACCESS_TOKEN")
+        self._config = config or PlayerokConfig()
+
+        if not self._access_token:
+            raise RuntimeError(
+                "Please provide playerok access token or fill PLAYEROK_ACCESS_TOKEN environment variable."
+            )
+
+        # Initialize network client
+        self._client = AsyncClient(
+            cookies={"token": self._access_token},
+            headers=self._config.headers,
+            timeout=self._config.request_timeout,
+        )
+
+    @staticmethod
+    def _raise_if_cloudflare(response: Response):
+        if any(sig in response.text for sig in CLOUDFLARE_SIGNATURES):
+            raise CloudflareDetected("The cloudflare protection is detected.")
+
+    async def request(
+        self,
+        method: Literal["get", "post"],
+        url: str,
+        payload: dict[str, str],
+        *,
+        headers: dict[str, str] | None = None,
+        files: dict[str, Any] | None = None,
+    ) -> Response:
+        request_headers = self._config.headers.copy()
+        if headers is not None:
+            request_headers.update(headers)
+        if not url.startswith("http"):
+            url = self._config.base_url + url
+
+        if method == "get":
+            response = await self._client.get(url=url, headers=request_headers, params=payload)
+        elif method == "post":
+            if files:
+                response = await self._client.post(
+                    url=url, headers=request_headers, data=payload, files=files
+                )
+            else:
+                response = await self._client.post(url=url, headers=request_headers, json=payload)
+        else:
+            raise RuntimeError(f"Unsupported HTTP method: {method}")
+
+        self._raise_if_cloudflare(response)
+        return response
+
+    async def close(self):
+        await self._client.aclose()

aiosellers/playerok/core/config.py

@@ -0,0 +1,23 @@
+import os
+import random
+
+from .constants import BASE_HEADERS, EXAMPLE_USER_AGENTS
+
+
+class PlayerokConfig:
+    def __init__(
+        self,
+        *,
+        user_agent: str | None = None,
+        request_timeout: float | None = None,
+        base_url: str | None = None,
+    ):
+        self.user_agent = user_agent or random.choice(EXAMPLE_USER_AGENTS)
+        self.request_timeout = request_timeout or 10.0
+        self.base_url = base_url or os.getenv("PLAYEROK_BASE_URL", "https://playerok.com/")
+
+    @property
+    def headers(self):
+        return BASE_HEADERS | {
+            "User-Agent": self.user_agent,
+        }

aiosellers/playerok/core/constants.py

@@ -0,0 +1,42 @@
+BASE_HEADERS = {
+    "accept": "*/*",
+    "accept-language": "en-US,en;q=0.9",
+    "access-control-allow-headers": "sentry-trace, baggage",
+    "apollo-require-preflight": "true",
+    "apollographql-client-name": "web",
+    "content-type": "application/json",
+    "origin": "https://playerok.com",
+    "priority": "u=1, i",
+    "referer": "https://playerok.com/",
+    "sec-ch-ua": '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"macOS"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    "x-gql-op": "viewer",
+    "x-gql-path": "/products/[slug]",
+    "x-timezone-offset": "-180",
+}
+
+EXAMPLE_USER_AGENTS = [
+    "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 7_0_2; en-US) Gecko/20100101 Firefox/57.1",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 9_8_3) AppleWebKit/534.47 (KHTML, like Gecko) Chrome/51.0.1124.252 Safari/535",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_2_9) Gecko/20100101 Firefox/65.6",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_0_2) AppleWebKit/536.44 (KHTML, like Gecko) Chrome/49.0.2950.348 Safari/602",
+    "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 9_9_9; en-US) Gecko/20130401 Firefox/59.3",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_1_1; en-US) AppleWebKit/534.17 (KHTML, like Gecko) Chrome/53.0.2619.208 Safari/535",
+    "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_7_8) Gecko/20130401 Firefox/59.9",
+    "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_0) Gecko/20130401 Firefox/68.4",
+    "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_3_5; en-US) Gecko/20100101 Firefox/53.9",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 7_1_1; en-US) Gecko/20130401 Firefox/61.0",
+]
+
+CLOUDFLARE_SIGNATURES = [
+    "<title>Just a moment...</title>",
+    "window._cf_chl_opt",
+    "Enable JavaScript and cookies to continue",
+    "Checking your browser before accessing",
+    "cf-browser-verification",
+    "Cloudflare Ray ID",
+]

aiosellers/playerok/core/exceptions.py

@@ -0,0 +1,6 @@
+class CloudflareDetected(Exception):
+    pass
+
+
+class Unauthorized(Exception):
+    pass

aiosellers/playerok/core/utils.py

@@ -0,0 +1,17 @@
+from collections.abc import Iterable
+from typing import Any
+
+
+def _dig(obj: dict[str, Any], path: Iterable[str]) -> Any:
+    cur: Any = obj
+    for key in path:
+        if cur is None:
+            return None
+        cur = cur.get(key)
+    return cur
+
+
+def _raise_on_gql_errors(payload: dict[str, Any]) -> None:
+    errors = payload.get("errors")
+    if errors:
+        raise RuntimeError(f"GraphQL errors: {errors}")

aiosellers/playerok/graphql.py

@@ -0,0 +1,222 @@
+from typing import Any
+
+from .models import (
+    GameCategoryDataFieldTypes,
+    GameCategoryInstructionTypes,
+    GameType,
+    ItemsSortOptions,
+    QueryID,
+)
+
+
+def _persisted(
+    operation_name: str,
+    variables: dict[str, Any],
+    *,
+    sha256_hash: Any | None = None,
+    query: str | None = None,
+) -> dict[str, Any]:
+    r = {
+        "operationName": operation_name,
+        "variables": variables,
+    }
+    if query:
+        r["query"] = query
+    if sha256_hash:
+        r["extensions"] = {
+            "persistedQuery": {
+                "version": 1,
+                "sha256Hash": sha256_hash,
+            }
+        }
+    return r
+
+
+class GraphQLQuery:
+    @staticmethod
+    def get_me():
+        return _persisted(
+            operation_name="viewer",
+            variables={},
+            query="query viewer {\n  viewer {\n    ...Viewer\n    __typename\n  }\n}\n\nfragment Viewer on User {\n  id\n  username\n  email\n  role\n  hasFrozenBalance\n  supportChatId\n  systemChatId\n  unreadChatsCounter\n  isBlocked\n  isBlockedFor\n  isFundsProtectionActive\n  createdAt\n  lastItemCreatedAt\n  hasConfirmedPhoneNumber\n  canPublishItems\n  chosenVerifiedCard {\n    ...MinimalUserBankCard\n    __typename\n  }\n  profile {\n    id\n    avatarURL\n    testimonialCounter\n    __typename\n  }\n  __typename\n}\n\nfragment MinimalUserBankCard on UserBankCard {\n  id\n  cardFirstSix\n  cardLastFour\n  cardType\n  isChosen\n  __typename\n}",
+        )
+
+    @staticmethod
+    def get_user(username: str | None = None, id: str | None = None) -> dict[str, Any]:
+        return _persisted(
+            operation_name="user",
+            variables={"id": id, "username": username, "hasSupportAccess": False},
+            sha256_hash=QueryID.user.value,
+        )
+
+    @staticmethod
+    def get_games(
+        count: int = 24, type: GameType | None = None, cursor: str | None = None
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="games",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": {"type": type.name} if type else {},
+            },
+            sha256_hash=QueryID.games.value,
+        )
+
+    @staticmethod
+    def get_game(id: str | None = None, slug: str | None = None) -> dict[str, Any]:
+        return _persisted(
+            operation_name="GamePage",
+            variables={"id": id, "slug": slug},
+            sha256_hash=QueryID.game.value,
+        )
+
+    @staticmethod
+    def get_game_category(
+        game_id: str | None = None,
+        slug: str | None = None,
+        id: str | None = None,
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="GamePageCategory",
+            variables={"id": id, "gameId": game_id, "slug": slug},
+            sha256_hash=QueryID.game_category.value,
+        )
+
+    @staticmethod
+    def get_game_category_agreements(
+        game_category_id: str,
+        user_id: str | None = None,
+        count: int = 24,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="gameCategoryAgreements",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": {"gameCategoryId": game_category_id, "userId": user_id},
+            },
+            sha256_hash=QueryID.game_category_agreements.value,
+        )
+
+    @staticmethod
+    def get_game_category_obtaining_types(
+        game_category_id: str,
+        count: int = 24,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="gameCategoryObtainingTypes",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": {"gameCategoryId": game_category_id},
+            },
+            sha256_hash=QueryID.game_category_obtaining_types.value,
+        )
+
+    @staticmethod
+    def get_game_category_instructions(
+        game_category_id: str,
+        obtaining_type_id: str,
+        count: int = 24,
+        type: GameCategoryInstructionTypes | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="gameCategoryInstructions",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": {
+                    "gameCategoryId": game_category_id,
+                    "obtainingTypeId": obtaining_type_id,
+                    "type": type.name if type else None,
+                },
+            },
+            sha256_hash=QueryID.game_category_instructions.value,
+        )
+
+    @staticmethod
+    def get_game_category_data_fields(
+        game_category_id: str,
+        obtaining_type_id: str,
+        count: int = 24,
+        type: GameCategoryDataFieldTypes | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        return _persisted(
+            operation_name="gameCategoryDataFields",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": {
+                    "gameCategoryId": game_category_id,
+                    "obtainingTypeId": obtaining_type_id,
+                    "type": type.name if type else None,
+                },
+            },
+            sha256_hash=QueryID.game_category_data_fields.value,
+        )
+
+    @staticmethod
+    def get_items(
+        count: int = 24,
+        cursor: str | None = None,
+        game_id: str | None = None,
+        category_id: str | None = None,
+        minimal_price: int | None = None,
+        maximal_price: int | None = None,
+        has_discount: bool | None = None,
+        has_reviews: bool | None = None,
+        attributes: list[dict[str, str]] | None = None,
+        search: str | None = None,
+        sort: ItemsSortOptions | None = None,
+    ) -> dict[str, Any]:
+        filters = {
+            "gameId": game_id,
+            "gameCategoryId": category_id,
+            "status": ["APPROVED"],
+        }
+        sort_field = None
+
+        if minimal_price or maximal_price:
+            filters["price"] = {"min": minimal_price, "max": maximal_price}
+        if has_discount:
+            filters["hasDiscount"] = has_discount
+        if has_reviews:
+            filters["hasTestimonials"] = has_reviews
+        if attributes:
+            filters["attributes"] = attributes
+        if search:
+            filters["searchQuery"] = search
+        if sort:
+            if "PRICE" in sort:
+                field = "price"
+            else:
+                field = "userRating"
+            if "ASC" in sort:
+                direction = "ASC"
+            else:
+                direction = "DESC"
+
+            sort_field = {"field": field, "direction": direction}
+
+        return _persisted(
+            operation_name="items",
+            variables={
+                "pagination": {"first": count, "after": cursor},
+                "filter": filters,
+                "sort": sort_field,
+            },
+            sha256_hash=QueryID.items.value,
+        )
+
+    @staticmethod
+    def get_item(id: str | None = None, slug: str | None = None) -> dict[str, Any]:
+        return _persisted(
+            operation_name="item",
+            variables={
+                "id": id,
+                "slug": slug,
+                "hasSupportAccess": False,
+                "showForbiddenImage": True,
+            },
+            sha256_hash=QueryID.item.value,
+        )

aiosellers/playerok/models/__init__.py

@@ -0,0 +1,75 @@
+from .basic import ApiModel, PageInfo  # noqa: I001
+from .enums import UserType, QueryID  # noqa: I001
+
+from .account import Account, AccountProfile, UserProfile
+
+from .enums import (
+    BankCardTypes,
+    ChatMessageButtonTypes,
+    ChatStatuses,
+    ChatTypes,
+    EventTypes,
+    GameCategoryAgreementIconTypes,
+    GameCategoryAutoConfirmPeriods,
+    GameCategoryDataFieldInputTypes,
+    GameCategoryDataFieldTypes,
+    GameCategoryInstructionTypes,
+    GameCategoryOptionTypes,
+    GameType,
+    ItemDealDirections,
+    ItemDealStatuses,
+    ItemLogEvents,
+    ItemsSortOptions,
+    ItemStatuses,
+    PriorityTypes,
+    ReviewStatuses,
+    SortDirections,
+    TransactionDirections,
+    TransactionOperations,
+    TransactionPaymentMethodIds,
+    TransactionProviderDirections,
+    TransactionProviderIds,
+    TransactionStatuses,
+)
+from .games import Game, GameList
+from .items import Item, ItemList
+
+__all__ = [
+    "Account",
+    "UserProfile",
+    "AccountProfile",
+    "QueryID",
+    "GameType",
+    "ApiModel",
+    "PageInfo",
+    "UserType",
+    "GameCategoryDataFieldTypes",
+    "EventTypes",
+    "ItemLogEvents",
+    "TransactionOperations",
+    "TransactionDirections",
+    "TransactionStatuses",
+    "TransactionPaymentMethodIds",
+    "TransactionProviderDirections",
+    "TransactionProviderIds",
+    "BankCardTypes",
+    "ItemDealStatuses",
+    "ItemDealDirections",
+    "ChatTypes",
+    "ChatStatuses",
+    "ChatMessageButtonTypes",
+    "ItemStatuses",
+    "ReviewStatuses",
+    "SortDirections",
+    "PriorityTypes",
+    "GameCategoryAgreementIconTypes",
+    "GameCategoryOptionTypes",
+    "GameCategoryDataFieldInputTypes",
+    "GameCategoryAutoConfirmPeriods",
+    "GameCategoryInstructionTypes",
+    "Game",
+    "GameList",
+    "Item",
+    "ItemList",
+    "ItemsSortOptions",
+]

aiosellers/playerok/models/account.py

@@ -0,0 +1,87 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import AliasChoices, Field
+
+from . import ApiModel, UserType
+
+
+class Account(ApiModel):
+    id: str = Field(..., alias="id")
+    username: str = Field(..., alias="username")
+    email: str = Field(..., alias="email")
+    role: UserType = Field(..., alias="role")
+    has_frozen_balance: bool = Field(..., alias="hasFrozenBalance")
+    support_chat_id: str = Field(..., alias="supportChatId")
+    system_chat_id: str = Field(..., alias="systemChatId")
+    unread_chats_counter: int = Field(..., alias="unreadChatsCounter")
+    is_blocked: bool = Field(..., alias="isBlocked")
+    is_blocked_for: Any = Field(None, alias="isBlockedFor")
+    created_at: datetime = Field(..., alias="createdAt")
+    last_item_created_at: datetime = Field(None, alias="lastItemCreatedAt")
+    has_confirmed_phone_number: bool = Field(..., alias="hasConfirmedPhoneNumber")
+    can_publish_items: bool = Field(..., alias="canPublishItems")
+    is_funds_protection_active: bool = Field(..., alias="isFundsProtectionActive")
+    chosen_verified_card: Any = Field(None, alias="chosenVerifiedCard")
+
+
+class UserProfile(ApiModel):
+    id: str = Field(..., alias="id")
+    username: str = Field(..., alias="username")
+    role: UserType = Field(..., alias="role")
+    avatar_url: str | None = Field(None, alias="avatarURL")
+    is_online: bool | None = Field(None, alias="isOnline")
+    is_blocked: bool = Field(..., alias="isBlocked")
+    rating: float | None = Field(None, alias="rating")
+    reviews_count: int | None = Field(
+        None,
+        alias="reviewsCount",
+        validation_alias=AliasChoices("reviewsCount", "testimonialCounter"),
+    )
+    created_at: datetime | None = Field(None, alias="createdAt")
+
+
+class AccountBalance(ApiModel):
+    id: str = Field(..., alias="id")
+    value: float = Field(..., alias="value")
+    available: float = Field(..., alias="available")
+    frozen: float = Field(..., alias="frozen")
+    pending_income: float = Field(..., alias="pendingIncome")
+    withdrawable: float = Field(..., alias="withdrawable")
+
+
+class AccountItemsStats(ApiModel):
+    total: int = Field(..., alias="total")
+    finished: int = Field(..., alias="finished")
+
+
+class AccountIncomingDealsStats(ApiModel):
+    total: int = Field(..., alias="total")
+    finished: int = Field(..., alias="finished")
+
+
+class AccountOutgoingDealsStats(ApiModel):
+    total: int = Field(..., alias="total")
+    finished: int = Field(..., alias="finished")
+
+
+class AccountDealsStats(ApiModel):
+    incoming: AccountIncomingDealsStats = Field(..., alias="incoming")
+    outgoing: AccountOutgoingDealsStats = Field(..., alias="outgoing")
+
+
+class AccountStats(ApiModel):
+    items: AccountItemsStats = Field(..., alias="items")
+    deals: AccountDealsStats = Field(..., alias="deals")
+
+
+class AccountProfile(UserProfile):
+    email: str = Field(..., alias="email")
+    balance: AccountBalance = Field(..., alias="balance")
+    stats: AccountStats = Field(..., alias="stats")
+    is_blocked_for: Any = Field(None, alias="isBlockedFor")
+    is_verified: bool | None = Field(None, alias="isVerified")
+    has_frozen_balance: bool = Field(..., alias="hasFrozenBalance")
+    has_enabled_notifications: bool = Field(..., alias="hasEnabledNotifications")
+    support_chat_id: str = Field(..., alias="supportChatId")
+    system_chat_id: str = Field(..., alias="systemChatId")

aiosellers/playerok/models/basic.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ApiModel(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="ignore",
+    )
+
+
+class PageInfo(ApiModel):
+    start_cursor: str | None = Field(None, alias="startCursor")
+    end_cursor: str | None = Field(None, alias="endCursor")
+    has_previous_page: bool | None = Field(None, alias="hasPreviousPage")
+    has_next_page: bool | None = Field(None, alias="hasNextPage")
+
+
+class File(ApiModel):
+    id: str = Field(alias="id")
+    url: str = Field(alias="url")
+    filename: str | None = Field(None, alias="filename")
+    mime: str | None = Field(None, alias="mime")