paytechuz 0.2.21__py3-none-any.whl → 0.2.22__py3-none-any.whl

core/http.py

@@ -1,268 +0,0 @@
-"""
-HTTP client for making requests to payment gateways.
-"""
-import json
-import logging
-from typing import Dict, Any, Optional, Union, List
-
-import requests
-from requests.exceptions import RequestException, Timeout, ConnectionError
-
-from paytechuz.core.exceptions import (
-    ExternalServiceError,
-    TimeoutError as PaymentTimeoutError,
-    InternalServiceError
-)
-
-logger = logging.getLogger(__name__)
-
-class HttpClient:
-    """
-    HTTP client for making requests to payment gateways.
-
-    This class provides a simple interface for making HTTP requests to payment
-    gateways with proper error handling and logging.
-    """
-
-    def __init__(
-        self,
-        base_url: str,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: int = 30,
-        verify_ssl: bool = True
-    ):
-        """
-        Initialize the HTTP client.
-
-        Args:
-            base_url: Base URL for the API
-            headers: Default headers to include in all requests
-            timeout: Request timeout in seconds
-            verify_ssl: Whether to verify SSL certificates
-        """
-        self.base_url = base_url.rstrip('/')
-        self.headers = headers or {}
-        self.timeout = timeout
-        self.verify_ssl = verify_ssl
-
-    def _build_url(self, endpoint: str) -> str:
-        """
-        Build the full URL for the given endpoint.
-
-        Args:
-            endpoint: API endpoint
-
-        Returns:
-            Full URL
-        """
-        endpoint = endpoint.lstrip('/')
-        return f"{self.base_url}/{endpoint}"
-
-    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
-        """
-        Handle the response from the API.
-
-        Args:
-            response: Response object
-
-        Returns:
-            Response data as dictionary
-
-        Raises:
-            ExternalServiceError: If the response status code is not 2xx
-        """
-        try:
-            response.raise_for_status()
-            return response.json()
-        except json.JSONDecodeError:
-            logger.error(f"Failed to decode JSON response: {response.text}")
-            raise InternalServiceError("Failed to decode JSON response")
-        except requests.HTTPError as e:
-            logger.error(f"HTTP error: {e}, Response: {response.text}")
-            try:
-                error_data = response.json()
-            except json.JSONDecodeError:
-                error_data = {"raw_response": response.text}
-
-            raise ExternalServiceError(
-                message=f"HTTP error: {response.status_code}",
-                data=error_data
-            )
-
-    def request(
-        self,
-        method: str,
-        endpoint: str,
-        params: Optional[Dict[str, Any]] = None,
-        data: Optional[Union[Dict[str, Any], List[Any]]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        json_data: Optional[Union[Dict[str, Any], List[Any]]] = None,
-        timeout: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Make an HTTP request.
-
-        Args:
-            method: HTTP method (GET, POST, PUT, DELETE, etc.)
-            endpoint: API endpoint
-            params: Query parameters
-            data: Form data
-            headers: Request headers
-            json_data: JSON data
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data as dictionary
-
-        Raises:
-            ExternalServiceError: If the request fails
-            TimeoutError: If the request times out
-        """
-        url = self._build_url(endpoint)
-        request_headers = {**self.headers}
-        if headers:
-            request_headers.update(headers)
-
-        timeout = timeout or self.timeout
-
-        try:
-            response = requests.request(
-                method=method.upper(),
-                url=url,
-                params=params,
-                data=data,
-                headers=request_headers,
-                json=json_data,
-                timeout=timeout,
-                verify=self.verify_ssl
-            )
-            return self._handle_response(response)
-        except Timeout:
-            logger.error(f"Request timed out: {method} {url}")
-            raise PaymentTimeoutError(f"Request timed out: {method} {url}")
-        except ConnectionError as e:
-            logger.error(f"Connection error: {e}")
-            raise ExternalServiceError(f"Connection error: {str(e)}")
-        except RequestException as e:
-            logger.error(f"Request error: {e}")
-            raise ExternalServiceError(f"Request error: {str(e)}")
-
-    def get(
-        self,
-        endpoint: str,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Make a GET request.
-
-        Args:
-            endpoint: API endpoint
-            params: Query parameters
-            headers: Request headers
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data as dictionary
-        """
-        return self.request(
-            method="GET",
-            endpoint=endpoint,
-            params=params,
-            headers=headers,
-            timeout=timeout
-        )
-
-    def post(
-        self,
-        endpoint: str,
-        data: Optional[Dict[str, Any]] = None,
-        json_data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Make a POST request.
-
-        Args:
-            endpoint: API endpoint
-            data: Form data
-            json_data: JSON data
-            params: Query parameters
-            headers: Request headers
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data as dictionary
-        """
-        return self.request(
-            method="POST",
-            endpoint=endpoint,
-            data=data,
-            json_data=json_data,
-            params=params,
-            headers=headers,
-            timeout=timeout
-        )
-
-    def put(
-        self,
-        endpoint: str,
-        data: Optional[Dict[str, Any]] = None,
-        json_data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Make a PUT request.
-
-        Args:
-            endpoint: API endpoint
-            data: Form data
-            json_data: JSON data
-            params: Query parameters
-            headers: Request headers
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data as dictionary
-        """
-        return self.request(
-            method="PUT",
-            endpoint=endpoint,
-            data=data,
-            json_data=json_data,
-            params=params,
-            headers=headers,
-            timeout=timeout
-        )
-
-    def delete(
-        self,
-        endpoint: str,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """
-        Make a DELETE request.
-
-        Args:
-            endpoint: API endpoint
-            params: Query parameters
-            headers: Request headers
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data as dictionary
-        """
-        return self.request(
-            method="DELETE",
-            endpoint=endpoint,
-            params=params,
-            headers=headers,
-            timeout=timeout
-        )

core/payme/errors.py

@@ -1,25 +0,0 @@
-"""
-Payme API error codes.
-"""
-
-# System errors
-SYSTEM_ERROR = -32400
-INVALID_JSON_RPC = -32600
-METHOD_NOT_FOUND = -32601
-INVALID_PARAMS = -32602
-INTERNAL_ERROR = -32603
-
-# Authorization errors
-AUTH_ERROR = -32504
-AUTH_TOKEN_INVALID = -32504
-AUTH_TOKEN_EXPIRED = -32504
-
-# Business logic errors
-INVALID_AMOUNT = -31001
-INVALID_ACCOUNT = -31050
-COULD_NOT_PERFORM = -31008
-COULD_NOT_CANCEL = -31007
-TRANSACTION_NOT_FOUND = -31003
-TRANSACTION_ALREADY_EXISTS = -31060
-TRANSACTION_ALREADY_CANCELLED = -31061
-TRANSACTION_ALREADY_COMPLETED = -31062

core/utils.py

@@ -1,192 +0,0 @@
-"""
-Utility functions for payment gateways.
-"""
-import base64
-import hashlib
-import hmac
-import json
-import logging
-import time
-from datetime import datetime
-from typing import Dict, Any, Union, Optional
-
-logger = logging.getLogger(__name__)
-
-def generate_timestamp() -> int:
-    """
-    Generate a Unix timestamp.
-
-    Returns:
-        Current Unix timestamp in seconds
-    """
-    return int(time.time())
-
-
-def generate_id(prefix: str = "") -> str:
-    """
-    Generate a unique ID.
-
-    Args:
-        prefix: Prefix for the ID
-
-    Returns:
-        Unique ID
-    """
-    timestamp = generate_timestamp()
-    unique_id = f"{timestamp}{hash(timestamp)}"
-    if prefix:
-        return f"{prefix}_{unique_id}"
-    return unique_id
-
-def format_amount(amount: Union[int, float, str]) -> int:
-    """
-    Format amount to integer (in tiyin/kopeyka).
-
-    Args:
-        amount: Amount in som/ruble
-
-    Returns:
-        Amount in tiyin/kopeyka (integer)
-    """
-    try:
-        # Convert to float first to handle string inputs
-        float_amount = float(amount)
-        # Convert to tiyin/kopeyka (multiply by 100) and round to integer
-        return int(float_amount * 100)
-    except (ValueError, TypeError) as e:
-        logger.error(f"Failed to format amount: {amount}, Error: {e}")
-        raise ValueError(f"Invalid amount format: {amount}")
-
-
-def format_datetime(dt: datetime) -> str:
-    """
-    Format datetime to ISO 8601 format.
-
-    Args:
-        dt: Datetime object
-
-    Returns:
-        Formatted datetime string
-    """
-    return dt.strftime("%Y-%m-%dT%H:%M:%S%z")
-
-def datetime_to_timestamp(dt: datetime) -> int:
-    """
-    Convert datetime to Unix timestamp.
-
-    Args:
-        dt: Datetime object
-
-    Returns:
-        Unix timestamp in seconds
-    """
-    return int(dt.timestamp())
-
-
-def timestamp_to_datetime(timestamp: int) -> datetime:
-    """
-    Convert Unix timestamp to datetime.
-
-    Args:
-        timestamp: Unix timestamp in seconds
-
-    Returns:
-        Datetime object
-    """
-    return datetime.fromtimestamp(timestamp)
-
-def generate_hmac_signature(
-    data: Union[str, Dict[str, Any], bytes],
-    secret_key: str,
-    algorithm: str = "sha256"
-) -> str:
-    """
-    Generate HMAC signature.
-
-    Args:
-        data: Data to sign
-        secret_key: Secret key for signing
-        algorithm: Hash algorithm to use
-
-    Returns:
-        HMAC signature as hexadecimal string
-    """
-    if isinstance(data, dict):
-        data = json.dumps(data, separators=(',', ':'))
-
-    if isinstance(data, str):
-        data = data.encode('utf-8')
-
-    key = secret_key.encode('utf-8')
-
-    if algorithm.lower() == "sha256":
-        signature = hmac.new(key, data, hashlib.sha256).hexdigest()
-    elif algorithm.lower() == "sha512":
-        signature = hmac.new(key, data, hashlib.sha512).hexdigest()
-    elif algorithm.lower() == "md5":
-        signature = hmac.new(key, data, hashlib.md5).hexdigest()
-    else:
-        raise ValueError(f"Unsupported algorithm: {algorithm}")
-
-    return signature
-
-
-def generate_basic_auth(username: str, password: str) -> str:
-    """
-    Generate Basic Authentication header value.
-
-    Args:
-        username: Username
-        password: Password
-
-    Returns:
-        Basic Authentication header value
-    """
-    auth_str = f"{username}:{password}"
-    auth_bytes = auth_str.encode('utf-8')
-    encoded = base64.b64encode(auth_bytes).decode('utf-8')
-    return f"Basic {encoded}"
-
-def handle_exceptions(func):
-    """
-    Decorator to handle exceptions and convert them to payment exceptions.
-
-    Args:
-        func: Function to decorate
-
-    Returns:
-        Decorated function
-    """
-    from paytechuz.core.exceptions import (
-        InternalServiceError,
-        exception_whitelist
-    )
-
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except exception_whitelist as exc:
-            # No need to wrap exceptions that are already payment exceptions
-            raise exc
-        except Exception as exc:
-            logger.exception(f"Unexpected error in {func.__name__}: {exc}")
-            raise InternalServiceError(str(exc))
-
-    return wrapper
-
-
-def validate_required_fields(data: Dict[str, Any], required_fields: list) -> Optional[str]:
-    """
-    Validate that all required fields are present in the data.
-
-    Args:
-        data: Data to validate
-        required_fields: List of required field names
-
-    Returns:
-        Error message if validation fails, None otherwise
-    """
-    missing_fields = [field for field in required_fields if field not in data or data[field] is None]
-    if missing_fields:
-        return f"Missing required fields: {', '.join(missing_fields)}"
-    return None

gateways/click/client.py

@@ -1,199 +0,0 @@
-"""
-Click payment gateway client.
-"""
-import logging
-from typing import Dict, Any, Optional, Union
-
-from paytechuz.core.base import BasePaymentGateway
-from paytechuz.core.http import HttpClient
-from paytechuz.core.constants import ClickNetworks
-from paytechuz.core.utils import handle_exceptions
-from paytechuz.gateways.click.merchant import ClickMerchantApi
-
-logger = logging.getLogger(__name__)
-
-
-class ClickGateway(BasePaymentGateway):
-    """
-    Click payment gateway implementation.
-
-    This class provides methods for interacting with the Click payment gateway,
-    including creating payments, checking payment status, and canceling payments.
-    """
-
-    def __init__(
-        self,
-        service_id: str,
-        merchant_id: str,
-        merchant_user_id: Optional[str] = None,
-        secret_key: Optional[str] = None,
-        is_test_mode: bool = False
-    ):
-        """
-        Initialize the Click gateway.
-
-        Args:
-            service_id: Click service ID
-            merchant_id: Click merchant ID
-            merchant_user_id: Click merchant user ID
-            secret_key: Secret key for authentication
-            is_test_mode: Whether to use the test environment
-        """
-        super().__init__(is_test_mode)
-        self.service_id = service_id
-        self.merchant_id = merchant_id
-        self.merchant_user_id = merchant_user_id
-        self.secret_key = secret_key
-
-        # Set the API URL based on the environment
-        url = ClickNetworks.TEST_NET if is_test_mode else ClickNetworks.PROD_NET
-
-        # Initialize HTTP client
-        self.http_client = HttpClient(base_url=url)
-
-        # Initialize merchant API
-        self.merchant_api = ClickMerchantApi(
-            http_client=self.http_client,
-            service_id=service_id,
-            merchant_user_id=merchant_user_id,
-            secret_key=secret_key
-        )
-
-    @handle_exceptions
-    def create_payment(
-        self,
-        id: Union[int, str],
-        amount: Union[int, float, str],
-        **kwargs
-    ) -> str:
-        """
-        Create a payment using Click.
-
-        Args:
-            id: The account ID or order ID
-            amount: The payment amount in som
-            **kwargs: Additional parameters for the payment
-                - description: Payment description
-                - return_url: URL to return after payment
-                - callback_url: URL for payment notifications
-                - language: Language code (uz, ru, en)
-                - phone: Customer phone number
-                - email: Customer email
-
-        Returns:
-            Payment URL string for redirecting the user to Click payment page
-        """
-        # Format amount for URL (no need to convert to tiyin for URL)
-
-        # Extract additional parameters
-        description = kwargs.get('description', f'Payment for account {id}')
-        return_url = kwargs.get('return_url')
-        callback_url = kwargs.get('callback_url')
-        # These parameters are not used in the URL but are available in the API
-        # language = kwargs.get('language', 'uz')
-        # phone = kwargs.get('phone')
-        # email = kwargs.get('email')
-
-        # Create payment URL
-        payment_url = "https://my.click.uz/services/pay"
-        payment_url += f"?service_id={self.service_id}"
-        payment_url += f"&merchant_id={self.merchant_id}"
-        payment_url += f"&amount={amount}"
-        payment_url += f"&transaction_param={id}"
-
-        if return_url:
-            payment_url += f"&return_url={return_url}"
-
-        if callback_url:
-            payment_url += f"&callback_url={callback_url}"
-
-        if description:
-            payment_url += f"&description={description}"
-
-        if self.merchant_user_id:
-            payment_url += f"&merchant_user_id={self.merchant_user_id}"
-
-        # Return the payment URL directly
-        return payment_url
-
-    @handle_exceptions
-    def check_payment(self, transaction_id: str) -> Dict[str, Any]:
-        """
-        Check payment status using Click merchant API.
-
-        Args:
-            transaction_id: The transaction ID to check
-
-        Returns:
-            Dict containing payment status and details
-        """
-        # Extract account_id from transaction_id
-        # Format: click_account_id_amount
-        parts = transaction_id.split('_')
-        if len(parts) < 3 or parts[0] != 'click':
-            raise ValueError(
-                f"Invalid transaction ID format: {transaction_id}"
-            )
-
-        account_id = parts[1]
-
-        # Check payment status using merchant API
-        payment_data = self.merchant_api.check_payment(account_id)
-
-        # Extract payment status
-        status = payment_data.get('status')
-
-        # Map Click status to our status
-        status_mapping = {
-            'success': 'paid',
-            'processing': 'waiting',
-            'failed': 'failed',
-            'cancelled': 'cancelled'
-        }
-
-        mapped_status = status_mapping.get(status, 'unknown')
-
-        return {
-            'transaction_id': transaction_id,
-            'status': mapped_status,
-            'amount': payment_data.get('amount'),
-            'paid_at': payment_data.get('paid_at'),
-            'created_at': payment_data.get('created_at'),
-            'raw_response': payment_data
-        }
-
-    @handle_exceptions
-    def cancel_payment(
-        self,
-        transaction_id: str,
-        reason: Optional[str] = None
-    ) -> Dict[str, Any]:
-        """
-        Cancel payment using Click merchant API.
-
-        Args:
-            transaction_id: The transaction ID to cancel
-            reason: Optional reason for cancellation
-
-        Returns:
-            Dict containing cancellation status and details
-        """
-        # Extract account_id from transaction_id
-        # Format: click_account_id_amount
-        parts = transaction_id.split('_')
-        if len(parts) < 3 or parts[0] != 'click':
-            raise ValueError(
-                f"Invalid transaction ID format: {transaction_id}"
-            )
-
-        account_id = parts[1]
-
-        # Cancel payment using merchant API
-        cancel_data = self.merchant_api.cancel_payment(account_id, reason)
-
-        return {
-            'transaction_id': transaction_id,
-            'status': 'cancelled',
-            'cancelled_at': cancel_data.get('cancelled_at'),
-            'raw_response': cancel_data
-        }