diff --git a/.env.example b/.env.example index 6cb65e4..ca82158 100644 --- a/.env.example +++ b/.env.example @@ -25,4 +25,9 @@ ACCOUNTS_BASE_PUBLIC_URL=https://accounts-staging.gooyal.ir WALLET_BASE_PUBLIC_URL=https://wallet-staging.gooyal.ir WALLET_RIAL=af7d967f-30c0-409b-9066-2549f2da5e5e WALLET_REWARD=e7c9d4d1-4d1f-43b2-96f7-4d4a168f480d -ADVERTISING_BASE_PUBLIC_URL=https://advertising-staging.winsoo.ir \ No newline at end of file +ADVERTISING_BASE_PUBLIC_URL=https://advertising-staging.winsoo.ir +CHAT_BASE_PUBLIC_URL= +NOTIFICATIONS_BASE_PUBLIC_URL= +PROMOTIONS_BASE_PUBLIC_URL= +CAMPAIGN_BASE_PUBLIC_URL= +IPG_BASE_PUBLIC_URL= \ No newline at end of file diff --git a/apps/proxy/__init__.py b/apps/proxy/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/apps/proxy/apps.py b/apps/proxy/apps.py new file mode 100644 index 0000000..3a7e36a --- /dev/null +++ b/apps/proxy/apps.py @@ -0,0 +1,6 @@ +from django.apps import AppConfig + + +class ProxyConfig(AppConfig): + default_auto_field = "django.db.models.BigAutoField" + name = "apps.proxy" diff --git a/apps/proxy/schema.py b/apps/proxy/schema.py new file mode 100644 index 0000000..5b60d40 --- /dev/null +++ b/apps/proxy/schema.py @@ -0,0 +1,112 @@ +import concurrent.futures +import copy +import logging + +import requests +from django.conf import settings +from django.core.cache import cache + +logger = logging.getLogger(__name__) + +CACHE_KEY_TEMPLATE = "proxy_upstream_openapi_schema_{service}" +CACHE_TIMEOUT_SECONDS = 300 +FETCH_TIMEOUT_SECONDS = 5 + + +def _rewrite_schema_refs(node, rename): + """Recursively repoint `$ref: '#/components/schemas/'` at the + renamed (service-prefixed) schema, in place.""" + if isinstance(node, dict): + ref = node.get("$ref") + if isinstance(ref, str) and ref.startswith("#/components/schemas/"): + name = ref.rsplit("/", 1)[-1] + if name in rename: + node["$ref"] = f"#/components/schemas/{rename[name]}" + for value in node.values(): + _rewrite_schema_refs(value, rename) + elif isinstance(node, list): + for item in node: + _rewrite_schema_refs(item, rename) + + +def _fetch_service_schema(service, base_url, schema_path): + cache_key = CACHE_KEY_TEMPLATE.format(service=service) + cached = cache.get(cache_key) + if cached is not None: + return cached + + url = f"{base_url.rstrip('/')}{schema_path}" + try: + response = requests.get(url, timeout=FETCH_TIMEOUT_SECONDS) + response.raise_for_status() + schema = response.json() + except (requests.RequestException, ValueError) as exc: + logger.warning("Could not fetch OpenAPI schema for service %r from %s: %s", service, url, exc) + return None + + cache.set(cache_key, schema, timeout=CACHE_TIMEOUT_SECONDS) + return schema + + +def merge_upstream_schemas(result, generator, request, public): + """drf-spectacular POSTPROCESSING_HOOKS entry point. + + Folds every proxied service's own OpenAPI document into this service's + schema under `//...` paths (mirroring apps.proxy.views), so the + combined swagger covers every endpoint this proxy forwards to, DTOs + included. Schemas are cached per service; a service that's unconfigured + or unreachable is skipped rather than failing the whole document. + """ + services = { + service: base_url + for service, base_url in settings.PROXY_SERVICE_BASE_URLS.items() + if base_url + } + if not services: + return result + + schema_paths = settings.PROXY_SERVICE_SCHEMA_PATHS + + with concurrent.futures.ThreadPoolExecutor(max_workers=len(services)) as executor: + futures = { + executor.submit( + _fetch_service_schema, + service, + base_url, + schema_paths.get(service, "/swagger/?format=json"), + ): service + for service, base_url in services.items() + } + fetched = {} + for future in concurrent.futures.as_completed(futures): + service = futures[future] + schema = future.result() + if schema: + fetched[service] = schema + + result.setdefault("paths", {}) + result.setdefault("components", {}).setdefault("schemas", {}) + + for service, schema in fetched.items(): + schema = copy.deepcopy(schema) + upstream_schemas = schema.get("components", {}).get("schemas", {}) + rename = {name: f"{service}_{name}" for name in upstream_schemas} + + _rewrite_schema_refs(schema.get("paths", {}), rename) + _rewrite_schema_refs(upstream_schemas, rename) + + for name, definition in upstream_schemas.items(): + result["components"]["schemas"][rename[name]] = definition + + label = service.capitalize() + for path, operations in schema.get("paths", {}).items(): + proxied_operations = copy.deepcopy(operations) + for operation in proxied_operations.values(): + if not isinstance(operation, dict): + continue + operation["tags"] = [label] + if "operationId" in operation: + operation["operationId"] = f"{service}_{operation['operationId']}" + result["paths"][f"/{service}{path}"] = proxied_operations + + return result diff --git a/apps/proxy/urls.py b/apps/proxy/urls.py new file mode 100644 index 0000000..72994e4 --- /dev/null +++ b/apps/proxy/urls.py @@ -0,0 +1,11 @@ +from django.urls import path + +from apps.proxy.views import ServiceProxyView + + +app_name = "proxy" + +urlpatterns = [ + path("/", ServiceProxyView.as_view(), name="proxy-root"), + path("/", ServiceProxyView.as_view(), name="proxy"), +] diff --git a/apps/proxy/views.py b/apps/proxy/views.py new file mode 100644 index 0000000..51993a4 --- /dev/null +++ b/apps/proxy/views.py @@ -0,0 +1,77 @@ +import requests +from django.conf import settings +from django.http import HttpResponse +from django.utils.decorators import method_decorator +from django.views import View +from django.views.decorators.csrf import csrf_exempt + +# Headers that must not be copied verbatim between hops (RFC 7230 6.1) plus +# framing headers that HttpResponse recomputes itself. +HOP_BY_HOP_HEADERS = { + "connection", + "keep-alive", + "proxy-authenticate", + "proxy-authorization", + "te", + "trailers", + "transfer-encoding", + "upgrade", + "content-encoding", + "content-length", +} + + +def _incoming_headers(request): + headers = {} + for key, value in request.META.items(): + if key.startswith("HTTP_"): + name = key[5:].replace("_", "-").title() + elif key in ("CONTENT_TYPE", "CONTENT_LENGTH") and value: + name = key.replace("_", "-").title() + else: + continue + headers[name] = value + headers.pop("Host", None) + return headers + + +@method_decorator(csrf_exempt, name="dispatch") +class ServiceProxyView(View): + """Forwards `//` to the configured base URL for `service`.""" + + def dispatch(self, request, service, rest="", *args, **kwargs): + base_url = settings.PROXY_SERVICE_BASE_URLS.get(service) + if not base_url: + return HttpResponse( + f'Unknown or unconfigured service "{service}".', + status=404, + content_type="text/plain", + ) + + target_url = f"{base_url.rstrip('/')}/{rest.lstrip('/')}" + query_string = request.META.get("QUERY_STRING", "") + if query_string: + target_url = f"{target_url}?{query_string}" + + try: + upstream = requests.request( + method=request.method, + url=target_url, + headers=_incoming_headers(request), + data=request.body, + timeout=settings.SERVICE_REQUEST_TIMEOUT, + allow_redirects=False, + ) + except requests.RequestException as exc: + return HttpResponse( + f'Error contacting upstream service "{service}": {exc}', + status=502, + content_type="text/plain", + ) + + response = HttpResponse(content=upstream.content, status=upstream.status_code) + for name, value in upstream.headers.items(): + if name.lower() in HOP_BY_HOP_HEADERS: + continue + response[name] = value + return response diff --git a/config/settings/base.py b/config/settings/base.py index bfdfdac..d012e88 100644 --- a/config/settings/base.py +++ b/config/settings/base.py @@ -43,6 +43,7 @@ THIRD_PARTY_APPS = [ LOCAL_APPS = [ "apps.core", "apps.reports", + "apps.proxy", ] INSTALLED_APPS = DJANGO_APPS + THIRD_PARTY_APPS + LOCAL_APPS @@ -152,9 +153,16 @@ REST_FRAMEWORK = { SPECTACULAR_SETTINGS = { "TITLE": "CRM Backend API", - "DESCRIPTION": "API for CRM report generation and health checks.", + "DESCRIPTION": ( + "API for CRM report generation and health checks, plus a merged view of " + "every proxied service's own API (see apps.proxy)." + ), "VERSION": "1.0.0", "SERVE_INCLUDE_SCHEMA": False, + "POSTPROCESSING_HOOKS": [ + "drf_spectacular.hooks.postprocess_schema_enums", + "apps.proxy.schema.merge_upstream_schemas", + ], } @@ -172,3 +180,38 @@ OAUTH2_CLIENT_SECRET = env("OAUTH2_CLIENT_SECRET", default="") OAUTH2_SCOPES = env("OAUTH2_SCOPES", default="") ADVERTISING_BASE_PUBLIC_URL = env("ADVERTISING_BASE_PUBLIC_URL", default="") ACCOUNTS_BASE_PUBLIC_URL = env("ACCOUNTS_BASE_PUBLIC_URL", default="") +WALLET_BASE_PUBLIC_URL = env("WALLET_BASE_PUBLIC_URL", default="") +WALLET_RIAL = env("WALLET_RIAL", default="") +WALLET_REWARD = env("WALLET_REWARD", default="") +CHAT_BASE_PUBLIC_URL = env("CHAT_BASE_PUBLIC_URL", default="") +NOTIFICATIONS_BASE_PUBLIC_URL = env("NOTIFICATIONS_BASE_PUBLIC_URL", default="") +PROMOTIONS_BASE_PUBLIC_URL = env("PROMOTIONS_BASE_PUBLIC_URL", default="") +CAMPAIGN_BASE_PUBLIC_URL = env("CAMPAIGN_BASE_PUBLIC_URL", default="") +IPG_BASE_PUBLIC_URL = env("IPG_BASE_PUBLIC_URL", default="") + +# Maps the first path segment of a proxied request (thisprojectbaseurl//) +# to the upstream service's base URL. See apps.proxy.views.ServiceProxyView. +PROXY_SERVICE_BASE_URLS = { + "accounts": ACCOUNTS_BASE_PUBLIC_URL, + "wallet": WALLET_BASE_PUBLIC_URL, + "advertising": ADVERTISING_BASE_PUBLIC_URL, + "chat": CHAT_BASE_PUBLIC_URL, + "notifications": NOTIFICATIONS_BASE_PUBLIC_URL, + "promotions": PROMOTIONS_BASE_PUBLIC_URL, + "campaign": CAMPAIGN_BASE_PUBLIC_URL, + "ipg": IPG_BASE_PUBLIC_URL, +} + +# Where each service publishes its own raw OpenAPI document (drf-spectacular's +# SpectacularAPIView, mounted at different prefixes per service). Used by +# apps.proxy.schema to fold every proxied endpoint into this service's swagger. +PROXY_SERVICE_SCHEMA_PATHS = { + "accounts": "/swagger/?format=json", + "wallet": "/swagger/?format=json", + "advertising": "/swagger/?format=json", + "chat": "/swagger/?format=json", + "notifications": "/swagger/?format=json", + "promotions": "/swagger/?format=json", + "campaign": "/api/swagger/schema/?format=json", + "ipg": "/swagger/?format=json", +} diff --git a/config/urls.py b/config/urls.py index e819a8e..5f42904 100644 --- a/config/urls.py +++ b/config/urls.py @@ -14,4 +14,7 @@ urlpatterns = [ path("api/redoc/", SpectacularRedocView.as_view(url_name="schema"), name="redoc"), path("api/", include("apps.core.urls")), path("api/reports/", include("apps.reports.urls")), + # Catch-all reverse proxy: thisprojectbaseurl//. + # Must stay last so it never shadows the routes above. + path("", include("apps.proxy.urls")), ] diff --git a/utils/accounts_client.py b/utils/accounts_client.py index c3dd2d8..15b12bd 100644 --- a/utils/accounts_client.py +++ b/utils/accounts_client.py @@ -9,9 +9,6 @@ from httpx import Request from utils.clients.gooyal_accounts_client import AuthenticatedClient from utils.clients.gooyal_accounts_client.models import Account from utils.clients.gooyal_accounts_client.api.users import (users_api_users_details_retrieve) -from utils.clients.gooyal_wallet_client.types import Response - -from django.conf import Settings diff --git a/utils/clients/gooyal_wallet_client/__init__.py b/utils/clients/gooyal_wallet_client/__init__.py deleted file mode 100644 index fe01c71..0000000 --- a/utils/clients/gooyal_wallet_client/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -"""A client library for accessing Gooyal Wallet""" - -from .client import AuthenticatedClient, Client - -__all__ = ( - "AuthenticatedClient", - "Client", -) diff --git a/utils/clients/gooyal_wallet_client/api/__init__.py b/utils/clients/gooyal_wallet_client/api/__init__.py deleted file mode 100644 index 81f9fa2..0000000 --- a/utils/clients/gooyal_wallet_client/api/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Contains methods for accessing the API""" diff --git a/utils/clients/gooyal_wallet_client/api/wallet/__init__.py b/utils/clients/gooyal_wallet_client/api/wallet/__init__.py deleted file mode 100644 index 2d7c0b2..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Contains endpoint functions for accessing the API""" diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_create.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_create.py deleted file mode 100644 index c4f8fa1..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_create.py +++ /dev/null @@ -1,168 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_deposit import ApplicationDeposit -from ...types import Response - - -def _get_kwargs( - payer_wallet: str, - *, - body: ApplicationDeposit, -) -> dict[str, Any]: - headers: dict[str, Any] = {} - - _kwargs: dict[str, Any] = { - "method": "post", - "url": f"/wallet/api/application/{payer_wallet}/deposit/", - } - - _kwargs["json"] = body.to_dict() - - headers["Content-Type"] = "application/json" - - _kwargs["headers"] = headers - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationDeposit]: - if response.status_code == 201: - response_201 = ApplicationDeposit.from_dict(response.json()) - - return response_201 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationDeposit]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payer_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationDeposit, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - body (ApplicationDeposit): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - body=body, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payer_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationDeposit, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - body (ApplicationDeposit): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return sync_detailed( - payer_wallet=payer_wallet, - client=client, - body=body, - ).parsed - - -async def asyncio_detailed( - payer_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationDeposit, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - body (ApplicationDeposit): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - body=body, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payer_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationDeposit, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - body (ApplicationDeposit): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return ( - await asyncio_detailed( - payer_wallet=payer_wallet, - client=client, - body=body, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_rollback_retrieve.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_rollback_retrieve.py deleted file mode 100644 index 21afdac..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_rollback_retrieve.py +++ /dev/null @@ -1,160 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_deposit import ApplicationDeposit -from ...types import Response - - -def _get_kwargs( - payer_wallet: str, - uuid: str, -) -> dict[str, Any]: - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/{payer_wallet}/deposit/{uuid}/rollback", - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationDeposit]: - if response.status_code == 200: - response_200 = ApplicationDeposit.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationDeposit]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - uuid=uuid, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return sync_detailed( - payer_wallet=payer_wallet, - uuid=uuid, - client=client, - ).parsed - - -async def asyncio_detailed( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - uuid=uuid, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return ( - await asyncio_detailed( - payer_wallet=payer_wallet, - uuid=uuid, - client=client, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_verify_retrieve.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_verify_retrieve.py deleted file mode 100644 index 29042f3..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_deposit_verify_retrieve.py +++ /dev/null @@ -1,160 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_deposit import ApplicationDeposit -from ...types import Response - - -def _get_kwargs( - payer_wallet: str, - uuid: str, -) -> dict[str, Any]: - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/{payer_wallet}/deposit/{uuid}/verify", - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationDeposit]: - if response.status_code == 200: - response_200 = ApplicationDeposit.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationDeposit]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - uuid=uuid, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return sync_detailed( - payer_wallet=payer_wallet, - uuid=uuid, - client=client, - ).parsed - - -async def asyncio_detailed( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationDeposit] - """ - - kwargs = _get_kwargs( - payer_wallet=payer_wallet, - uuid=uuid, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payer_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationDeposit]: - """ - Args: - payer_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationDeposit - """ - - return ( - await asyncio_detailed( - payer_wallet=payer_wallet, - uuid=uuid, - client=client, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_list.py deleted file mode 100644 index e808f0e..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_list.py +++ /dev/null @@ -1,227 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_transaction_list import PaginatedTransactionList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - json_payee: Union[Unset, str] = UNSET - if not isinstance(payee, Unset): - json_payee = str(payee) - params["payee"] = json_payee - - json_payer: Union[Unset, str] = UNSET - if not isinstance(payer, Unset): - json_payer = str(payer) - params["payer"] = json_payer - - json_wallets = [] - for wallets_item_data in wallets: - wallets_item = str(wallets_item_data) - json_wallets.append(wallets_item) - - params["wallets"] = json_wallets - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": "/wallet/api/application/transactions/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedTransactionList]: - if response.status_code == 200: - response_200 = PaginatedTransactionList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedTransactionList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionList - """ - - return sync_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ).parsed - - -async def asyncio_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionList - """ - - return ( - await asyncio_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_retrieve.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_retrieve.py deleted file mode 100644 index 1939f25..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_transactions_retrieve.py +++ /dev/null @@ -1,144 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.transaction import Transaction -from ...types import Response - - -def _get_kwargs( - uuid: UUID, -) -> dict[str, Any]: - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/transactions/{uuid}/", - } - - return _kwargs - - -def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Transaction]: - if response.status_code == 200: - response_200 = Transaction.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Transaction]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - uuid: UUID, - *, - client: AuthenticatedClient, -) -> Response[Transaction]: - """ - Args: - uuid (UUID): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Transaction] - """ - - kwargs = _get_kwargs( - uuid=uuid, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - uuid: UUID, - *, - client: AuthenticatedClient, -) -> Optional[Transaction]: - """ - Args: - uuid (UUID): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Transaction - """ - - return sync_detailed( - uuid=uuid, - client=client, - ).parsed - - -async def asyncio_detailed( - uuid: UUID, - *, - client: AuthenticatedClient, -) -> Response[Transaction]: - """ - Args: - uuid (UUID): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[Transaction] - """ - - kwargs = _get_kwargs( - uuid=uuid, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - uuid: UUID, - *, - client: AuthenticatedClient, -) -> Optional[Transaction]: - """ - Args: - uuid (UUID): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Transaction - """ - - return ( - await asyncio_detailed( - uuid=uuid, - client=client, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_user_wallets_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_user_wallets_list.py deleted file mode 100644 index 3317b1e..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_user_wallets_list.py +++ /dev/null @@ -1,208 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_account_list import PaginatedAccountList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - owner: str, - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - json_wallet = [] - for wallet_item_data in wallet: - wallet_item = str(wallet_item_data) - json_wallet.append(wallet_item) - - params["wallet"] = json_wallet - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/user/wallets/{owner}/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedAccountList]: - if response.status_code == 200: - response_200 = PaginatedAccountList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedAccountList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - owner: str, - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Response[PaginatedAccountList]: - """API for getting specified user wallet. - - Args: - owner (str): - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - owner=owner, - limit=limit, - offset=offset, - wallet=wallet, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - owner: str, - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Optional[PaginatedAccountList]: - """API for getting specified user wallet. - - Args: - owner (str): - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return sync_detailed( - owner=owner, - client=client, - limit=limit, - offset=offset, - wallet=wallet, - ).parsed - - -async def asyncio_detailed( - owner: str, - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Response[PaginatedAccountList]: - """API for getting specified user wallet. - - Args: - owner (str): - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - owner=owner, - limit=limit, - offset=offset, - wallet=wallet, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - owner: str, - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Optional[PaginatedAccountList]: - """API for getting specified user wallet. - - Args: - owner (str): - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return ( - await asyncio_detailed( - owner=owner, - client=client, - limit=limit, - offset=offset, - wallet=wallet, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_wallets_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_wallets_list.py deleted file mode 100644 index 9d5a57b..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_wallets_list.py +++ /dev/null @@ -1,174 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_account_list import PaginatedAccountList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": "/wallet/api/application/wallets/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedAccountList]: - if response.status_code == 200: - response_200 = PaginatedAccountList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedAccountList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, -) -> Response[PaginatedAccountList]: - """API for getting specified user or application balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, -) -> Optional[PaginatedAccountList]: - """API for getting specified user or application balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return sync_detailed( - client=client, - limit=limit, - offset=offset, - ).parsed - - -async def asyncio_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, -) -> Response[PaginatedAccountList]: - """API for getting specified user or application balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, -) -> Optional[PaginatedAccountList]: - """API for getting specified user or application balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return ( - await asyncio_detailed( - client=client, - limit=limit, - offset=offset, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_create.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_create.py deleted file mode 100644 index 74d6944..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_create.py +++ /dev/null @@ -1,168 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_withdraw import ApplicationWithdraw -from ...types import Response - - -def _get_kwargs( - payee_wallet: str, - *, - body: ApplicationWithdraw, -) -> dict[str, Any]: - headers: dict[str, Any] = {} - - _kwargs: dict[str, Any] = { - "method": "post", - "url": f"/wallet/api/application/{payee_wallet}/withdraw/", - } - - _kwargs["json"] = body.to_dict() - - headers["Content-Type"] = "application/json" - - _kwargs["headers"] = headers - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationWithdraw]: - if response.status_code == 201: - response_201 = ApplicationWithdraw.from_dict(response.json()) - - return response_201 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationWithdraw]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payee_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationWithdraw, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - body (ApplicationWithdraw): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - body=body, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payee_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationWithdraw, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - body (ApplicationWithdraw): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return sync_detailed( - payee_wallet=payee_wallet, - client=client, - body=body, - ).parsed - - -async def asyncio_detailed( - payee_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationWithdraw, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - body (ApplicationWithdraw): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - body=body, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payee_wallet: str, - *, - client: AuthenticatedClient, - body: ApplicationWithdraw, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - body (ApplicationWithdraw): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return ( - await asyncio_detailed( - payee_wallet=payee_wallet, - client=client, - body=body, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_rollback_retrieve.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_rollback_retrieve.py deleted file mode 100644 index 32421fb..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_rollback_retrieve.py +++ /dev/null @@ -1,160 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_withdraw import ApplicationWithdraw -from ...types import Response - - -def _get_kwargs( - payee_wallet: str, - uuid: str, -) -> dict[str, Any]: - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/{payee_wallet}/withdraw/{uuid}/rollback", - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationWithdraw]: - if response.status_code == 200: - response_200 = ApplicationWithdraw.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationWithdraw]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - uuid=uuid, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return sync_detailed( - payee_wallet=payee_wallet, - uuid=uuid, - client=client, - ).parsed - - -async def asyncio_detailed( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - uuid=uuid, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return ( - await asyncio_detailed( - payee_wallet=payee_wallet, - uuid=uuid, - client=client, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_verify_retrieve.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_verify_retrieve.py deleted file mode 100644 index 757b597..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_application_withdraw_verify_retrieve.py +++ /dev/null @@ -1,160 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.application_withdraw import ApplicationWithdraw -from ...types import Response - - -def _get_kwargs( - payee_wallet: str, - uuid: str, -) -> dict[str, Any]: - _kwargs: dict[str, Any] = { - "method": "get", - "url": f"/wallet/api/application/{payee_wallet}/withdraw/{uuid}/verify", - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[ApplicationWithdraw]: - if response.status_code == 200: - response_200 = ApplicationWithdraw.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[ApplicationWithdraw]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - uuid=uuid, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return sync_detailed( - payee_wallet=payee_wallet, - uuid=uuid, - client=client, - ).parsed - - -async def asyncio_detailed( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Response[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[ApplicationWithdraw] - """ - - kwargs = _get_kwargs( - payee_wallet=payee_wallet, - uuid=uuid, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - payee_wallet: str, - uuid: str, - *, - client: AuthenticatedClient, -) -> Optional[ApplicationWithdraw]: - """ - Args: - payee_wallet (str): - uuid (str): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - ApplicationWithdraw - """ - - return ( - await asyncio_detailed( - payee_wallet=payee_wallet, - uuid=uuid, - client=client, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_grouped_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_grouped_list.py deleted file mode 100644 index 1d1cb15..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_grouped_list.py +++ /dev/null @@ -1,227 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_transaction_grouped_list import PaginatedTransactionGroupedList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - json_payee: Union[Unset, str] = UNSET - if not isinstance(payee, Unset): - json_payee = str(payee) - params["payee"] = json_payee - - json_payer: Union[Unset, str] = UNSET - if not isinstance(payer, Unset): - json_payer = str(payer) - params["payer"] = json_payer - - json_wallets = [] - for wallets_item_data in wallets: - wallets_item = str(wallets_item_data) - json_wallets.append(wallets_item) - - params["wallets"] = json_wallets - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": "/wallet/api/transactions/grouped/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedTransactionGroupedList]: - if response.status_code == 200: - response_200 = PaginatedTransactionGroupedList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedTransactionGroupedList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionGroupedList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionGroupedList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionGroupedList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionGroupedList - """ - - return sync_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ).parsed - - -async def asyncio_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionGroupedList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionGroupedList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionGroupedList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionGroupedList - """ - - return ( - await asyncio_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_list.py deleted file mode 100644 index 35b6626..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_transactions_list.py +++ /dev/null @@ -1,227 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_transaction_list import PaginatedTransactionList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - json_payee: Union[Unset, str] = UNSET - if not isinstance(payee, Unset): - json_payee = str(payee) - params["payee"] = json_payee - - json_payer: Union[Unset, str] = UNSET - if not isinstance(payer, Unset): - json_payer = str(payer) - params["payer"] = json_payer - - json_wallets = [] - for wallets_item_data in wallets: - wallets_item = str(wallets_item_data) - json_wallets.append(wallets_item) - - params["wallets"] = json_wallets - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": "/wallet/api/transactions/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedTransactionList]: - if response.status_code == 200: - response_200 = PaginatedTransactionList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedTransactionList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionList - """ - - return sync_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ).parsed - - -async def asyncio_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Response[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedTransactionList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - payee: Union[Unset, UUID] = UNSET, - payer: Union[Unset, UUID] = UNSET, - wallets: list[UUID], -) -> Optional[PaginatedTransactionList]: - """ - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - payee (Union[Unset, UUID]): - payer (Union[Unset, UUID]): - wallets (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedTransactionList - """ - - return ( - await asyncio_detailed( - client=client, - limit=limit, - offset=offset, - payee=payee, - payer=payer, - wallets=wallets, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_wallets_list.py b/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_wallets_list.py deleted file mode 100644 index f406ae8..0000000 --- a/utils/clients/gooyal_wallet_client/api/wallet/wallet_api_wallets_list.py +++ /dev/null @@ -1,195 +0,0 @@ -from http import HTTPStatus -from typing import Any, Optional, Union -from uuid import UUID - -import httpx - -from ... import errors -from ...client import AuthenticatedClient, Client -from ...models.paginated_account_list import PaginatedAccountList -from ...types import UNSET, Response, Unset - - -def _get_kwargs( - *, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> dict[str, Any]: - params: dict[str, Any] = {} - - params["limit"] = limit - - params["offset"] = offset - - json_wallet = [] - for wallet_item_data in wallet: - wallet_item = str(wallet_item_data) - json_wallet.append(wallet_item) - - params["wallet"] = json_wallet - - params = {k: v for k, v in params.items() if v is not UNSET and v is not None} - - _kwargs: dict[str, Any] = { - "method": "get", - "url": "/wallet/api/wallets/", - "params": params, - } - - return _kwargs - - -def _parse_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Optional[PaginatedAccountList]: - if response.status_code == 200: - response_200 = PaginatedAccountList.from_dict(response.json()) - - return response_200 - - if client.raise_on_unexpected_status: - raise errors.UnexpectedStatus(response.status_code, response.content) - else: - return None - - -def _build_response( - *, client: Union[AuthenticatedClient, Client], response: httpx.Response -) -> Response[PaginatedAccountList]: - return Response( - status_code=HTTPStatus(response.status_code), - content=response.content, - headers=response.headers, - parsed=_parse_response(client=client, response=response), - ) - - -def sync_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Response[PaginatedAccountList]: - """API for getting authenticated user balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - wallet=wallet, - ) - - response = client.get_httpx_client().request( - **kwargs, - ) - - return _build_response(client=client, response=response) - - -def sync( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Optional[PaginatedAccountList]: - """API for getting authenticated user balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return sync_detailed( - client=client, - limit=limit, - offset=offset, - wallet=wallet, - ).parsed - - -async def asyncio_detailed( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Response[PaginatedAccountList]: - """API for getting authenticated user balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - Response[PaginatedAccountList] - """ - - kwargs = _get_kwargs( - limit=limit, - offset=offset, - wallet=wallet, - ) - - response = await client.get_async_httpx_client().request(**kwargs) - - return _build_response(client=client, response=response) - - -async def asyncio( - *, - client: AuthenticatedClient, - limit: Union[Unset, int] = UNSET, - offset: Union[Unset, int] = UNSET, - wallet: list[UUID], -) -> Optional[PaginatedAccountList]: - """API for getting authenticated user balance. - - Args: - limit (Union[Unset, int]): - offset (Union[Unset, int]): - wallet (list[UUID]): - - Raises: - errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True. - httpx.TimeoutException: If the request takes longer than Client.timeout. - - Returns: - PaginatedAccountList - """ - - return ( - await asyncio_detailed( - client=client, - limit=limit, - offset=offset, - wallet=wallet, - ) - ).parsed diff --git a/utils/clients/gooyal_wallet_client/client.py b/utils/clients/gooyal_wallet_client/client.py deleted file mode 100644 index e80446f..0000000 --- a/utils/clients/gooyal_wallet_client/client.py +++ /dev/null @@ -1,268 +0,0 @@ -import ssl -from typing import Any, Optional, Union - -import httpx -from attrs import define, evolve, field - - -@define -class Client: - """A class for keeping track of data related to the API - - The following are accepted as keyword arguments and will be used to construct httpx Clients internally: - - ``base_url``: The base URL for the API, all requests are made to a relative path to this URL - - ``cookies``: A dictionary of cookies to be sent with every request - - ``headers``: A dictionary of headers to be sent with every request - - ``timeout``: The maximum amount of a time a request can take. API functions will raise - httpx.TimeoutException if this is exceeded. - - ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production, - but can be set to False for testing purposes. - - ``follow_redirects``: Whether or not to follow redirects. Default value is False. - - ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor. - - - Attributes: - raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a - status code that was not documented in the source OpenAPI document. Can also be provided as a keyword - argument to the constructor. - """ - - raise_on_unexpected_status: bool = field(default=False, kw_only=True) - _base_url: str = field(alias="base_url") - _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") - _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") - _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") - _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: Optional[httpx.Client] = field(default=None, init=False) - _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) - - def with_headers(self, headers: dict[str, str]) -> "Client": - """Get a new client matching this one with additional headers""" - if self._client is not None: - self._client.headers.update(headers) - if self._async_client is not None: - self._async_client.headers.update(headers) - return evolve(self, headers={**self._headers, **headers}) - - def with_cookies(self, cookies: dict[str, str]) -> "Client": - """Get a new client matching this one with additional cookies""" - if self._client is not None: - self._client.cookies.update(cookies) - if self._async_client is not None: - self._async_client.cookies.update(cookies) - return evolve(self, cookies={**self._cookies, **cookies}) - - def with_timeout(self, timeout: httpx.Timeout) -> "Client": - """Get a new client matching this one with a new timeout (in seconds)""" - if self._client is not None: - self._client.timeout = timeout - if self._async_client is not None: - self._async_client.timeout = timeout - return evolve(self, timeout=timeout) - - def set_httpx_client(self, client: httpx.Client) -> "Client": - """Manually set the underlying httpx.Client - - **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout. - """ - self._client = client - return self - - def get_httpx_client(self) -> httpx.Client: - """Get the underlying httpx.Client, constructing a new one if not previously set""" - if self._client is None: - self._client = httpx.Client( - base_url=self._base_url, - cookies=self._cookies, - headers=self._headers, - timeout=self._timeout, - verify=self._verify_ssl, - follow_redirects=self._follow_redirects, - **self._httpx_args, - ) - return self._client - - def __enter__(self) -> "Client": - """Enter a context manager for self.client—you cannot enter twice (see httpx docs)""" - self.get_httpx_client().__enter__() - return self - - def __exit__(self, *args: Any, **kwargs: Any) -> None: - """Exit a context manager for internal httpx.Client (see httpx docs)""" - self.get_httpx_client().__exit__(*args, **kwargs) - - def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "Client": - """Manually the underlying httpx.AsyncClient - - **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout. - """ - self._async_client = async_client - return self - - def get_async_httpx_client(self) -> httpx.AsyncClient: - """Get the underlying httpx.AsyncClient, constructing a new one if not previously set""" - if self._async_client is None: - self._async_client = httpx.AsyncClient( - base_url=self._base_url, - cookies=self._cookies, - headers=self._headers, - timeout=self._timeout, - verify=self._verify_ssl, - follow_redirects=self._follow_redirects, - **self._httpx_args, - ) - return self._async_client - - async def __aenter__(self) -> "Client": - """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)""" - await self.get_async_httpx_client().__aenter__() - return self - - async def __aexit__(self, *args: Any, **kwargs: Any) -> None: - """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)""" - await self.get_async_httpx_client().__aexit__(*args, **kwargs) - - -@define -class AuthenticatedClient: - """A Client which has been authenticated for use on secured endpoints - - The following are accepted as keyword arguments and will be used to construct httpx Clients internally: - - ``base_url``: The base URL for the API, all requests are made to a relative path to this URL - - ``cookies``: A dictionary of cookies to be sent with every request - - ``headers``: A dictionary of headers to be sent with every request - - ``timeout``: The maximum amount of a time a request can take. API functions will raise - httpx.TimeoutException if this is exceeded. - - ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production, - but can be set to False for testing purposes. - - ``follow_redirects``: Whether or not to follow redirects. Default value is False. - - ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor. - - - Attributes: - raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a - status code that was not documented in the source OpenAPI document. Can also be provided as a keyword - argument to the constructor. - token: The token to use for authentication - prefix: The prefix to use for the Authorization header - auth_header_name: The name of the Authorization header - """ - - raise_on_unexpected_status: bool = field(default=False, kw_only=True) - _base_url: str = field(alias="base_url") - _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies") - _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers") - _timeout: Optional[httpx.Timeout] = field(default=None, kw_only=True, alias="timeout") - _verify_ssl: Union[str, bool, ssl.SSLContext] = field(default=True, kw_only=True, alias="verify_ssl") - _follow_redirects: bool = field(default=False, kw_only=True, alias="follow_redirects") - _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args") - _client: Optional[httpx.Client] = field(default=None, init=False) - _async_client: Optional[httpx.AsyncClient] = field(default=None, init=False) - - token: str - prefix: str = "Bearer" - auth_header_name: str = "Authorization" - - def with_headers(self, headers: dict[str, str]) -> "AuthenticatedClient": - """Get a new client matching this one with additional headers""" - if self._client is not None: - self._client.headers.update(headers) - if self._async_client is not None: - self._async_client.headers.update(headers) - return evolve(self, headers={**self._headers, **headers}) - - def with_cookies(self, cookies: dict[str, str]) -> "AuthenticatedClient": - """Get a new client matching this one with additional cookies""" - if self._client is not None: - self._client.cookies.update(cookies) - if self._async_client is not None: - self._async_client.cookies.update(cookies) - return evolve(self, cookies={**self._cookies, **cookies}) - - def with_timeout(self, timeout: httpx.Timeout) -> "AuthenticatedClient": - """Get a new client matching this one with a new timeout (in seconds)""" - if self._client is not None: - self._client.timeout = timeout - if self._async_client is not None: - self._async_client.timeout = timeout - return evolve(self, timeout=timeout) - - def set_httpx_client(self, client: httpx.Client) -> "AuthenticatedClient": - """Manually set the underlying httpx.Client - - **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout. - """ - self._client = client - return self - - def get_httpx_client(self) -> httpx.Client: - """Get the underlying httpx.Client, constructing a new one if not previously set""" - if self._client is None: - self._headers[self.auth_header_name] = f"{self.prefix} {self.token}" if self.prefix else self.token - self._client = httpx.Client( - base_url=self._base_url, - cookies=self._cookies, - headers=self._headers, - timeout=self._timeout, - verify=self._verify_ssl, - follow_redirects=self._follow_redirects, - **self._httpx_args, - ) - return self._client - - def __enter__(self) -> "AuthenticatedClient": - """Enter a context manager for self.client—you cannot enter twice (see httpx docs)""" - self.get_httpx_client().__enter__() - return self - - def __exit__(self, *args: Any, **kwargs: Any) -> None: - """Exit a context manager for internal httpx.Client (see httpx docs)""" - self.get_httpx_client().__exit__(*args, **kwargs) - - def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "AuthenticatedClient": - """Manually the underlying httpx.AsyncClient - - **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout. - """ - self._async_client = async_client - return self - - def get_async_httpx_client(self) -> httpx.AsyncClient: - """Get the underlying httpx.AsyncClient, constructing a new one if not previously set""" - if self._async_client is None: - self._headers[self.auth_header_name] = f"{self.prefix} {self.token}" if self.prefix else self.token - self._async_client = httpx.AsyncClient( - base_url=self._base_url, - cookies=self._cookies, - headers=self._headers, - timeout=self._timeout, - verify=self._verify_ssl, - follow_redirects=self._follow_redirects, - **self._httpx_args, - ) - return self._async_client - - async def __aenter__(self) -> "AuthenticatedClient": - """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)""" - await self.get_async_httpx_client().__aenter__() - return self - - async def __aexit__(self, *args: Any, **kwargs: Any) -> None: - """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)""" - await self.get_async_httpx_client().__aexit__(*args, **kwargs) diff --git a/utils/clients/gooyal_wallet_client/errors.py b/utils/clients/gooyal_wallet_client/errors.py deleted file mode 100644 index 5f92e76..0000000 --- a/utils/clients/gooyal_wallet_client/errors.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Contains shared errors types that can be raised from API functions""" - - -class UnexpectedStatus(Exception): - """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True""" - - def __init__(self, status_code: int, content: bytes): - self.status_code = status_code - self.content = content - - super().__init__( - f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}" - ) - - -__all__ = ["UnexpectedStatus"] diff --git a/utils/clients/gooyal_wallet_client/models/__init__.py b/utils/clients/gooyal_wallet_client/models/__init__.py deleted file mode 100644 index 7df448d..0000000 --- a/utils/clients/gooyal_wallet_client/models/__init__.py +++ /dev/null @@ -1,23 +0,0 @@ -"""Contains all the data models used in inputs/outputs""" - -from .account import Account -from .application_deposit import ApplicationDeposit -from .application_withdraw import ApplicationWithdraw -from .paginated_account_list import PaginatedAccountList -from .paginated_transaction_grouped_list import PaginatedTransactionGroupedList -from .paginated_transaction_list import PaginatedTransactionList -from .state_enum import StateEnum -from .transaction import Transaction -from .transaction_grouped import TransactionGrouped - -__all__ = ( - "Account", - "ApplicationDeposit", - "ApplicationWithdraw", - "PaginatedAccountList", - "PaginatedTransactionGroupedList", - "PaginatedTransactionList", - "StateEnum", - "Transaction", - "TransactionGrouped", -) diff --git a/utils/clients/gooyal_wallet_client/models/account.py b/utils/clients/gooyal_wallet_client/models/account.py deleted file mode 100644 index 25b08bb..0000000 --- a/utils/clients/gooyal_wallet_client/models/account.py +++ /dev/null @@ -1,90 +0,0 @@ -from collections.abc import Mapping -from typing import Any, TypeVar, Union, cast -from uuid import UUID - -from attrs import define as _attrs_define -from attrs import field as _attrs_field - -from ..types import UNSET, Unset - -T = TypeVar("T", bound="Account") - - -@_attrs_define -class Account: - """ - Attributes: - balance (Union[Unset, int]): - wallet (Union[None, UUID, Unset]): - """ - - balance: Union[Unset, int] = UNSET - wallet: Union[None, UUID, Unset] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - balance = self.balance - - wallet: Union[None, Unset, str] - if isinstance(self.wallet, Unset): - wallet = UNSET - elif isinstance(self.wallet, UUID): - wallet = str(self.wallet) - else: - wallet = self.wallet - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update({}) - if balance is not UNSET: - field_dict["balance"] = balance - if wallet is not UNSET: - field_dict["wallet"] = wallet - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - d = dict(src_dict) - balance = d.pop("balance", UNSET) - - def _parse_wallet(data: object) -> Union[None, UUID, Unset]: - if data is None: - return data - if isinstance(data, Unset): - return data - try: - if not isinstance(data, str): - raise TypeError() - wallet_type_0 = UUID(data) - - return wallet_type_0 - except: # noqa: E722 - pass - return cast(Union[None, UUID, Unset], data) - - wallet = _parse_wallet(d.pop("wallet", UNSET)) - - account = cls( - balance=balance, - wallet=wallet, - ) - - account.additional_properties = d - return account - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/application_deposit.py b/utils/clients/gooyal_wallet_client/models/application_deposit.py deleted file mode 100644 index 7f6d00f..0000000 --- a/utils/clients/gooyal_wallet_client/models/application_deposit.py +++ /dev/null @@ -1,170 +0,0 @@ -import datetime -from collections.abc import Mapping -from typing import Any, TypeVar, Union -from uuid import UUID - -from attrs import define as _attrs_define -from attrs import field as _attrs_field -from dateutil.parser import isoparse - -from ..models.state_enum import StateEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="ApplicationDeposit") - - -@_attrs_define -class ApplicationDeposit: - """ - Attributes: - payer (str): - payer_type (str): - payer_wallet (UUID): - payee (UUID): - payee_type (int): - payee_wallet (UUID): - created_at (datetime.datetime): - state (StateEnum): * `1` - created - * `2` - delayed - * `3` - pending - * `4` - incomplete - * `5` - success - * `6` - failed - * `7` - expected_failure - * `8` - ROLLED_BACK - * `9` - CANCELED - amount (int): - updated_at (datetime.datetime): - uuid (Union[Unset, UUID]): - details (Union[Unset, Any]): - """ - - payer: str - payer_type: str - payer_wallet: UUID - payee: UUID - payee_type: int - payee_wallet: UUID - created_at: datetime.datetime - state: StateEnum - amount: int - updated_at: datetime.datetime - uuid: Union[Unset, UUID] = UNSET - details: Union[Unset, Any] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - payer = self.payer - - payer_type = self.payer_type - - payer_wallet = str(self.payer_wallet) - - payee = str(self.payee) - - payee_type = self.payee_type - - payee_wallet = str(self.payee_wallet) - - created_at = self.created_at.isoformat() - - state = self.state.value - - amount = self.amount - - updated_at = self.updated_at.isoformat() - - uuid: Union[Unset, str] = UNSET - if not isinstance(self.uuid, Unset): - uuid = str(self.uuid) - - details = self.details - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "payer": payer, - "payer_type": payer_type, - "payer_wallet": payer_wallet, - "payee": payee, - "payee_type": payee_type, - "payee_wallet": payee_wallet, - "created_at": created_at, - "state": state, - "amount": amount, - "updated_at": updated_at, - } - ) - if uuid is not UNSET: - field_dict["uuid"] = uuid - if details is not UNSET: - field_dict["details"] = details - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - d = dict(src_dict) - payer = d.pop("payer") - - payer_type = d.pop("payer_type") - - payer_wallet = UUID(d.pop("payer_wallet")) - - payee = UUID(d.pop("payee")) - - payee_type = d.pop("payee_type") - - payee_wallet = UUID(d.pop("payee_wallet")) - - created_at = isoparse(d.pop("created_at")) - - state = StateEnum(d.pop("state")) - - amount = d.pop("amount") - - updated_at = isoparse(d.pop("updated_at")) - - _uuid = d.pop("uuid", UNSET) - uuid: Union[Unset, UUID] - if isinstance(_uuid, Unset): - uuid = UNSET - else: - uuid = UUID(_uuid) - - details = d.pop("details", UNSET) - - application_deposit = cls( - payer=payer, - payer_type=payer_type, - payer_wallet=payer_wallet, - payee=payee, - payee_type=payee_type, - payee_wallet=payee_wallet, - created_at=created_at, - state=state, - amount=amount, - updated_at=updated_at, - uuid=uuid, - details=details, - ) - - application_deposit.additional_properties = d - return application_deposit - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/application_withdraw.py b/utils/clients/gooyal_wallet_client/models/application_withdraw.py deleted file mode 100644 index ac64a92..0000000 --- a/utils/clients/gooyal_wallet_client/models/application_withdraw.py +++ /dev/null @@ -1,170 +0,0 @@ -import datetime -from collections.abc import Mapping -from typing import Any, TypeVar, Union -from uuid import UUID - -from attrs import define as _attrs_define -from attrs import field as _attrs_field -from dateutil.parser import isoparse - -from ..models.state_enum import StateEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="ApplicationWithdraw") - - -@_attrs_define -class ApplicationWithdraw: - """ - Attributes: - payer (UUID): - payer_type (int): - payer_wallet (UUID): - payee (str): - payee_type (str): - payee_wallet (UUID): - created_at (datetime.datetime): - state (StateEnum): * `1` - created - * `2` - delayed - * `3` - pending - * `4` - incomplete - * `5` - success - * `6` - failed - * `7` - expected_failure - * `8` - ROLLED_BACK - * `9` - CANCELED - amount (int): - updated_at (datetime.datetime): - uuid (Union[Unset, UUID]): - details (Union[Unset, Any]): - """ - - payer: UUID - payer_type: int - payer_wallet: UUID - payee: str - payee_type: str - payee_wallet: UUID - created_at: datetime.datetime - state: StateEnum - amount: int - updated_at: datetime.datetime - uuid: Union[Unset, UUID] = UNSET - details: Union[Unset, Any] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - payer = str(self.payer) - - payer_type = self.payer_type - - payer_wallet = str(self.payer_wallet) - - payee = self.payee - - payee_type = self.payee_type - - payee_wallet = str(self.payee_wallet) - - created_at = self.created_at.isoformat() - - state = self.state.value - - amount = self.amount - - updated_at = self.updated_at.isoformat() - - uuid: Union[Unset, str] = UNSET - if not isinstance(self.uuid, Unset): - uuid = str(self.uuid) - - details = self.details - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "payer": payer, - "payer_type": payer_type, - "payer_wallet": payer_wallet, - "payee": payee, - "payee_type": payee_type, - "payee_wallet": payee_wallet, - "created_at": created_at, - "state": state, - "amount": amount, - "updated_at": updated_at, - } - ) - if uuid is not UNSET: - field_dict["uuid"] = uuid - if details is not UNSET: - field_dict["details"] = details - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - d = dict(src_dict) - payer = UUID(d.pop("payer")) - - payer_type = d.pop("payer_type") - - payer_wallet = UUID(d.pop("payer_wallet")) - - payee = d.pop("payee") - - payee_type = d.pop("payee_type") - - payee_wallet = UUID(d.pop("payee_wallet")) - - created_at = isoparse(d.pop("created_at")) - - state = StateEnum(d.pop("state")) - - amount = d.pop("amount") - - updated_at = isoparse(d.pop("updated_at")) - - _uuid = d.pop("uuid", UNSET) - uuid: Union[Unset, UUID] - if isinstance(_uuid, Unset): - uuid = UNSET - else: - uuid = UUID(_uuid) - - details = d.pop("details", UNSET) - - application_withdraw = cls( - payer=payer, - payer_type=payer_type, - payer_wallet=payer_wallet, - payee=payee, - payee_type=payee_type, - payee_wallet=payee_wallet, - created_at=created_at, - state=state, - amount=amount, - updated_at=updated_at, - uuid=uuid, - details=details, - ) - - application_withdraw.additional_properties = d - return application_withdraw - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/paginated_account_list.py b/utils/clients/gooyal_wallet_client/models/paginated_account_list.py deleted file mode 100644 index 18aee85..0000000 --- a/utils/clients/gooyal_wallet_client/models/paginated_account_list.py +++ /dev/null @@ -1,123 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar, Union, cast - -from attrs import define as _attrs_define -from attrs import field as _attrs_field - -from ..types import UNSET, Unset - -if TYPE_CHECKING: - from ..models.account import Account - - -T = TypeVar("T", bound="PaginatedAccountList") - - -@_attrs_define -class PaginatedAccountList: - """ - Attributes: - count (int): Example: 123. - results (list['Account']): - next_ (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=400&limit=100. - previous (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=200&limit=100. - """ - - count: int - results: list["Account"] - next_: Union[None, Unset, str] = UNSET - previous: Union[None, Unset, str] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - count = self.count - - results = [] - for results_item_data in self.results: - results_item = results_item_data.to_dict() - results.append(results_item) - - next_: Union[None, Unset, str] - if isinstance(self.next_, Unset): - next_ = UNSET - else: - next_ = self.next_ - - previous: Union[None, Unset, str] - if isinstance(self.previous, Unset): - previous = UNSET - else: - previous = self.previous - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "count": count, - "results": results, - } - ) - if next_ is not UNSET: - field_dict["next"] = next_ - if previous is not UNSET: - field_dict["previous"] = previous - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.account import Account - - d = dict(src_dict) - count = d.pop("count") - - results = [] - _results = d.pop("results") - for results_item_data in _results: - results_item = Account.from_dict(results_item_data) - - results.append(results_item) - - def _parse_next_(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - next_ = _parse_next_(d.pop("next", UNSET)) - - def _parse_previous(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - previous = _parse_previous(d.pop("previous", UNSET)) - - paginated_account_list = cls( - count=count, - results=results, - next_=next_, - previous=previous, - ) - - paginated_account_list.additional_properties = d - return paginated_account_list - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/paginated_transaction_grouped_list.py b/utils/clients/gooyal_wallet_client/models/paginated_transaction_grouped_list.py deleted file mode 100644 index ebde34e..0000000 --- a/utils/clients/gooyal_wallet_client/models/paginated_transaction_grouped_list.py +++ /dev/null @@ -1,123 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar, Union, cast - -from attrs import define as _attrs_define -from attrs import field as _attrs_field - -from ..types import UNSET, Unset - -if TYPE_CHECKING: - from ..models.transaction_grouped import TransactionGrouped - - -T = TypeVar("T", bound="PaginatedTransactionGroupedList") - - -@_attrs_define -class PaginatedTransactionGroupedList: - """ - Attributes: - count (int): Example: 123. - results (list['TransactionGrouped']): - next_ (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=400&limit=100. - previous (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=200&limit=100. - """ - - count: int - results: list["TransactionGrouped"] - next_: Union[None, Unset, str] = UNSET - previous: Union[None, Unset, str] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - count = self.count - - results = [] - for results_item_data in self.results: - results_item = results_item_data.to_dict() - results.append(results_item) - - next_: Union[None, Unset, str] - if isinstance(self.next_, Unset): - next_ = UNSET - else: - next_ = self.next_ - - previous: Union[None, Unset, str] - if isinstance(self.previous, Unset): - previous = UNSET - else: - previous = self.previous - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "count": count, - "results": results, - } - ) - if next_ is not UNSET: - field_dict["next"] = next_ - if previous is not UNSET: - field_dict["previous"] = previous - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.transaction_grouped import TransactionGrouped - - d = dict(src_dict) - count = d.pop("count") - - results = [] - _results = d.pop("results") - for results_item_data in _results: - results_item = TransactionGrouped.from_dict(results_item_data) - - results.append(results_item) - - def _parse_next_(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - next_ = _parse_next_(d.pop("next", UNSET)) - - def _parse_previous(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - previous = _parse_previous(d.pop("previous", UNSET)) - - paginated_transaction_grouped_list = cls( - count=count, - results=results, - next_=next_, - previous=previous, - ) - - paginated_transaction_grouped_list.additional_properties = d - return paginated_transaction_grouped_list - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/paginated_transaction_list.py b/utils/clients/gooyal_wallet_client/models/paginated_transaction_list.py deleted file mode 100644 index 71f2a07..0000000 --- a/utils/clients/gooyal_wallet_client/models/paginated_transaction_list.py +++ /dev/null @@ -1,123 +0,0 @@ -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar, Union, cast - -from attrs import define as _attrs_define -from attrs import field as _attrs_field - -from ..types import UNSET, Unset - -if TYPE_CHECKING: - from ..models.transaction import Transaction - - -T = TypeVar("T", bound="PaginatedTransactionList") - - -@_attrs_define -class PaginatedTransactionList: - """ - Attributes: - count (int): Example: 123. - results (list['Transaction']): - next_ (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=400&limit=100. - previous (Union[None, Unset, str]): Example: http://api.example.org/accounts/?offset=200&limit=100. - """ - - count: int - results: list["Transaction"] - next_: Union[None, Unset, str] = UNSET - previous: Union[None, Unset, str] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - count = self.count - - results = [] - for results_item_data in self.results: - results_item = results_item_data.to_dict() - results.append(results_item) - - next_: Union[None, Unset, str] - if isinstance(self.next_, Unset): - next_ = UNSET - else: - next_ = self.next_ - - previous: Union[None, Unset, str] - if isinstance(self.previous, Unset): - previous = UNSET - else: - previous = self.previous - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "count": count, - "results": results, - } - ) - if next_ is not UNSET: - field_dict["next"] = next_ - if previous is not UNSET: - field_dict["previous"] = previous - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.transaction import Transaction - - d = dict(src_dict) - count = d.pop("count") - - results = [] - _results = d.pop("results") - for results_item_data in _results: - results_item = Transaction.from_dict(results_item_data) - - results.append(results_item) - - def _parse_next_(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - next_ = _parse_next_(d.pop("next", UNSET)) - - def _parse_previous(data: object) -> Union[None, Unset, str]: - if data is None: - return data - if isinstance(data, Unset): - return data - return cast(Union[None, Unset, str], data) - - previous = _parse_previous(d.pop("previous", UNSET)) - - paginated_transaction_list = cls( - count=count, - results=results, - next_=next_, - previous=previous, - ) - - paginated_transaction_list.additional_properties = d - return paginated_transaction_list - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/state_enum.py b/utils/clients/gooyal_wallet_client/models/state_enum.py deleted file mode 100644 index dac91c3..0000000 --- a/utils/clients/gooyal_wallet_client/models/state_enum.py +++ /dev/null @@ -1,16 +0,0 @@ -from enum import IntEnum - - -class StateEnum(IntEnum): - VALUE_1 = 1 - VALUE_2 = 2 - VALUE_3 = 3 - VALUE_4 = 4 - VALUE_5 = 5 - VALUE_6 = 6 - VALUE_7 = 7 - VALUE_8 = 8 - VALUE_9 = 9 - - def __str__(self) -> str: - return str(self.value) diff --git a/utils/clients/gooyal_wallet_client/models/transaction.py b/utils/clients/gooyal_wallet_client/models/transaction.py deleted file mode 100644 index 41a7a83..0000000 --- a/utils/clients/gooyal_wallet_client/models/transaction.py +++ /dev/null @@ -1,178 +0,0 @@ -import datetime -from collections.abc import Mapping -from typing import Any, TypeVar, Union -from uuid import UUID - -from attrs import define as _attrs_define -from attrs import field as _attrs_field -from dateutil.parser import isoparse - -from ..models.state_enum import StateEnum -from ..types import UNSET, Unset - -T = TypeVar("T", bound="Transaction") - - -@_attrs_define -class Transaction: - """ - Attributes: - uuid (UUID): - payer (str): - payer_type (str): - payer_wallet (str): - payee (UUID): - payee_type (int): - payee_wallet (str): - created_at (datetime.datetime): - state (StateEnum): * `1` - created - * `2` - delayed - * `3` - pending - * `4` - incomplete - * `5` - success - * `6` - failed - * `7` - expected_failure - * `8` - ROLLED_BACK - * `9` - CANCELED - amount (int): - updated_at (datetime.datetime): - details (Any): - role (int): - delay (Union[Unset, int]): - """ - - uuid: UUID - payer: str - payer_type: str - payer_wallet: str - payee: UUID - payee_type: int - payee_wallet: str - created_at: datetime.datetime - state: StateEnum - amount: int - updated_at: datetime.datetime - details: Any - role: int - delay: Union[Unset, int] = UNSET - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - uuid = str(self.uuid) - - payer = self.payer - - payer_type = self.payer_type - - payer_wallet = self.payer_wallet - - payee = str(self.payee) - - payee_type = self.payee_type - - payee_wallet = self.payee_wallet - - created_at = self.created_at.isoformat() - - state = self.state.value - - amount = self.amount - - updated_at = self.updated_at.isoformat() - - details = self.details - - role = self.role - - delay = self.delay - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "uuid": uuid, - "payer": payer, - "payer_type": payer_type, - "payer_wallet": payer_wallet, - "payee": payee, - "payee_type": payee_type, - "payee_wallet": payee_wallet, - "created_at": created_at, - "state": state, - "amount": amount, - "updated_at": updated_at, - "details": details, - "role": role, - } - ) - if delay is not UNSET: - field_dict["delay"] = delay - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - d = dict(src_dict) - uuid = UUID(d.pop("uuid")) - - payer = d.pop("payer") - - payer_type = d.pop("payer_type") - - payer_wallet = d.pop("payer_wallet") - - payee = UUID(d.pop("payee")) - - payee_type = d.pop("payee_type") - - payee_wallet = d.pop("payee_wallet") - - created_at = isoparse(d.pop("created_at")) - - state = StateEnum(d.pop("state")) - - amount = d.pop("amount") - - updated_at = isoparse(d.pop("updated_at")) - - details = d.pop("details") - - role = d.pop("role") - - delay = d.pop("delay", UNSET) - - transaction = cls( - uuid=uuid, - payer=payer, - payer_type=payer_type, - payer_wallet=payer_wallet, - payee=payee, - payee_type=payee_type, - payee_wallet=payee_wallet, - created_at=created_at, - state=state, - amount=amount, - updated_at=updated_at, - details=details, - role=role, - delay=delay, - ) - - transaction.additional_properties = d - return transaction - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/models/transaction_grouped.py b/utils/clients/gooyal_wallet_client/models/transaction_grouped.py deleted file mode 100644 index bf72d4c..0000000 --- a/utils/clients/gooyal_wallet_client/models/transaction_grouped.py +++ /dev/null @@ -1,140 +0,0 @@ -import datetime -from collections.abc import Mapping -from typing import TYPE_CHECKING, Any, TypeVar -from uuid import UUID - -from attrs import define as _attrs_define -from attrs import field as _attrs_field -from dateutil.parser import isoparse - -if TYPE_CHECKING: - from ..models.transaction import Transaction - - -T = TypeVar("T", bound="TransactionGrouped") - - -@_attrs_define -class TransactionGrouped: - """ - Attributes: - reference (UUID): - application (UUID): - total_amount (float): - total_count (int): - state (int): - description (str): - created_at (datetime.datetime): - role (int): - transactions (list['Transaction']): - """ - - reference: UUID - application: UUID - total_amount: float - total_count: int - state: int - description: str - created_at: datetime.datetime - role: int - transactions: list["Transaction"] - additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict) - - def to_dict(self) -> dict[str, Any]: - reference = str(self.reference) - - application = str(self.application) - - total_amount = self.total_amount - - total_count = self.total_count - - state = self.state - - description = self.description - - created_at = self.created_at.isoformat() - - role = self.role - - transactions = [] - for transactions_item_data in self.transactions: - transactions_item = transactions_item_data.to_dict() - transactions.append(transactions_item) - - field_dict: dict[str, Any] = {} - field_dict.update(self.additional_properties) - field_dict.update( - { - "reference": reference, - "application": application, - "total_amount": total_amount, - "total_count": total_count, - "state": state, - "description": description, - "created_at": created_at, - "role": role, - "transactions": transactions, - } - ) - - return field_dict - - @classmethod - def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T: - from ..models.transaction import Transaction - - d = dict(src_dict) - reference = UUID(d.pop("reference")) - - application = UUID(d.pop("application")) - - total_amount = d.pop("total_amount") - - total_count = d.pop("total_count") - - state = d.pop("state") - - description = d.pop("description") - - created_at = isoparse(d.pop("created_at")) - - role = d.pop("role") - - transactions = [] - _transactions = d.pop("transactions") - for transactions_item_data in _transactions: - transactions_item = Transaction.from_dict(transactions_item_data) - - transactions.append(transactions_item) - - transaction_grouped = cls( - reference=reference, - application=application, - total_amount=total_amount, - total_count=total_count, - state=state, - description=description, - created_at=created_at, - role=role, - transactions=transactions, - ) - - transaction_grouped.additional_properties = d - return transaction_grouped - - @property - def additional_keys(self) -> list[str]: - return list(self.additional_properties.keys()) - - def __getitem__(self, key: str) -> Any: - return self.additional_properties[key] - - def __setitem__(self, key: str, value: Any) -> None: - self.additional_properties[key] = value - - def __delitem__(self, key: str) -> None: - del self.additional_properties[key] - - def __contains__(self, key: str) -> bool: - return key in self.additional_properties diff --git a/utils/clients/gooyal_wallet_client/py.typed b/utils/clients/gooyal_wallet_client/py.typed deleted file mode 100644 index 1aad327..0000000 --- a/utils/clients/gooyal_wallet_client/py.typed +++ /dev/null @@ -1 +0,0 @@ -# Marker file for PEP 561 \ No newline at end of file diff --git a/utils/clients/gooyal_wallet_client/types.py b/utils/clients/gooyal_wallet_client/types.py deleted file mode 100644 index 1b96ca4..0000000 --- a/utils/clients/gooyal_wallet_client/types.py +++ /dev/null @@ -1,54 +0,0 @@ -"""Contains some shared types for properties""" - -from collections.abc import Mapping, MutableMapping -from http import HTTPStatus -from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union - -from attrs import define - - -class Unset: - def __bool__(self) -> Literal[False]: - return False - - -UNSET: Unset = Unset() - -# The types that `httpx.Client(files=)` can accept, copied from that library. -FileContent = Union[IO[bytes], bytes, str] -FileTypes = Union[ - # (filename, file (or bytes), content_type) - tuple[Optional[str], FileContent, Optional[str]], - # (filename, file (or bytes), content_type, headers) - tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]], -] -RequestFiles = list[tuple[str, FileTypes]] - - -@define -class File: - """Contains information for file uploads""" - - payload: BinaryIO - file_name: Optional[str] = None - mime_type: Optional[str] = None - - def to_tuple(self) -> FileTypes: - """Return a tuple representation that httpx will accept for multipart/form-data""" - return self.file_name, self.payload, self.mime_type - - -T = TypeVar("T") - - -@define -class Response(Generic[T]): - """A response from an endpoint""" - - status_code: HTTPStatus - content: bytes - headers: MutableMapping[str, str] - parsed: Optional[T] - - -__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"] diff --git a/utils/wallet_client.py b/utils/wallet_client.py deleted file mode 100644 index 87e5b8b..0000000 --- a/utils/wallet_client.py +++ /dev/null @@ -1,139 +0,0 @@ -import time - -import requests -from django.conf import settings -from django.core.cache import cache -from httpx import Request - -from utils.clients.gooyal_wallet_client import AuthenticatedClient -from utils.clients.gooyal_wallet_client.models import Transaction, Account, ApplicationDeposit, ApplicationWithdraw, PaginatedAccountList -from utils.clients.gooyal_wallet_client.api.wallet import (wallet_api_application_deposit_create, - wallet_api_application_deposit_rollback_retrieve, - wallet_api_application_deposit_verify_retrieve, - wallet_api_application_withdraw_create, - wallet_api_application_withdraw_rollback_retrieve, - wallet_api_application_withdraw_verify_retrieve, - wallet_api_application_user_wallets_list) - - - - -def login_as_client_credentials(): - access_token = cache.get('settlement_access_token') - # expires_in = self.auth_data.get('expires_in') - # created_at = self.auth_data.get('created_at') - # - # if access_token and expires_in > time.time() - created_at: - # return self.auth_data - if access_token: - print('already in cache') - return access_token - - print('not in cache') - - data = { - "grant_type": 'client_credentials', - "scope": settings.OAUTH2_PROVIDER_SCOPES, - } - auth = (settings.OAUTH2_PROVIDER_CLIENT_ID, settings.OAUTH2_PROVIDER_CLIENT_SECRET) - - response = requests.post(f'{settings.OAUTH2_PROVIDER_BASE_PUBLIC_URL}/token/', - data=data, - auth=auth) - print(response.content) - - auth_data = response.json() - if 'access_token' in auth_data: - auth_data['created_at'] = time.time() - cache.set('settlement_access_token', auth_data, timeout=auth_data.get('expires_in') - 5) - - return auth_data - - -def log_request(request: Request): - print(request.headers['authorization']) - print( - f"Request event hook: {request.method} {request.url} {request.method} {request.headers} - Waiting for response") - - -def log_response(response): - request = response.request - print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}") - - -def get_client(): - access_token = login_as_client_credentials()['access_token'] - client = AuthenticatedClient(base_url=settings.WALLET_BASE_PUBLIC_URL, token=access_token, - httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}}, - ) - return client - - -def deposit_to_user_wallet_submit(payer_wallet, data): - class Tmp(): - def to_dict(self): - return data - - deposit_data = Tmp() - client = get_client() - response: ApplicationDeposit = wallet_api_application_deposit_create.sync(payer_wallet=payer_wallet, - client=client, - body=deposit_data) - print(response) - return response - - -def deposit_to_user_wallet_verify(payer_wallet, uuid): - client = get_client() - response: ApplicationDeposit = wallet_api_application_deposit_verify_retrieve.sync(payer_wallet=payer_wallet, uuid=uuid, client=client) - print(response) - return response - -def rollback_deposit_to_user_wallet(payer_wallet, uuid): - client = get_client() - response: ApplicationDeposit = wallet_api_application_deposit_rollback_retrieve.sync(payer_wallet=payer_wallet, uuid=uuid, client=client) - print(response) - return response - - -def withdraw_from_user_wallet_submit(payee_wallet, data): - class Tmp(): - def to_dict(self): - return data - - withdraw_data = Tmp() - client = get_client() - response: ApplicationWithdraw = wallet_api_application_withdraw_create.sync(payee_wallet=payee_wallet, client=client, body=withdraw_data) - print(response) - return response - -def rollback_withdraw_from_user_wallet(payee_wallet, uuid): - client = get_client() - response: ApplicationWithdraw = wallet_api_application_withdraw_rollback_retrieve.sync(payee_wallet=payee_wallet, uuid=uuid, client=client) - print(response) - return response - - -def withdraw_from_user_wallet_verify(payee_wallet, uuid): - client = get_client() - response: ApplicationWithdraw = wallet_api_application_withdraw_verify_retrieve.sync(payee_wallet=payee_wallet, uuid=uuid, client=client) - print(response) - return response - - -def get_user_wallets(owner, wallets): - client = get_client() - # by pass several wallet query params: [','.join([str(i) for i in wallets])] - response: PaginatedAccountList = wallet_api_application_user_wallets_list.sync(owner=owner, wallet=[','.join([str(i) for i in wallets])], client=client) - print(response) - balances = dict(map(lambda result: (str(result.wallet), result.balance), response.results)) - return balances - - -sample_data = { - "uuid": "3fa85f64-5717-4562-b3fc-2c963f66afb1", - "payee_id": "5d66d02e-6087-4b0a-bb0c-291d5c11755a", - "payee_type": 1, - "amount": 2000, - "details": "string", -}