gameflip-api 1.0.1__tar.gz

gameflip_api-1.0.1/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: gameflip-api
+Version: 1.0.1
+Summary: Uma API wrapper em Python para utilização com a plataforma Gameflip.
+Author-email: Gustavo Pedroso Bernardes <gpedrosobernardes@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: validators
+Requires-Dist: pydantic
+Requires-Dist: pyotp
+Requires-Dist: requests
+
+# Gameflip API
+
+Uma **API wrapper em Python** para utilização com a plataforma Gameflip.
+Facilita a integração via script, para automatizar operações, consultar dados e interagir com a Gameflip de forma programática.
+
+## 🧰 Funcionalidades
+
+* Conexão autenticada com a Gameflip via chave e segredo (`API_KEY`, `API_SECRET`)
+* Métodos para executar operações comuns (por exemplo: listagem de produtos, criação de ofertas, consulta de histórico)
+* Interface simples em Python para agilizar automações
+* Código open-source, fácil de estender para necessidades específicas
+
+## 🚀 Começando
+
+### Pré-requisitos
+
+* Python (versão compatível — idealmente 3.8+)
+* Conta na Gameflip e acesso à API (chave + segredo)
+* Variáveis de ambiente configuradas:
+
+  ```bash
+  export GFAPI_KEY=<sua_chave_aqui>
+  export GFAPI_SECRET=<seu_segredo_aqui>
+  ```
+
+  (No Windows: `set GFAPI_KEY=<…>`, `set GFAPI_SECRET=<…>`)
+
+### Instalação
+
+```bash
+pip install gameflip-api
+```
+
+### Uso básico
+
+Exemplo no arquivo `example.py` (ajuste conforme a sua necessidade):
+
+```python
+import os
+from pprint import pprint
+from dotenv import load_dotenv
+from gameflip_api.api import GameflipAPI
+
+load_dotenv()
+
+print("Listing results:")
+
+listing_response = GameflipAPI.listing_search(digital=True, limit=1)
+pprint(listing_response.json())
+
+gameflip_api = GameflipAPI(os.getenv('GFAPI_KEY'), os.getenv('GFAPI_SECRET'))
+
+print("My profile info:")
+
+pprint(gameflip_api.profile().json())
+```
+
+## 📦 Estrutura do Projeto
+
+* `src/gameflip_api/` — código-fonte da biblioteca
+* `example.py` — script de demonstração de uso
+* `test.py` — arquivo para testes rápidos
+* `requirements.txt` — dependências do Python
+
+## 🤝 Contato
+
+Se tiver dúvidas, sugestões ou quiser colaborar:
+
+* Crie uma *issue* no próprio repositório
+* Envie um pull request com descrições claras das alterações

gameflip_api-1.0.1/README.md

@@ -0,0 +1,70 @@
+# Gameflip API
+
+Uma **API wrapper em Python** para utilização com a plataforma Gameflip.
+Facilita a integração via script, para automatizar operações, consultar dados e interagir com a Gameflip de forma programática.
+
+## 🧰 Funcionalidades
+
+* Conexão autenticada com a Gameflip via chave e segredo (`API_KEY`, `API_SECRET`)
+* Métodos para executar operações comuns (por exemplo: listagem de produtos, criação de ofertas, consulta de histórico)
+* Interface simples em Python para agilizar automações
+* Código open-source, fácil de estender para necessidades específicas
+
+## 🚀 Começando
+
+### Pré-requisitos
+
+* Python (versão compatível — idealmente 3.8+)
+* Conta na Gameflip e acesso à API (chave + segredo)
+* Variáveis de ambiente configuradas:
+
+  ```bash
+  export GFAPI_KEY=<sua_chave_aqui>
+  export GFAPI_SECRET=<seu_segredo_aqui>
+  ```
+
+  (No Windows: `set GFAPI_KEY=<…>`, `set GFAPI_SECRET=<…>`)
+
+### Instalação
+
+```bash
+pip install gameflip-api
+```
+
+### Uso básico
+
+Exemplo no arquivo `example.py` (ajuste conforme a sua necessidade):
+
+```python
+import os
+from pprint import pprint
+from dotenv import load_dotenv
+from gameflip_api.api import GameflipAPI
+
+load_dotenv()
+
+print("Listing results:")
+
+listing_response = GameflipAPI.listing_search(digital=True, limit=1)
+pprint(listing_response.json())
+
+gameflip_api = GameflipAPI(os.getenv('GFAPI_KEY'), os.getenv('GFAPI_SECRET'))
+
+print("My profile info:")
+
+pprint(gameflip_api.profile().json())
+```
+
+## 📦 Estrutura do Projeto
+
+* `src/gameflip_api/` — código-fonte da biblioteca
+* `example.py` — script de demonstração de uso
+* `test.py` — arquivo para testes rápidos
+* `requirements.txt` — dependências do Python
+
+## 🤝 Contato
+
+Se tiver dúvidas, sugestões ou quiser colaborar:
+
+* Crie uma *issue* no próprio repositório
+* Envie um pull request com descrições claras das alterações

gameflip_api-1.0.1/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "gameflip-api"
+version = "1.0.1"
+description = "Uma API wrapper em Python para utilização com a plataforma Gameflip."
+authors = [{ name="Gustavo Pedroso Bernardes", email="gpedrosobernardes@gmail.com" }]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["validators", "pydantic", "pyotp", "requests"]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pydantic-pycharm-plugin.parsable-types]
+"src.gameflip_api.types.AwsCognitoUUID" = ["str"]

gameflip_api-1.0.1/setup.cfg

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

gameflip_api-1.0.1/src/gameflip_api/api.py

@@ -0,0 +1,136 @@
+from pathlib import Path
+
+import requests
+import pyotp
+
+from gameflip_api.enums import ListingOps, ListingPhotoStatus
+from gameflip_api.params import GameflipAPIParams, UUIDParam, ListingPostParams, Op, ExchangeParams, ExchangePostParams, \
+    OwnerParam, ListingSearchParams
+import validators
+
+
+class GameflipAPI:
+    __api = 'https://production-gameflip.fingershock.com/api/v1'
+
+    def __init__(self, api_key, secret):
+        GameflipAPIParams(api_key=api_key, secret=secret)
+        self.__api_key = api_key
+        self.__secret = secret
+        self.__totp = pyotp.TOTP(secret)
+
+    def __get_auth_header(self):
+        return {"Authorization": f"GFAPI {self.__api_key}:{self.__totp.now()}"}
+
+    def profile(self, owner = 'me'):
+        if owner != 'me':
+            # noinspection PyTypeChecker
+            OwnerParam(owner=owner)
+        return requests.get(f"{self.__api}/account/{owner}/profile", headers=self.__get_auth_header())
+
+    def wallet_history(self):
+        return requests.get(f"{self.__api}/account/me/wallet_history", headers=self.__get_auth_header())
+
+    @staticmethod
+    def get_rldata_items():
+        return requests.get("https://gameflip.com/api/gameitem/inventory/812872018935")
+
+    @classmethod
+    def listing_search(cls, params = None, **kwargs):
+        if params is None:
+            params = ListingSearchParams(**kwargs)
+        elif not isinstance(params, ListingSearchParams):
+            raise TypeError("params must be of type ListingPostParams.")
+        return requests.get(f"{cls.__api}/listing", params.model_dump(exclude_none=True))
+
+    def my_listing_search(self, params = None, **kwargs):
+        if params is None:
+            params = ListingSearchParams(**kwargs)
+        elif not isinstance(params, ListingSearchParams):
+            raise TypeError("params must be of type ListingPostParams.")
+        return requests.get(f"{self.__api}/listing", params.model_dump(exclude_none=True),
+                            headers=self.__get_auth_header())
+
+    @classmethod
+    def listing_of(cls, uuid):
+        UUIDParam(uuid=uuid)
+        return requests.get(f"{cls.__api}/listing/{uuid}")
+
+    def my_listing_of(self, uuid):
+        UUIDParam(uuid=uuid)
+        return requests.get(f"{self.__api}/listing/{uuid}", headers=self.__get_auth_header())
+
+    def listing_post(self, params = None, **kwargs):
+        if params is None:
+            params = ListingPostParams(**kwargs)
+        elif not isinstance(params, ListingPostParams):
+            raise TypeError("params must be of type ListingPostParams.")
+        return requests.post(
+            f"{self.__api}/listing",
+            params.model_dump(exclude_none=True),
+            headers=self.__get_auth_header()
+        )
+
+    def listing_delete(self, uuid):
+        UUIDParam(uuid=uuid)
+        return requests.delete(f"{self.__api}/listing/{uuid}", headers=self.__get_auth_header())
+
+    def listing_patch(self, uuid, ops):
+        UUIDParam(uuid=uuid)
+        ops_objects = map(lambda op: op if isinstance(op, Op) else Op(**op), ops)
+        ops_json = list(map(lambda op: op.model_dump(mode="json"), ops_objects))
+        headers = {"Content-Type": "application/json-patch+json"}
+        headers.update(self.__get_auth_header())
+        return requests.patch(f"{self.__api}/listing/{uuid}", json=ops_json, headers=headers)
+
+    def post_photo(self, listing_uuid, photo, display_order):
+        if not (isinstance(photo, Path) or isinstance(photo, str)):
+            raise TypeError("Photo must be of type Path or str.")
+
+        if isinstance(photo, str) and validators.url(photo):
+            photo_request = requests.get(photo)
+            photo_request.raise_for_status()
+            photo_data = photo_request.content
+            mime_type = photo_request.headers.get("Content-Type", "application/octet-stream")
+        else:
+            if isinstance(photo, Path):
+                photo_path = photo
+            else:
+                photo_path = Path(photo)
+            if not photo_path.exists() or not photo_path.is_file():
+                raise FileNotFoundError(f"File not found: {photo}")
+            photo_data = open(photo_path, "rb")
+            mime_type = photo_path.suffix[1:]
+
+        post_photo_request = requests.post(f"{self.__api}/listing/{listing_uuid}/photo", headers=self.__get_auth_header())
+        post_photo_request.raise_for_status()
+        post_photo_data = post_photo_request.json()['data']
+        upload_photo_url = post_photo_data['upload_url']
+        photo_id = post_photo_data['id']
+
+        put_photo_headers = {'Content-Type': f'image/{mime_type}'}
+        put_photo_request = requests.put(upload_photo_url, headers=put_photo_headers, data=photo_data)
+        put_photo_request.raise_for_status()
+
+        ops = [Op(op=ListingOps.REPLACE, path=f'/photo/{photo_id}/status', value=ListingPhotoStatus.ACTIVE)]
+
+        if display_order >= 0:
+            ops.append(Op(op=ListingOps.REPLACE, path=f'/photo/{photo_id}/display_order', value=display_order))
+        else:
+            ops.append(Op(op=ListingOps.REPLACE, path=f'/cover_photo', value=photo_id))
+
+        listing_patch_request = self.listing_patch(listing_uuid, ops)
+        listing_patch_request.raise_for_status()
+
+    def exchange_search(self, params = None, **kwargs):
+        if params is None:
+            params = ExchangeParams(**kwargs)
+        elif not isinstance(params, ExchangeParams):
+            raise TypeError("params must be of type ExchangeParams.")
+        return requests.get(f"{self.__api}/exchange", params.model_dump(mode='json'), headers=self.__get_auth_header())
+
+    def exchange_post(self, params = None, **kwargs):
+        if params is None:
+            params = ExchangePostParams(**kwargs)
+        elif not isinstance(params, ExchangePostParams):
+            raise TypeError("params must be of type ExchangePostParams.")
+        return requests.post(f"{self.__api}/exchange", json=params.model_dump(mode='json'), headers=self.__get_auth_header())

gameflip_api-1.0.1/src/gameflip_api/api.pyi

@@ -0,0 +1,332 @@
+import datetime
+import typing
+from pathlib import Path
+from uuid import UUID
+
+import pyotp
+import requests
+
+from gameflip_api.enums import ShippingPaidBy, Category, Platform, UPC, ListingStatus, AcceptCurrency, Visibility
+from gameflip_api.params import PriceRange, DatetimeRange, ListingSearchParams, ListingPostParams, Op, ExchangeParams, \
+    IntRange, ExchangePostParams
+
+
+class GameflipAPI:
+    __api: str
+    __api_key: str
+    __secret: str
+    __totp: pyotp.totp.TOTP
+
+    def __init__(self, api_key: str, secret: str) -> None:
+        """
+        Generates the totp to get authorization for requests.
+        :param api_key: API Key is located at developer tab on your profile.
+        :param secret: The secret is generated on API Key creation.
+        """
+        ...
+
+    def __get_auth_header(self) -> dict: ...
+
+    def profile(self, uuid: typing.Union[str, UUID] = 'me') -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch user profile information, which you can get your own information.
+        :param uuid: The id is on the url of any profile, it usually starts with 'us-east' and ends with a bunt of numbers.
+        To fetch data from your own profile you can set the id with 'me'.
+        :raise pydantic.error_wrappers.ValidationError: If id_ is empty or not a string.
+        :return: requests.Response
+        """
+        ...
+
+    def wallet_history(self) -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch your wallet history.
+        :return: requests.Response
+        """
+        ...
+
+    @staticmethod
+    def get_rldata_items() -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch Rocket League items data.
+        :return: requests.Response
+        """
+        ...
+
+    @classmethod
+    @typing.overload
+    def listing_search(cls, params: ListingSearchParams) -> requests.Response: ...
+
+    @classmethod
+    @typing.overload
+    def listing_search(
+        cls,
+        *,
+        term: typing.Optional[str] = None,
+        category: typing.Optional[Category] = None,
+        platform: typing.Optional[Platform] = None,
+        genre: typing.Optional[str] = None,
+        upc: typing.Optional[UPC] = None,
+        shipping_paid_by: typing.Optional[ShippingPaidBy] = None,
+        digital: typing.Optional[bool] = None,
+        status: typing.Optional[ListingStatus] = None,
+        owner: typing.Optional[str] = None,
+        condition: typing.Optional[str] = None,
+        condition_min: typing.Optional[str] = None,
+        price: typing.Optional[PriceRange] = None,
+        created: typing.Optional[DatetimeRange] = None,
+        updated: typing.Optional[DatetimeRange] = None,
+        expiration: typing.Optional[DatetimeRange] = None,
+        seller_online_until: typing.Optional[datetime.datetime] = None,
+        tags: typing.Optional[str] = None,
+        start: typing.Optional[int] = None,
+        limit: typing.Optional[int] = None
+    ) -> requests.Response:
+        """
+        Makes a get to /api/v1/listing
+        ::param term: Searches listing name and description and generates relevance score
+        ::param category: Filters category
+        ::param platform: Filters platform
+        ::param genre: Filters genre
+        ::param upc: Filters UPC (Universal Product Code), games in this case
+        ::param shipping_paid_by: Filters shipping paid by
+        ::param digital: Filters if it's a digital listing
+        ::param status: Filters status
+        ::param owner: Filters owner
+        ::param condition: Filters condition
+        ::param condition_min: Filters condition (any one value defined for condition)
+        ::param price: Filters price
+        ::param created: Filters in a range when it has been created
+        ::param updated: Filters in a range when it has been updated
+        ::param expiration: Filters in a range for its expiration
+        ::param seller_online_until: Filters sellers online
+        ::param tags: A special term filter which also allows logical AND using the carrot ^ operator in addition
+                to logical OR with comma ,
+                Precedence is given to OR operations over AND so that a filter like tags=a,b^c^d,e will match all
+                listings that have (a OR b) AND (c) AND (d OR e).
+        ::param start: Gets listing by page number
+        ::param limit: Limit the number of listings returned
+        ::raise pydantic.error_wrappers.ValidationError: If some parameter is not correct type
+        ::raise TypeError: params is not ListingPostParams neither None
+        ::return requests.Response: Returns a response object
+        """
+        ...
+
+    @typing.overload
+    def my_listing_search(self, params: ListingSearchParams) -> requests.Response: ...
+
+    @typing.overload
+    def my_listing_search(
+        self,
+        *,
+        term: typing.Optional[str] = None,
+        category: typing.Optional[Category] = None,
+        platform: typing.Optional[Platform] = None,
+        genre: typing.Optional[str] = None,
+        upc: typing.Optional[UPC] = None,
+        shipping_paid_by: typing.Optional[ShippingPaidBy] = None,
+        digital: typing.Optional[bool] = None,
+        status: typing.Optional[ListingStatus] = None,
+        owner: typing.Optional[str] = None,
+        condition: typing.Optional[str] = None,
+        condition_min: typing.Optional[str] = None,
+        price: typing.Optional[PriceRange] = None,
+        created: typing.Optional[DatetimeRange] = None,
+        updated: typing.Optional[DatetimeRange] = None,
+        expiration: typing.Optional[DatetimeRange] = None,
+        seller_online_until: typing.Optional[datetime.datetime] = None,
+        tags: typing.Optional[str] = None,
+        start: typing.Optional[int] = None,
+        limit: typing.Optional[int] = None
+    ) -> requests.Response:
+        """
+        Makes a get to /api/v1/listing
+        ::param term: Searches listing name and description and generates relevance score
+        ::param category: Filters category
+        ::param platform: Filters platform
+        ::param genre: Filters genre
+        ::param upc: Filters UPC (Universal Product Code), games in this case
+        ::param shipping_paid_by: Filters shipping paid by
+        ::param digital: Filters if it's a digital listing
+        ::param status: Filters status
+        ::param owner: Filters owner
+        ::param condition: Filters condition
+        ::param condition_min: Filters condition (any one value defined for condition)
+        ::param price: Filters price
+        ::param created: Filters in a range when it has been created
+        ::param updated: Filters in a range when it has been updated
+        ::param expiration: Filters in a range for its expiration
+        ::param seller_online_until: Filters sellers online
+        ::param tags: A special term filter which also allows logical AND using the carrot ^ operator in addition
+                to logical OR with comma ,
+                Precedence is given to OR operations over AND so that a filter like tags=a,b^c^d,e will match all
+                listings that have (a OR b) AND (c) AND (d OR e).
+        ::param start: Gets listing by page number
+        ::param limit: Limit the number of listings returned
+        ::raise pydantic.error_wrappers.ValidationError: If some parameter is not correct type
+        ::raise TypeError: params is not ListingPostParams neither None
+        ::return requests.Response: Returns a response object
+        """
+        ...
+
+    @classmethod
+    def listing_of(cls, uuid: typing.Union[str, UUID]) -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch listing information.
+        :param uuid: The id is on the url of any listing, it usually made with a bunt of numbers.
+        :raise pydantic.error_wrappers.ValidationError: If id_ is empty or not a string.
+        :return: requests.Response
+        """
+        ...
+
+    def my_listing_of(self, uuid: typing.Union[str, UUID]) -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch listing information. Can fetch your own private listing.
+        :param uuid: The id is on the url of any listing, it usually made with a bunt of numbers.
+        :raise pydantic.error_wrappers.ValidationError: If id_ is empty or not a string.
+        :return: requests.Response
+        """
+        ...
+
+    @typing.overload
+    def listing_post(self, params: ListingPostParams) -> requests.Response: ...
+
+    @typing.overload
+    def listing_post(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        description: typing.Optional[str] = None,
+        price: typing.Optional[int] = None,
+        category: typing.Optional[Category] = None,
+        upc: typing.Optional[UPC] = None,
+        accept_currency: AcceptCurrency = AcceptCurrency.USD,
+        digital: bool = False,
+        visibility: Visibility = Visibility.PUBLIC
+    ) -> requests.Response:
+        """
+        Makes a post to /api/v1/listing to create a new listing
+        :param name: Name of listing
+        :param description: Description of listing
+        :param price: Price of listing
+        :param category: Category of listing
+        :param upc: UPC of listing
+        :param accept_currency: Accept currency of the listing
+        :param digital: Specifies if it's a digital listing
+        :param visibility: Visibility of listing
+        :raise pydantic.error_wrappers.ValidationError: If some parameter is not correct type or price is invalid
+        :return: requests.Response
+        """
+        ...
+
+    def listing_delete(self, uuid: typing.Union[str, UUID]) -> requests.Response:
+        """
+        Makes a request to the gameflip API to delete a listing
+        :param uuid: The id of the listing
+        :return: requests.Response
+        """
+        ...
+
+    def listing_patch(self, uuid: typing.Union[str, UUID], ops: typing.List[typing.Union[Op, typing.Dict]]) -> requests.Response:
+        """
+        Makes a request to the gameflip API to update a listing
+        :param uuid: The id of the listing
+        :param ops: Operations to apply
+        :return: requests.Response
+        """
+        ...
+
+    def post_photo(self, listing_uuid: typing.Union[str, UUID], photo: typing.Union[str, Path], display_order: int):
+        """
+        Makes a serie of requests to update a listing photo
+        :param listing_uuid: The id of the listing
+        :param photo: Url or Path for the photo
+        :param display_order: Display order of the photo
+        :raise TypeError: photo is not a string or a Path
+        :raise HTTPError: some request goes wrong
+        :raise FileNotFoundError: photo path not found or don't exist
+        :return: None
+        """
+        ...
+
+    @typing.overload
+    def exchange_search(self, params: ExchangeParams) -> requests.Response: ...
+
+    @typing.overload
+    def exchange_search(
+        self,
+        *,
+        role: typing.Optional[ShippingPaidBy] = None,
+        id: typing.Optional[str, UUID] = None,
+        name: typing.Optional[str] = None,
+        buyer: typing.Optional[str] = None,
+        seller: typing.Optional[str] = None,
+        price: typing.Optional[PriceRange] = None,
+        risk: typing.Optional[IntRange] = None,
+        status: typing.Optional[ShippingPaidBy] = None,
+        start: typing.Optional[int] = None,
+        buyer_rated: typing.Optional[bool] = None,
+        seller_rated: typing.Optional[bool] = None,
+        category: typing.Optional[Category] = None,
+        upc: typing.Optional[UPC] = None,
+        digital: typing.Optional[bool] = None,
+        escrow: typing.Optional[bool] = None,
+        settled: typing.Optional[DatetimeRange] = None,
+        shipped: typing.Optional[DatetimeRange] = None,
+        received: typing.Optional[DatetimeRange] = None,
+        auto_rate_after: typing.Optional[DatetimeRange] = None,
+        created: typing.Optional[DatetimeRange] = None,
+        updated: typing.Optional[DatetimeRange] = None,
+        version: typing.Optional[int] = None,
+        limit: typing.Optional[int] = None,
+    ) -> requests.Response:
+        """
+        Makes a request to the gameflip API to fetch exchange
+        ::param role: buyer or seller
+        ::param id: uuid of the exchange
+        ::param name: Name of listing
+        ::param buyer: uuid of the buyer
+        ::param seller: uuid of the seller
+        ::param price: price range of the exchange
+        ::param risk: risk range of the exchange
+        ::param status: status of the exchange
+        ::param start: start page of the fetch
+        ::param buyer_rated: buyer rated (True/False)
+        ::param seller_rated: seller rated (True/False)
+        ::param category: category of the listing
+        ::param upc: UPC of the listing
+        ::param digital: specifies if it's a digital listing
+        ::param escrow: specifies if it's exchange with escrow
+        ::param settled: settled time range of the listing
+        ::param shipped: shipped time range of the listing
+        ::param received: received time range of the listing
+        ::param auto_rate_after: time range
+        ::param created: time range of the listing
+        ::param updated: time range of the listing
+        ::param version: version of the exchange
+        ::param limit: limit the fetch
+        ::raise pydantic.error_wrappers.ValidationError: If some parameter is not correct type
+        ::raise TypeError: params is not ExchangeParams neither None
+        :return: requests.Response
+        """
+        ...
+
+    @typing.overload
+    def exchange_post(self, params: ExchangePostParams) -> requests.Response: ...
+
+    @typing.overload
+    def exchange_post(
+        self,
+        *,
+        listing_id: typing.Union[str, UUID],
+        source_id: typing.Union[str, UUID],
+        address_id: typing.Union[str, UUID],
+    ):
+        """
+        Makes a request to the gameflip API to buy a listing
+        :param listing_id: listing id
+        :param source_id: source id
+        :param address_id: address id
+        ::raise pydantic.error_wrappers.ValidationError: If some parameter is not correct type
+        ::raise TypeError: params is not ExchangePostParams neither None
+        :return: requests.Response
+        """

gameflip_api-1.0.1/src/gameflip_api/enums.py

@@ -0,0 +1,214 @@
+from enum import Enum
+
+class ShippingPaidBy(str, Enum):
+    BUYER = "buyer"
+    SELLER = "seller"
+
+
+class Category(str, Enum):
+    GAMES = 'CONSOLE_VIDEO_GAMES'  # Video games, digital or physical
+    INGAME = 'DIGITAL_INGAME'  # In-game items, digital only
+    GIFTCARD = 'GIFTCARD'  # Gift cards, digital or physical
+    CONSOLE = 'VIDEO_GAME_HARDWARE'  # Console game hardware, physical listing only
+    ACCESSORIES = 'VIDEO_GAME_ACCESSORIES'  # Console game accessories, physical listing only
+    TOYS = 'TOYS_AND_GAMES'  # Collectibles, physical listing only
+    VIDEO = 'VIDEO_DVD'  # Movies, physical or digital
+    OTHER = 'UNKNOWN'  # Unsupported category
+
+
+class Kind(str, Enum):
+    ITEM = 'item'  # Item selling
+    GIG = 'gig'  # Gig selling
+
+
+class UPC(str, Enum):
+    ANIMAL_CROSSING_NH = "045496596439"
+    BORDERLANDS3_PC = "GFPCBDLANDS3"
+    BORDERLANDS3_PS4 = "GFPSBDLANDS3"
+    BORDERLANDS3_XONE = "GFXOBDLANDS3"
+    BRAWLHALLA = "045496663285"
+    BRAWL_STARS = "GFBRAWLSTARS"
+    CLASH_OF_CLANS = "GFCLASHOCLAN"
+    CLASH_ROYALE = "GFCLASHROYAL"
+    COD_BLOPS6 = "7340f6b6-3a5a-4737-9033-237b9fb522ca"
+    COD_MWII = "GF0000CODMW2"
+    COD_MWIII = "GF0000CODMW3"
+    COD_WZ = "GF00000CODWZ"
+    CS2 = "094922417596"
+    DARK_AND_DARKER = "GF00DADARKER"
+    DARK_SOULS_3 = "GFDARKSOULS3"
+    DCU_ONLINE = "GF000000DCUO"
+    DEAD_BY_DAYLIGHT = "GFDBDAYLIGHT"
+    DIABLO_4 = "GF000DIABLO4"
+    DOTA2 = "111111111111"
+    DRAGONS_DOGMA_2 = "GFDRAGONSDM2"
+    DREAMLIGHT_VALLEY = "GFDREAMLIGHT"
+    DYING_LIGHT_2_PS4 = "662248923314"
+    DYING_LIGHT_2_PS5 = "662248924915"
+    DYING_LIGHT_2_XONE = "662248923369"
+    DYING_LIGHT_2_XSERIES = "662248924823"
+    ELDEN_RING_PC = "GF000ERINGPC"
+    ELDEN_RING_PS5 = "GF000ERINGPS"
+    ELDEN_RING_XSERIES = "GF000ERINGXS"
+    ENSHROUDED = "GFENSHROUDED"
+    ESO_PC = "GF00000PCESO"
+    ESO_PS5 = "GF00000PSESO"
+    ESO_XSERIES = "GF00000XSESO"
+    EVE_ONLINE = "GF0000000EVE"
+    FALLOUT76_PC = "GFPCFLLOUT76"
+    FALLOUT76_PS4 = "GFPSFLLOUT76"
+    FALLOUT76_XONE = "GFXOFLLOUT76"
+    FIFA = "GF000000FIFA"
+    FORTNITE = "GFFORTNITE"
+    GROWTOPIA = "GF0GROWTOPIA"
+    GTA5_PC = "710425414534"
+    GTA5_PS4 = "710425474521"
+    GTA5_PS5 = "GF000GTA5PS5"
+    GTA5_XONE = "710425494512"
+    GTA5_XSERIES = "GF000GTA5XSX"
+    HALO_INFINITE = "GF000HALOINF"
+    HAY_DAY = "GF0000HAYDAY"
+    LEAGUE_OF_LEGENDS = "GF0000000LOL"
+    LORDS_OF_THE_FALLEN = "GFLORDFALLEN"
+    MADDEN = "GF0000MADDEN"
+    MONOPOLY_GO = "GFMONOPOLYGO"
+    NO_MANS_SKY = "GF0NOMANSSKY"
+    PATH_OF_EXILE = "GF000POEXILE"
+    PATH_OF_EXILE_2 = "6ce9c6d3-c32d-4037-9554-3f1f9de866bd"
+    POKEMON_DIAMOND_PEARL = "045496597894"
+    POKEMON_LEGENDS_ARCEUS = "045496598044"
+    POKEMON_SCARLET_VIOLET = "045496599058"
+    POKEMON_SWORD_SHIELD = "045496596972"
+    PUBG = "000000578080"
+    PUBG_MOBILE = "GF00PUBGMOBI"
+    RUNESCAPE = "GF0RUNESCAPE"
+    RUST = "000000252490"
+    RUST_CONSOLE = "GFRUSTCONSOL"
+    SEA_OF_THIEVES = "GFSEATHIEVES"
+    SKULL_BONES = "GFSKULLBONES"
+    STATE_OF_DECAY_2 = "GF00SODECAY2"
+    SWTOR = "GF00000SWTOR"
+    TF2 = "014633098693"
+    TINY_TINAS_WONDERLANDS = "GF00TTWONDER"
+    WARFRAME_PC = "GFSTWARFRAME"
+    WARFRAME_PS = "GFPSWARFRAME"
+    WARFRAME_SWITCH = "GFSWWARFRAME"
+    WARFRAME_XBOX = "GFXOWARFRAME"
+    WORLD_OF_WARCRAFT = "GF000WOW0000"
+    XDEFIANT = "GF00XDEFIANT"
+
+
+class Platform(str, Enum):
+    XBOX = 'xbox'
+    X360 = 'xbox_360'
+    XONE = 'xbox_one'
+    PS1 = 'playstation'
+    PS2 = 'playstation_2'
+    PS3 = 'playstation_3'
+    PS4 = 'playstation_4'
+    PSP = 'playstation_portable'
+    PSVITA = 'playstation_vita'
+    N64 = 'nintendo_64'
+    NGAMECUBE = 'nintendo_gamecube'
+    NWII = 'nintendo_wii'
+    NWIIU = 'nintendo_wiiu'
+    NSWITCH = 'nintendo_switch'
+    NDS = 'nintendo_ds'
+    NDSI = 'nintendo_dsi'
+    N3DS = 'nintendo_3ds'
+    STEAM = 'steam'
+    ORIGIN = 'origin'
+    UPLAY = 'uplay'
+    GOG = 'gog'
+    MOBILE = 'mobile'
+    BATTLENET = 'battlenet'
+    XLIVE = 'xbox_live'
+    PSN = 'playstation_network'
+    UNKNOWN = 'unknown'  # For PC platform, use UNKNOWN
+
+
+class ShippingWithinDays(int, Enum):
+    AUTO = 0
+    ONE = 1
+    TWO = 2
+    THREE = 3
+
+
+class ExpireInDays(int, Enum):
+    SEVEN = 7
+    FOURTEEN = 14
+    THIRTY = 30
+
+
+class EscrowStatus(str, Enum):
+    START = 'start'  # Initial condition: seller has Steam item(s)
+    RECEIVE_PENDING = 'receive_pending'  # Offer made to seller to get Steam item(s)
+    RECEIVED = 'received'  # Gameflip has Steam item(s)
+    LISTED = 'listed'  # Gameflip has created listings for Steam item(s)
+    STEAM_ESCROW = 'steam_escrow'  # Steam item(s) is held by Steam in escrow
+    TRADE_HOLD = 'trade_hold'  # Gameflip has item(s) but there is a trade hold on them (e.g., Just Survive)
+    DELIVER_PENDING = "deliver_pending"  # Escrow status: Offer made to buyer, but not accepted yet
+    DELIVERED = "delivered"  # Escrow status: Buyer has item (terminal state)
+    RETURN_PENDING = "return_pending"  # Escrow status: Trade offer made to seller to return item, but not accepted yet
+    RETURNED = "returned"  # Escrow status: Seller has accepted return of item
+
+
+class ListingStatus(str, Enum):
+    DRAFT = "draft"  # Listing is draft/editing mode. You cannot list it when it's in this mode
+    READY = "ready"  # Listing is ready to be listed, required fields have been filled
+    ONSALE = "onsale"  # Listing is published to the public
+    SALE_PENDING = "sale_pending"  # A buyer just bought the listing, and payment is being processed
+    SOLD = "sold"  # A buyer had bought the listing
+
+
+class ListingPhotoStatus(str, Enum):
+    PENDING = "pending"
+    ACTIVE = "active"
+    DELETED = "deleted"
+
+
+class ListingOps(str, Enum):
+    TEST = "test"
+    ADD = "add"
+    REPLACE = "replace"
+    REMOVE = "remove"
+
+
+class ExchangeStatus(str, Enum):
+    PENDING = "pending"  # Exchange is being created
+    PENDING_CANCEL = "pending_cancel"  # Exchange is being canceled
+    PENDING_RESCINDING = "pending_rescinding"  # Exchange is being refunded
+    SETTLED = "settled"  # Exchange has payment settled (verified and approved)
+    RECEIVED = "received"  # Buyer has received the item
+    PENDING_COMPLETION = "pending_completion"  # Exchange is being completed, happens after seller rates
+    COMPLETE = "complete"  # Exchange completes, both buyer and seller have rated each other
+    CANCELLED = "cancelled"  # Exchange has been cancelled, and payment authorization (if any) is also cancelled
+    RESCINDED = "rescinded"  # Exchange has been cancelled with refund completed
+
+
+class AcceptCurrency(str, Enum):
+    USD = "USD"
+    FLP = "FLP"
+    BOTH = "BOTH"
+
+
+# Steam APP IDs and Context IDs can be defined in a similar manner if needed.
+class SteamAppID(str, Enum):
+    CSGO = '730'  # CS:GO
+    TF2 = '440'  # Team Fortress 2
+    DOTA2 = '570'  # DOTA 2
+    RUST = '252490'  # Rust
+    PUBG = '578080'  # PlayerUnknown's Battlegrounds
+    H1Z1_KOK = '433850'  # H1Z1: King of the Kill
+    JUST_SURVIVE = '295110'  # H1Z1: Just Survive
+
+
+class SteamContextID(str, Enum):
+    CONTEXT_ID_433850 = '1'  # H1Z1: King of the Kill
+    CONTEXT_ID_295110 = '1'  # Just Survive
+    CONTEXT_ID_DEFAULT = '2'  # Default if not specified above
+
+
+class Visibility(str, Enum):
+    UNLISTED = 'unlisted'
+    PUBLIC = 'public'

gameflip_api-1.0.1/src/gameflip_api/params.py

@@ -0,0 +1,134 @@
+import datetime
+import typing
+from uuid import UUID
+
+from pydantic import BaseModel, Field, field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from gameflip_api.enums import Category, Platform, UPC, ShippingPaidBy, ListingStatus, AcceptCurrency, Visibility, \
+    ListingOps
+from gameflip_api.types import AwsCognitoUUID, Price
+
+T = typing.TypeVar("T")
+
+class Range(BaseModel, typing.Generic[T]):
+    start: T
+    end: T
+
+    @field_validator("end", mode="after")
+    @classmethod
+    def check_end_after_start(cls, value: int, info: ValidationInfo) -> int:
+        if "start" in info.data and value < info.data["start"]:
+            raise ValueError("start must be greater or equal to end.")
+        return value
+
+    def __str__(self):
+        return f"{self.start},{self.end}"
+
+
+class IntRange(Range[int]):
+    pass
+
+
+class PriceRange(Range[Price]):
+    pass
+
+
+class DatetimeRange(Range[datetime.datetime]):
+    def __str__(self):
+            return f"{self.__format_datetime(self.start)},{self.__format_datetime(self.end)}"
+
+    @staticmethod
+    def __format_datetime(datetime_: datetime.datetime):
+        return datetime_.isoformat(timespec='milliseconds') + "Z"
+
+
+class ListingSearchParams(BaseModel):
+    term: typing.Optional[str] = None
+    category: typing.Optional[Category] = None
+    platform: typing.Optional[Platform] = None
+    genre: typing.Optional[str] = None
+    upc: typing.Optional[UPC] = None
+    shipping_paid_by: typing.Optional[ShippingPaidBy] = None
+    digital: typing.Optional[bool] = None
+    status: typing.Optional[ListingStatus] = None
+    owner: typing.Optional[str] = None
+    condition: typing.Optional[str] = None
+    condition_min: typing.Optional[str] = None
+    price: typing.Optional[PriceRange] = None
+    created: typing.Optional[DatetimeRange] = None
+    updated: typing.Optional[DatetimeRange] = None
+    expiration: typing.Optional[DatetimeRange] = None
+    seller_online_until: typing.Optional[DatetimeRange] = None
+    tags: typing.Optional[str] = None
+    start: typing.Optional[int] = None
+    limit: typing.Optional[int] = None
+
+    def model_dump(self, *args, **kwargs):
+        d = super().model_dump(*args, **kwargs)
+        for attr in ["price", "created", "updated", "expiration", "seller_online_until"]:
+            if d.get(attr) is not None:
+                d[attr] = str(getattr(self, attr))
+        return d
+
+
+class ListingPostParams(BaseModel):
+    name: typing.Optional[str] = None
+    description: typing.Optional[str] = None
+    price: typing.Optional[Price] = None
+    category: typing.Optional[Category] = None
+    upc: typing.Optional[UPC] = None
+    accept_currency: AcceptCurrency = AcceptCurrency.USD
+    digital: bool = False
+    visibility: Visibility = Visibility.PUBLIC
+
+
+class GameflipAPIParams(BaseModel):
+    api_key: str = Field(..., min_length=1, description="API key is required.")
+    secret: str = Field(..., min_length=1, description="Secret is required.")
+
+
+class UUIDParam(BaseModel):
+    uuid: UUID
+
+
+class OwnerParam(BaseModel):
+    owner: AwsCognitoUUID
+
+
+class Op(BaseModel):
+    op: ListingOps
+    path: str
+    value: typing.Any
+
+
+class ExchangeParams(BaseModel):
+    role: typing.Optional[ShippingPaidBy] = None
+    id: typing.Optional[UUID] = None
+    name: typing.Optional[str] = None
+    buyer: typing.Optional[str] = None
+    seller: typing.Optional[str] = None
+    price: typing.Optional[PriceRange] = None
+    risk: typing.Optional[IntRange] = None
+    status: typing.Optional[ListingStatus] = None
+    buyer_rated : typing.Optional[bool] = None
+    seller_rated : typing.Optional[bool] = None
+    start: typing.Optional[int] = None
+    category: typing.Optional[Category] = None
+    upc: typing.Optional[UPC] = None
+    digital: typing.Optional[bool] = None
+    escrow: typing.Optional[bool] = None
+    settled: typing.Optional[DatetimeRange] = None
+    shipped: typing.Optional[DatetimeRange] = None
+    received: typing.Optional[DatetimeRange] = None
+    auto_rate_after: typing.Optional[DatetimeRange] = None
+    created: typing.Optional[DatetimeRange] = None
+    updated: typing.Optional[DatetimeRange] = None
+    version: typing.Optional[int] = None
+    limit: typing.Optional[int] = None
+
+
+class ExchangePostParams(BaseModel):
+    listing_id: UUID
+    source_id: UUID
+    address_id: UUID

gameflip_api-1.0.1/src/gameflip_api/types.py

@@ -0,0 +1,60 @@
+import re
+from uuid import UUID
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+
+class AwsCognitoUUID(str):
+    """
+    Tipo customizado que valida strings no formato:
+    <region>:<uuid>
+    Exemplo: us-east-1:dc501f75-302c-4419-8ece-57974d688e6f
+    """
+
+    pattern = re.compile(
+        r"^[a-z]{2}-[a-z]+-\d+:[0-9a-fA-F-]{36}$"
+    )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type, _handler: GetCoreSchemaHandler):
+        return core_schema.no_info_after_validator_function(
+            cls.validate,
+            core_schema.str_schema()
+        )
+
+    @classmethod
+    def validate(cls, value):
+        if not isinstance(value, str):
+            raise TypeError("valor should be string.")
+
+        if not cls.pattern.match(value):
+            raise ValueError("invalid format (expected '<region>:<uuid>')")
+
+        # Valida se a parte após ':' é um UUID válido
+        region, uuid_part = value.split(":", 1)
+        try:
+            UUID(uuid_part)
+        except ValueError:
+            raise ValueError("UUID invalid after ':'")
+
+        return cls(value)
+
+
+class Price(int):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type, _handler: GetCoreSchemaHandler):
+        return core_schema.no_info_after_validator_function(
+            cls.validate,
+            core_schema.int_schema()
+        )
+
+    @classmethod
+    def validate(cls, value):
+        if not isinstance(value, int):
+            raise TypeError("value should be int.")
+
+        if value < 75:
+            raise ValueError("value should be higher than 75.")
+
+        return cls(value)

gameflip_api-1.0.1/src/gameflip_api.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: gameflip-api
+Version: 1.0.1
+Summary: Uma API wrapper em Python para utilização com a plataforma Gameflip.
+Author-email: Gustavo Pedroso Bernardes <gpedrosobernardes@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: validators
+Requires-Dist: pydantic
+Requires-Dist: pyotp
+Requires-Dist: requests
+
+# Gameflip API
+
+Uma **API wrapper em Python** para utilização com a plataforma Gameflip.
+Facilita a integração via script, para automatizar operações, consultar dados e interagir com a Gameflip de forma programática.
+
+## 🧰 Funcionalidades
+
+* Conexão autenticada com a Gameflip via chave e segredo (`API_KEY`, `API_SECRET`)
+* Métodos para executar operações comuns (por exemplo: listagem de produtos, criação de ofertas, consulta de histórico)
+* Interface simples em Python para agilizar automações
+* Código open-source, fácil de estender para necessidades específicas
+
+## 🚀 Começando
+
+### Pré-requisitos
+
+* Python (versão compatível — idealmente 3.8+)
+* Conta na Gameflip e acesso à API (chave + segredo)
+* Variáveis de ambiente configuradas:
+
+  ```bash
+  export GFAPI_KEY=<sua_chave_aqui>
+  export GFAPI_SECRET=<seu_segredo_aqui>
+  ```
+
+  (No Windows: `set GFAPI_KEY=<…>`, `set GFAPI_SECRET=<…>`)
+
+### Instalação
+
+```bash
+pip install gameflip-api
+```
+
+### Uso básico
+
+Exemplo no arquivo `example.py` (ajuste conforme a sua necessidade):
+
+```python
+import os
+from pprint import pprint
+from dotenv import load_dotenv
+from gameflip_api.api import GameflipAPI
+
+load_dotenv()
+
+print("Listing results:")
+
+listing_response = GameflipAPI.listing_search(digital=True, limit=1)
+pprint(listing_response.json())
+
+gameflip_api = GameflipAPI(os.getenv('GFAPI_KEY'), os.getenv('GFAPI_SECRET'))
+
+print("My profile info:")
+
+pprint(gameflip_api.profile().json())
+```
+
+## 📦 Estrutura do Projeto
+
+* `src/gameflip_api/` — código-fonte da biblioteca
+* `example.py` — script de demonstração de uso
+* `test.py` — arquivo para testes rápidos
+* `requirements.txt` — dependências do Python
+
+## 🤝 Contato
+
+Se tiver dúvidas, sugestões ou quiser colaborar:
+
+* Crie uma *issue* no próprio repositório
+* Envie um pull request com descrições claras das alterações

gameflip_api-1.0.1/src/gameflip_api.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/gameflip_api/__init__.py
+src/gameflip_api/api.py
+src/gameflip_api/api.pyi
+src/gameflip_api/enums.py
+src/gameflip_api/params.py
+src/gameflip_api/types.py
+src/gameflip_api.egg-info/PKG-INFO
+src/gameflip_api.egg-info/SOURCES.txt
+src/gameflip_api.egg-info/dependency_links.txt
+src/gameflip_api.egg-info/requires.txt
+src/gameflip_api.egg-info/top_level.txt

gameflip_api-1.0.1/src/gameflip_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gameflip_api-1.0.1/src/gameflip_api.egg-info/requires.txt

@@ -0,0 +1,4 @@
+validators
+pydantic
+pyotp
+requests

gameflip_api-1.0.1/src/gameflip_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+gameflip_api