pinelabs-python 0.1.0__py3-none-any.whl

pinelabs/convenience_fee/client.py

@@ -0,0 +1,156 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.request_options import RequestOptions
+from ..types.amount import Amount
+from ..types.calculate_convenience_fee_response import CalculateConvenienceFeeResponse
+from .raw_client import AsyncRawConvenienceFeeClient, RawConvenienceFeeClient
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class ConvenienceFeeClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawConvenienceFeeClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawConvenienceFeeClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawConvenienceFeeClient
+        """
+        return self._raw_client
+
+    def calculate_convenience_fee(
+        self,
+        *,
+        amount: Amount,
+        payment_method: str,
+        network_type: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> CalculateConvenienceFeeResponse:
+        """
+        Calculate the convenience fee for a payment against an order based on
+        the payment method and amount.
+
+        Parameters
+        ----------
+        amount : Amount
+
+        payment_method : str
+            Payment method for fee calculation.
+
+        network_type : typing.Optional[str]
+            Card network type for more specific fee calculation.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CalculateConvenienceFeeResponse
+            Convenience fee calculated successfully.
+
+        Examples
+        --------
+        from pinelabs import Amount, PinelabsApi
+
+        client = PinelabsApi(
+            request_timestamp="YOUR_REQUEST_TIMESTAMP",
+            request_id="YOUR_REQUEST_ID",
+            token="YOUR_TOKEN",
+        )
+        client.convenience_fee.calculate_convenience_fee(
+            amount=Amount(
+                value=50000,
+                currency="INR",
+            ),
+            payment_method="CARD",
+        )
+        """
+        _response = self._raw_client.calculate_convenience_fee(
+            amount=amount, payment_method=payment_method, network_type=network_type, request_options=request_options
+        )
+        return _response.data
+
+
+class AsyncConvenienceFeeClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawConvenienceFeeClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawConvenienceFeeClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawConvenienceFeeClient
+        """
+        return self._raw_client
+
+    async def calculate_convenience_fee(
+        self,
+        *,
+        amount: Amount,
+        payment_method: str,
+        network_type: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> CalculateConvenienceFeeResponse:
+        """
+        Calculate the convenience fee for a payment against an order based on
+        the payment method and amount.
+
+        Parameters
+        ----------
+        amount : Amount
+
+        payment_method : str
+            Payment method for fee calculation.
+
+        network_type : typing.Optional[str]
+            Card network type for more specific fee calculation.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        CalculateConvenienceFeeResponse
+            Convenience fee calculated successfully.
+
+        Examples
+        --------
+        import asyncio
+
+        from pinelabs import Amount, AsyncPinelabsApi
+
+        client = AsyncPinelabsApi(
+            request_timestamp="YOUR_REQUEST_TIMESTAMP",
+            request_id="YOUR_REQUEST_ID",
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.convenience_fee.calculate_convenience_fee(
+                amount=Amount(
+                    value=50000,
+                    currency="INR",
+                ),
+                payment_method="CARD",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.calculate_convenience_fee(
+            amount=amount, payment_method=payment_method, network_type=network_type, request_options=request_options
+        )
+        return _response.data

pinelabs/convenience_fee/raw_client.py

@@ -0,0 +1,247 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+from json.decoder import JSONDecodeError
+
+from ..core.api_error import ApiError
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ..core.http_response import AsyncHttpResponse, HttpResponse
+from ..core.parse_error import ParsingError
+from ..core.pydantic_utilities import parse_obj_as
+from ..core.request_options import RequestOptions
+from ..core.serialization import convert_and_respect_annotation_metadata
+from ..errors.bad_request_error import BadRequestError
+from ..errors.internal_server_error import InternalServerError
+from ..errors.unauthorized_error import UnauthorizedError
+from ..errors.unprocessable_entity_error import UnprocessableEntityError
+from ..types.amount import Amount
+from ..types.calculate_convenience_fee_response import CalculateConvenienceFeeResponse
+from ..types.error_response import ErrorResponse
+from pydantic import ValidationError
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawConvenienceFeeClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def calculate_convenience_fee(
+        self,
+        *,
+        amount: Amount,
+        payment_method: str,
+        network_type: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[CalculateConvenienceFeeResponse]:
+        """
+        Calculate the convenience fee for a payment against an order based on
+        the payment method and amount.
+
+        Parameters
+        ----------
+        amount : Amount
+
+        payment_method : str
+            Payment method for fee calculation.
+
+        network_type : typing.Optional[str]
+            Card network type for more specific fee calculation.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[CalculateConvenienceFeeResponse]
+            Convenience fee calculated successfully.
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "api/v1/fees",
+            method="POST",
+            json={
+                "amount": convert_and_respect_annotation_metadata(object_=amount, annotation=Amount, direction="write"),
+                "payment_method": payment_method,
+                "network_type": network_type,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CalculateConvenienceFeeResponse,
+                    parse_obj_as(
+                        type_=CalculateConvenienceFeeResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+
+class AsyncRawConvenienceFeeClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def calculate_convenience_fee(
+        self,
+        *,
+        amount: Amount,
+        payment_method: str,
+        network_type: typing.Optional[str] = OMIT,
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[CalculateConvenienceFeeResponse]:
+        """
+        Calculate the convenience fee for a payment against an order based on
+        the payment method and amount.
+
+        Parameters
+        ----------
+        amount : Amount
+
+        payment_method : str
+            Payment method for fee calculation.
+
+        network_type : typing.Optional[str]
+            Card network type for more specific fee calculation.
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[CalculateConvenienceFeeResponse]
+            Convenience fee calculated successfully.
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "api/v1/fees",
+            method="POST",
+            json={
+                "amount": convert_and_respect_annotation_metadata(object_=amount, annotation=Amount, direction="write"),
+                "payment_method": payment_method,
+                "network_type": network_type,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    CalculateConvenienceFeeResponse,
+                    parse_obj_as(
+                        type_=CalculateConvenienceFeeResponse,  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            if _response.status_code == 400:
+                raise BadRequestError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 401:
+                raise UnauthorizedError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 422:
+                raise UnprocessableEntityError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        typing.Any,
+                        parse_obj_as(
+                            type_=typing.Any,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            if _response.status_code == 500:
+                raise InternalServerError(
+                    headers=dict(_response.headers),
+                    body=typing.cast(
+                        ErrorResponse,
+                        parse_obj_as(
+                            type_=ErrorResponse,  # type: ignore
+                            object_=_response.json(),
+                        ),
+                    ),
+                )
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        except ValidationError as e:
+            raise ParsingError(
+                status_code=_response.status_code, headers=dict(_response.headers), body=_response.json(), cause=e
+            )
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

pinelabs/core/__init__.py

@@ -0,0 +1,127 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .api_error import ApiError
+    from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
+    from .datetime_utils import Rfc2822DateTime, parse_rfc2822_datetime, serialize_datetime
+    from .file import File, convert_file_dict_to_httpx_tuples, with_content_type
+    from .http_client import AsyncHttpClient, HttpClient
+    from .http_response import AsyncHttpResponse, HttpResponse
+    from .jsonable_encoder import encode_path_param, jsonable_encoder
+    from .logging import ConsoleLogger, ILogger, LogConfig, LogLevel, Logger, create_logger
+    from .parse_error import ParsingError
+    from .pydantic_utilities import (
+        IS_PYDANTIC_V2,
+        UniversalBaseModel,
+        UniversalRootModel,
+        parse_obj_as,
+        universal_field_validator,
+        universal_root_validator,
+        update_forward_refs,
+    )
+    from .query_encoder import encode_query
+    from .remove_none_from_dict import remove_none_from_dict
+    from .request_options import RequestOptions
+    from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApiError": ".api_error",
+    "AsyncClientWrapper": ".client_wrapper",
+    "AsyncHttpClient": ".http_client",
+    "AsyncHttpResponse": ".http_response",
+    "BaseClientWrapper": ".client_wrapper",
+    "ConsoleLogger": ".logging",
+    "FieldMetadata": ".serialization",
+    "File": ".file",
+    "HttpClient": ".http_client",
+    "HttpResponse": ".http_response",
+    "ILogger": ".logging",
+    "IS_PYDANTIC_V2": ".pydantic_utilities",
+    "LogConfig": ".logging",
+    "LogLevel": ".logging",
+    "Logger": ".logging",
+    "ParsingError": ".parse_error",
+    "RequestOptions": ".request_options",
+    "Rfc2822DateTime": ".datetime_utils",
+    "SyncClientWrapper": ".client_wrapper",
+    "UniversalBaseModel": ".pydantic_utilities",
+    "UniversalRootModel": ".pydantic_utilities",
+    "convert_and_respect_annotation_metadata": ".serialization",
+    "convert_file_dict_to_httpx_tuples": ".file",
+    "create_logger": ".logging",
+    "encode_path_param": ".jsonable_encoder",
+    "encode_query": ".query_encoder",
+    "jsonable_encoder": ".jsonable_encoder",
+    "parse_obj_as": ".pydantic_utilities",
+    "parse_rfc2822_datetime": ".datetime_utils",
+    "remove_none_from_dict": ".remove_none_from_dict",
+    "serialize_datetime": ".datetime_utils",
+    "universal_field_validator": ".pydantic_utilities",
+    "universal_root_validator": ".pydantic_utilities",
+    "update_forward_refs": ".pydantic_utilities",
+    "with_content_type": ".file",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "AsyncHttpClient",
+    "AsyncHttpResponse",
+    "BaseClientWrapper",
+    "ConsoleLogger",
+    "FieldMetadata",
+    "File",
+    "HttpClient",
+    "HttpResponse",
+    "ILogger",
+    "IS_PYDANTIC_V2",
+    "LogConfig",
+    "LogLevel",
+    "Logger",
+    "ParsingError",
+    "RequestOptions",
+    "Rfc2822DateTime",
+    "SyncClientWrapper",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "convert_and_respect_annotation_metadata",
+    "convert_file_dict_to_httpx_tuples",
+    "create_logger",
+    "encode_path_param",
+    "encode_query",
+    "jsonable_encoder",
+    "parse_obj_as",
+    "parse_rfc2822_datetime",
+    "remove_none_from_dict",
+    "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
+    "with_content_type",
+]

pinelabs/core/api_error.py

@@ -0,0 +1,23 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import Any, Dict, Optional
+
+
+class ApiError(Exception):
+    headers: Optional[Dict[str, str]]
+    status_code: Optional[int]
+    body: Any
+
+    def __init__(
+        self,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        status_code: Optional[int] = None,
+        body: Any = None,
+    ) -> None:
+        self.headers = headers
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"headers: {self.headers}, status_code: {self.status_code}, body: {self.body}"

pinelabs/core/client_wrapper.py

@@ -0,0 +1,132 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+import typing
+
+import httpx
+from .http_client import AsyncHttpClient, HttpClient
+from .logging import LogConfig, Logger
+
+
+class BaseClientWrapper:
+    def __init__(
+        self,
+        *,
+        request_timestamp: typing.Optional[dt.datetime] = None,
+        request_id: typing.Optional[str] = None,
+        token: typing.Union[str, typing.Callable[[], str]],
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+    ):
+        self._request_timestamp = request_timestamp
+        self._request_id = request_id
+        self._token = token
+        self._headers = headers
+        self._base_url = base_url
+        self._timeout = timeout
+        self._logging = logging
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        import platform
+
+        headers: typing.Dict[str, str] = {
+            "X-Fern-Language": "Python",
+            "X-Fern-Runtime": f"python/{platform.python_version()}",
+            "X-Fern-Platform": f"{platform.system().lower()}/{platform.release()}",
+            **(self.get_custom_headers() or {}),
+        }
+        if self._request_timestamp is not None:
+            headers["Request-Timestamp"] = str(self._request_timestamp)
+        if self._request_id is not None:
+            headers["Request-ID"] = self._request_id
+        headers["Authorization"] = f"Bearer {self._get_token()}"
+        return headers
+
+    def _get_token(self) -> str:
+        if isinstance(self._token, str):
+            return self._token
+        else:
+            return self._token()
+
+    def get_custom_headers(self) -> typing.Optional[typing.Dict[str, str]]:
+        return self._headers
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+    def get_timeout(self) -> typing.Optional[float]:
+        return self._timeout
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        request_timestamp: typing.Optional[dt.datetime] = None,
+        request_id: typing.Optional[str] = None,
+        token: typing.Union[str, typing.Callable[[], str]],
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+        httpx_client: httpx.Client,
+    ):
+        super().__init__(
+            request_timestamp=request_timestamp,
+            request_id=request_id,
+            token=token,
+            headers=headers,
+            base_url=base_url,
+            timeout=timeout,
+            logging=logging,
+        )
+        self.httpx_client = HttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            base_url=self.get_base_url,
+            logging_config=self._logging,
+        )
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        request_timestamp: typing.Optional[dt.datetime] = None,
+        request_id: typing.Optional[str] = None,
+        token: typing.Union[str, typing.Callable[[], str]],
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        logging: typing.Optional[typing.Union[LogConfig, Logger]] = None,
+        async_token: typing.Optional[typing.Callable[[], typing.Awaitable[str]]] = None,
+        httpx_client: httpx.AsyncClient,
+    ):
+        super().__init__(
+            request_timestamp=request_timestamp,
+            request_id=request_id,
+            token=token,
+            headers=headers,
+            base_url=base_url,
+            timeout=timeout,
+            logging=logging,
+        )
+        self._async_token = async_token
+        self.httpx_client = AsyncHttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            base_url=self.get_base_url,
+            async_base_headers=self.async_get_headers,
+            logging_config=self._logging,
+        )
+
+    async def async_get_headers(self) -> typing.Dict[str, str]:
+        headers = self.get_headers()
+        if self._async_token is not None:
+            token = await self._async_token()
+            headers["Authorization"] = f"Bearer {token}"
+        return headers