airwallex-sdk 0.1.0__py3-none-any.whl

airwallex/models/payment.py

@@ -0,0 +1,81 @@
+"""
+Models for the Airwallex payment API.
+"""
+from typing import Optional, List, Dict, Any, Union
+from datetime import datetime
+from pydantic import Field, EmailStr
+from .base import AirwallexModel
+
+
+class PaymentAmount(AirwallexModel):
+    """Model for payment amount."""
+    value: float = Field(..., description="Payment amount value")
+    currency: str = Field(..., description="Currency code (ISO 4217)")
+
+
+class PaymentSourceDetails(AirwallexModel):
+    """Model for payment source details."""
+    type: str = Field(..., description="Source type (e.g., 'account')")
+    account_id: Optional[str] = Field(None, description="Account ID for account sources")
+    card_id: Optional[str] = Field(None, description="Card ID for card sources")
+
+
+class PaymentBeneficiary(AirwallexModel):
+    """Model for payment beneficiary."""
+    type: str = Field(..., description="Beneficiary type (e.g., 'bank_account', 'email')")
+    id: Optional[str] = Field(None, description="Beneficiary ID for saved beneficiaries")
+    name: Optional[str] = Field(None, description="Beneficiary name")
+    email: Optional[EmailStr] = Field(None, description="Beneficiary email")
+    country_code: Optional[str] = Field(None, description="Beneficiary country code (ISO 3166-1 alpha-2)")
+    bank_details: Optional[Dict[str, Any]] = Field(None, description="Bank details for bank transfers")
+
+
+class Payment(AirwallexModel):
+    """Model for an Airwallex payment."""
+    resource_name: str = "payments"
+    
+    id: str = Field(..., description="Unique payment ID")
+    request_id: Optional[str] = Field(None, description="Client-generated request ID")
+    amount: PaymentAmount = Field(..., description="Payment amount")
+    source: PaymentSourceDetails = Field(..., description="Payment source details")
+    beneficiary: PaymentBeneficiary = Field(..., description="Payment beneficiary details")
+    payment_method: str = Field(..., description="Payment method type")
+    status: str = Field(..., description="Payment status")
+    payment_date: Optional[datetime] = Field(None, description="Payment date")
+    reference: Optional[str] = Field(None, description="Payment reference")
+    description: Optional[str] = Field(None, description="Payment description")
+    metadata: Optional[Dict[str, str]] = Field(None, description="Additional metadata")
+    created_at: datetime = Field(..., description="Payment creation timestamp")
+    updated_at: Optional[datetime] = Field(None, description="Payment last update timestamp")
+
+
+class PaymentCreateRequest(AirwallexModel):
+    """Model for payment creation request."""
+    request_id: str = Field(..., description="Client-generated unique ID for the request")
+    amount: PaymentAmount = Field(..., description="Payment amount")
+    source: PaymentSourceDetails = Field(..., description="Payment source details")
+    beneficiary: PaymentBeneficiary = Field(..., description="Payment beneficiary details")
+    payment_method: str = Field(..., description="Payment method type")
+    payment_date: Optional[datetime] = Field(None, description="Requested payment date")
+    reference: Optional[str] = Field(None, description="Payment reference visible to the beneficiary")
+    description: Optional[str] = Field(None, description="Internal payment description")
+    metadata: Optional[Dict[str, str]] = Field(None, description="Additional metadata")
+
+
+class PaymentUpdateRequest(AirwallexModel):
+    """Model for payment update request."""
+    status: Optional[str] = Field(None, description="New payment status (for cancellation)")
+    payment_date: Optional[datetime] = Field(None, description="Updated payment date")
+    reference: Optional[str] = Field(None, description="Updated payment reference")
+    description: Optional[str] = Field(None, description="Updated payment description")
+    metadata: Optional[Dict[str, str]] = Field(None, description="Updated metadata")
+
+
+class PaymentQuote(AirwallexModel):
+    """Model for payment quote details."""
+    id: str = Field(..., description="Quote ID")
+    source_amount: PaymentAmount = Field(..., description="Source amount")
+    target_amount: PaymentAmount = Field(..., description="Target amount")
+    fx_rate: float = Field(..., description="FX rate applied")
+    fee: Optional[PaymentAmount] = Field(None, description="Fee amount")
+    expires_at: datetime = Field(..., description="Quote expiration timestamp")

airwallex/utils.py

@@ -0,0 +1,107 @@
+"""
+Utility functions for the Airwallex SDK.
+"""
+import re
+from datetime import datetime
+from typing import Any, Dict, List, Union, TypeVar
+
+T = TypeVar('T')
+
+
+def snake_to_pascal_case(snake_str: str) -> str:
+    """Convert snake_case to PascalCase."""
+    return ''.join(word.title() for word in snake_str.split('_'))
+
+
+def pascal_to_snake_case(pascal_str: str) -> str:
+    """Convert PascalCase to snake_case."""
+    return re.sub(r'(?<!^)(?=[A-Z])', '_', pascal_str).lower()
+
+
+def camel_to_snake_case(camel_str: str) -> str:
+    """Convert camelCase to snake_case."""
+    pattern = re.compile(r'(?<!^)(?=[A-Z])')
+    return pattern.sub('_', camel_str).lower()
+
+
+def snake_to_camel_case(snake_str: str) -> str:
+    """Convert snake_case to camelCase."""
+    components = snake_str.split('_')
+    return components[0] + ''.join(x.title() for x in components[1:])
+
+
+def serialize(data: Union[Dict[str, Any], List[Dict[str, Any]]]) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Serialize data for the Airwallex API.
+    Converts keys from snake_case to camelCase as required by the API.
+    Handles datetime objects, converting them to ISO format strings.
+    """
+    if isinstance(data, list):
+        return [serialize(item) for item in data]
+    
+    if not isinstance(data, dict):
+        if isinstance(data, datetime):
+            return data.isoformat()
+        return data
+    
+    result: Dict[str, Any] = {}
+    for key, value in data.items():
+        # Convert snake_case keys to camelCase
+        camel_key = snake_to_camel_case(key)
+        
+        # Handle nested dictionaries and lists
+        if isinstance(value, dict):
+            result[camel_key] = serialize(value)
+        elif isinstance(value, list):
+            result[camel_key] = [serialize(item) for item in value]
+        elif isinstance(value, datetime):
+            # Convert datetime objects to ISO format strings
+            result[camel_key] = value.isoformat()
+        else:
+            result[camel_key] = value
+            
+    return result
+
+
+def deserialize(data: Union[Dict[str, Any], List[Dict[str, Any]]]) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Deserialize data from the Airwallex API.
+    Converts keys from camelCase to snake_case for Python convention.
+    Attempts to parse ISO format date strings to datetime objects.
+    """
+    if isinstance(data, list):
+        return [deserialize(item) for item in data]
+    
+    if not isinstance(data, dict):
+        # Try to parse ISO date strings
+        if isinstance(data, str):
+            try:
+                if 'T' in data and ('+' in data or 'Z' in data):
+                    return datetime.fromisoformat(data.replace('Z', '+00:00'))
+            except ValueError:
+                pass
+        return data
+    
+    result: Dict[str, Any] = {}
+    for key, value in data.items():
+        # Convert camelCase keys to snake_case
+        snake_key = camel_to_snake_case(key)
+        
+        # Handle nested dictionaries and lists
+        if isinstance(value, dict):
+            result[snake_key] = deserialize(value)
+        elif isinstance(value, list):
+            result[snake_key] = [deserialize(item) for item in value]
+        elif isinstance(value, str):
+            # Try to parse ISO date strings
+            try:
+                if 'T' in value and ('+' in value or 'Z' in value):
+                    result[snake_key] = datetime.fromisoformat(value.replace('Z', '+00:00'))
+                else:
+                    result[snake_key] = value
+            except ValueError:
+                result[snake_key] = value
+        else:
+            result[snake_key] = value
+            
+    return result

airwallex_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.1
+Name: airwallex-sdk
+Version: 0.1.0
+Summary: Unofficial Airwallex SDK for Python
+License: MIT
+Author: duneraccoon
+Author-email: benjamincsherro@hotmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: pydantic (>=2.11.3,<3.0.0)
+Project-URL: Source, https://github.com/DuneRaccoon/airwallex-sdk
+Description-Content-Type: text/markdown
+
+# UNOFFICIAL Airwallex Python SDK
+
+A simple SDK for interacting with the [Airwallex API](https://www.airwallex.com/docs/api).
+
+## Features
+
+- SOMEWHAT Comprehensive implementation of the Airwallex API
+- Both synchronous and asynchronous client support
+- Automatic authentication and token refresh
+- Built-in rate limiting and retry logic
+- Type checking with Pydantic models
+
+## Installation
+
+```bash
+pip install airwallex-sdk
+```
+
+## Quick Start
+
+### Payments API
+
+#### Synchronous Usage
+
+```python
+from airwallex import AirwallexClient
+from airwallex.models.payment import PaymentCreateRequest, PaymentAmount
+
+# Initialize the client
+client = AirwallexClient(
+    client_id="your_client_id",
+    api_key="your_api_key"
+)
+
+# List accounts
+accounts = client.accounts.list()
+for account in accounts:
+    print(f"Account: {account.account_name} ({account.id})")
+
+# Fetch a specific account
+account = client.accounts.fetch("account_id")
+print(account.show())  # Print a formatted representation
+
+# Create a payment
+payment_request = PaymentCreateRequest(
+    request_id="unique_request_id",
+    amount=PaymentAmount(value=100.00, currency="USD"),
+    source={
+        "type": "account",
+        "account_id": "account_id"
+    },
+    beneficiary={
+        "type": "bank_account",
+        "id": "beneficiary_id"
+    },
+    payment_method="swift"
+)
+
+payment = client.payments.create_from_model(payment_request)
+print(f"Payment created with ID: {payment.id}")
+
+# Use generator to iterate through all payments
+for payment in client.payments():
+    print(f"Payment {payment.id}: {payment.amount.value} {payment.amount.currency}")
+```
+
+#### Asynchronous Usage
+
+```python
+import asyncio
+from airwallex import AirwallexAsyncClient
+from airwallex.models.beneficiary import BeneficiaryCreateRequest, BankDetails
+
+async def main():
+    # Initialize the async client
+    client = AirwallexAsyncClient(
+        client_id="your_client_id",
+        api_key="your_api_key"
+    )
+    
+    # List accounts
+    accounts = await client.accounts.list_async()
+    
+    # Create a beneficiary
+    beneficiary_request = BeneficiaryCreateRequest(
+        name="John Doe",
+        type="bank_account",
+        bank_details=BankDetails(
+            account_name="John Doe",
+            account_number="123456789",
+            swift_code="ABCDEFGH",
+            bank_country_code="US"
+        )
+    )
+    
+    beneficiary = await client.beneficiaries.create_from_model_async(beneficiary_request)
+    print(f"Beneficiary created with ID: {beneficiary.id}")
+    
+    # Async generator to iterate through all beneficiaries
+    async for ben in client.beneficiaries.paginate_async_generator():
+        print(f"Beneficiary: {ben.name}")
+    
+    await client.close()
+
+# Run the async function
+asyncio.run(main())
+```
+
+### Issuing API
+
+#### Working with Cardholders and Cards
+
+```python
+from airwallex import AirwallexClient
+from airwallex.models.issuing_cardholder import CardholderCreateRequest, Individual, Name, Address
+from airwallex.models.issuing_card import CardCreateRequest, AuthorizationControls, CardProgram
+
+# Initialize the client
+client = AirwallexClient(
+    client_id="your_client_id",
+    api_key="your_api_key"
+)
+
+# Create a cardholder
+cardholder_request = CardholderCreateRequest(
+    email="john.doe@example.com",
+    individual=Individual(
+        name=Name(
+            first_name="John",
+            last_name="Doe",
+            title="Mr"
+        ),
+        date_of_birth="1982-11-02",
+        address=Address(
+            city="Melbourne",
+            country="AU",
+            line1="44 Example St",
+            postcode="3121",
+            state="VIC"
+        ),
+        cardholder_agreement_terms_consent_obtained="yes",
+        express_consent_obtained="yes"
+    ),
+    type="INDIVIDUAL"
+)
+
+cardholder = client.issuing_cardholder.create_cardholder(cardholder_request)
+print(f"Cardholder created with ID: {cardholder.cardholder_id}")
+
+# Create a virtual card
+card_request = CardCreateRequest(
+    cardholder_id=cardholder.cardholder_id,
+    request_id="unique-request-id",
+    created_by="API User",
+    form_factor="VIRTUAL",
+    is_personalized=True,
+    authorization_controls=AuthorizationControls(
+        allowed_currencies=["USD", "AUD"],
+        allowed_transaction_count="MULTIPLE"
+    ),
+    program=CardProgram(
+        id="your_program_id",
+        name="Default Program"
+    )
+)
+
+card = client.issuing_card.create_card(card_request)
+print(f"Card created with ID: {card.card_id}")
+
+# Get card details
+card_details = client.issuing_card.get_card_details(card.card_id)
+print(f"Card Number: {card_details.card_number}")
+print(f"CVV: {card_details.cvv}")
+print(f"Expiry: {card_details.expiry_month}/{card_details.expiry_year}")
+```
+
+## Documentation
+
+For detailed documentation, see [https://www.airwallex.com/docs/api](https://www.airwallex.com/docs/api).
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+

airwallex_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+airwallex/__init__.py,sha256=u37jsOHa_cPHZWNV2w5BIq65HPWimCCmMGeoCbJbzgQ,2389
+airwallex/api/__init__.py,sha256=1T54Z3An7kgBNxHMhkQFv6jk2dnaT9OKL79MytcGhtg,1042
+airwallex/api/account.py,sha256=kdIBXNoeAYl0p1gD6Oz1nCuQn1v6E_ESJfYxPwD5sF4,3760
+airwallex/api/account_detail.py,sha256=XRrWlUm99jEhh4clqlJr3uCs6Awd2ZhXsr4h89A3eyc,17885
+airwallex/api/base.py,sha256=x9WMly6i6hfX8bCy_xH0Yw77aYYdLe1NxhIm2OpBegk,20140
+airwallex/api/beneficiary.py,sha256=4fprYXmqtBk5nHhp1ks3V-LXOIlV1dk0PEzoHM_sHwc,5580
+airwallex/api/financial_transaction.py,sha256=6INPjTwLO99LL2ph0uVHcPSpIJ5Qyc4xW38KXrIq8TQ,4137
+airwallex/api/invoice.py,sha256=JZSSqhqG5I2pATOlplvuRs70uW8JUYRU-Po08O3SW90,9488
+airwallex/api/issuing_authorization.py,sha256=PSbf4MMalI7u3-xb6GGHzi2o9nh9xWTGyexgtPDvfQo,11297
+airwallex/api/issuing_card.py,sha256=1SX1mMpeOsaKyICDtzuPO_E-3hwD5J0Fhai1nJuggEo,14691
+airwallex/api/issuing_cardholder.py,sha256=JmblwrNN8dstzYr6Yie8FRGNuw5zcsLKu5eqJtZ4C3k,8422
+airwallex/api/issuing_config.py,sha256=P_C_4hskUnwCpoxKro36xG3O6AN5Ena7dz-_NHgogPc,3015
+airwallex/api/issuing_digital_wallet_token.py,sha256=CIEn15rsONkofChpOtZ_pAQnmHFwVaYlm_NF_wH3Fnk,9447
+airwallex/api/issuing_transaction.py,sha256=3SjL3EtI9lMtlhCdufBrfi0qHhF7PgNjggkjwldBG50,8478
+airwallex/api/issuing_transaction_dispute.py,sha256=C7rJO5LHSwq5mjsMCZlEqjWquxbZxGWFuNLBJrlpMZ8,13244
+airwallex/api/payment.py,sha256=JfQJWwtvJpmYCzdLL4Sn5_FbFyd7ruez0zE5maRy_kU,5214
+airwallex/client.py,sha256=21EjrBsXpdWWpvMvRz1OBpYpxiCOzlpWyRri5zm3pJM,14924
+airwallex/exceptions.py,sha256=2LiIxn870uYnlKXl7AwFnNobUGBTeixbWRvNa1eLofE,6472
+airwallex/models/__init__.py,sha256=6WNmWHnCm2HwtQlax1xU8S3pQH5RQtnij5OX6wLMkGQ,2119
+airwallex/models/account.py,sha256=twIGjM_5eIO9AuE2RsvCHvFtJad8KmRazren9L6u2as,2393
+airwallex/models/account_detail.py,sha256=rYz79PkKqg_aSRDMQFPl_hLcjaLLPkQtFlqctQ78VP0,15511
+airwallex/models/base.py,sha256=eMddlaRdkhK0G7TgRUm7OMwzs7aPDRxe47_ksoGDQnM,5057
+airwallex/models/beneficiary.py,sha256=X0jI2AnZHth5KMTWU5tPU_Xbkr_f2UPVmfsv5dx5GEs,4146
+airwallex/models/financial_transaction.py,sha256=2XrKjwdCZrNg-mARZG8Sy1Q07psiNetbjZ8moFKCwH0,1863
+airwallex/models/fx.py,sha256=pYzioeHf-5aqg7Q-BFCluyL-Z-cQUncKBcSlI_bx_AY,3172
+airwallex/models/invoice.py,sha256=U3BG-RmAuygqiINymZBbWy3X0QVBlN99yadTbccZRnU,5801
+airwallex/models/issuing_authorization.py,sha256=Kj5Xp7d4OtNW2wBaIRTMwMszjgLhaHnxnz9h6_DlVEM,2680
+airwallex/models/issuing_card.py,sha256=nJQWcfgdlEK_CNMy6ArSHm8KE69nN3tTUtCSly81g0g,7458
+airwallex/models/issuing_cardholder.py,sha256=2lwcGMWVpRycf3xCB9fHUMqgP75C6zQBV5Ca96BXjKE,2870
+airwallex/models/issuing_common.py,sha256=vzZNOtLjX5quFcuT4sGxgvjYaDiKNcV8fgNzpNcqubQ,3741
+airwallex/models/issuing_config.py,sha256=fJltwHT-aYOuVuAYJJfh_XDnAYtc0wshC8f0b50rMn0,3154
+airwallex/models/issuing_digital_wallet_token.py,sha256=4Mycd-xOTVfRCeHpzBnPKWmaSxlf4Qzl67KMmftvVOw,2078
+airwallex/models/issuing_transaction.py,sha256=SPprY12C6sLV5-fZqExzzFV3l6Llh-A93l1PrD8tcd0,2504
+airwallex/models/issuing_transaction_dispute.py,sha256=OR78VtO9a5_C3FYyVrwH6UVsvW5ptym5SeDokWgoP4w,3062
+airwallex/models/payment.py,sha256=Yxr2w8sesAEko7BccHR3Qwz5hly1OLfctzU3V-3levU,4393
+airwallex/utils.py,sha256=qKiA1e7g-RcUs7yXpaYsUgcxoeYjCoGvytFohYwPV-Q,3685
+airwallex_sdk-0.1.0.dist-info/METADATA,sha256=JpdVWVHJbs9pmpzXqHTy0KaNNMLB-Iif_b9oGAesVJQ,5600
+airwallex_sdk-0.1.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+airwallex_sdk-0.1.0.dist-info/RECORD,,

airwallex_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any