inter-service-sdk 1.0.2__py3-none-any.whl

inter_service_sdk/__init__.py

@@ -0,0 +1,42 @@
+"""
+Inter-Service SDK - Complete framework for service-to-service communication.
+
+Provides both client-side and server-side utilities:
+- Client: InterServiceClient for making inter-service HTTP requests
+- Server: FastAPI utilities for creating inter-service endpoints
+- Crypto: Optional ECC encryption/decryption
+- Exceptions: Custom exception hierarchy
+"""
+
+from .client import InterServiceClient
+from .exceptions import (
+    InterServiceError,
+    AuthenticationError,
+    RequestError,
+    EncryptionError,
+    URLBuildError
+)
+from .server import (
+    create_inter_service_router,
+    inter_service_endpoint,
+    format_error_response,
+    format_success_response
+)
+
+__version__ = "1.0.2"
+
+__all__ = [
+    # Client
+    "InterServiceClient",
+    # Exceptions
+    "InterServiceError",
+    "AuthenticationError",
+    "RequestError",
+    "EncryptionError",
+    "URLBuildError",
+    # Server utilities
+    "create_inter_service_router",
+    "inter_service_endpoint",
+    "format_error_response",
+    "format_success_response",
+]

inter_service_sdk/client.py

@@ -0,0 +1,251 @@
+"""
+Inter-service HTTP client with bearer auth and optional encryption.
+"""
+
+import time
+import logging
+from typing import Optional, Dict, Any
+import requests
+from requests.exceptions import RequestException, Timeout
+
+from .utils import build_url
+from .exceptions import AuthenticationError, RequestError
+from . import crypto
+
+logger = logging.getLogger(__name__)
+
+
+class InterServiceClient:
+    """
+    Generic HTTP client for inter-service communication.
+
+    Features:
+    - Bearer token authentication
+    - Optional ECC encryption/decryption
+    - Path and query parameter handling
+    - Automatic retry with exponential backoff
+    - Consistent response format
+
+    Example:
+        >>> client = InterServiceClient(
+        ...     base_url="https://api.example.com",
+        ...     api_key="your-secret-key"
+        ... )
+        >>> response = client.request(
+        ...     endpoint="users/{user_id}",
+        ...     path_params={"user_id": 123}
+        ... )
+        >>> print(response["data"])
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        api_prefix: str = "/api/v1/inter-service",
+        timeout: int = 30,
+        retry_attempts: int = 3,
+        ecc_private_key: Optional[str] = None,
+        ecc_public_key: Optional[str] = None
+    ):
+        """
+        Initialize inter-service client.
+
+        Args:
+            base_url: Base URL (e.g., "https://api.example.com")
+            api_key: Bearer token for authentication
+            api_prefix: API prefix (default: "/api/v1/inter-service")
+            timeout: Request timeout in seconds (default: 30)
+            retry_attempts: Number of retry attempts (default: 3)
+            ecc_private_key: ECC private key for decryption (PEM format)
+            ecc_public_key: ECC public key for encryption (PEM format)
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+        self.default_api_prefix = api_prefix
+        self.timeout = timeout
+        self.retry_attempts = retry_attempts
+        self.ecc_private_key = ecc_private_key
+        self.ecc_public_key = ecc_public_key
+
+        # Setup session with auth headers
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Authorization': f'Bearer {api_key}',
+            'User-Agent': 'InterServiceSDK/1.0.0',
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        })
+
+        logger.info(f"InterServiceClient initialized: {base_url}{api_prefix}")
+
+    def request(
+        self,
+        endpoint: str,
+        path_params: Optional[Dict[str, Any]] = None,
+        query_params: Optional[Dict[str, Any]] = None,
+        method: str = "GET",
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        encrypt: bool = False,
+        decrypt: bool = False,
+        timeout: Optional[int] = None,
+        api_prefix: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Make HTTP request to inter-service API.
+
+        Args:
+            endpoint: Endpoint template (e.g., "users/{user_id}")
+            path_params: Path parameters for substitution
+            query_params: Query string parameters
+            method: HTTP method (GET, POST, PUT, DELETE, PATCH)
+            data: Request body (JSON)
+            headers: Additional headers
+            encrypt: Auto-encrypt request data with ECC
+            decrypt: Auto-decrypt response with ECC
+            timeout: Override default timeout
+            api_prefix: Override default API prefix
+
+        Returns:
+            {
+                "status": "success" | "error",
+                "data": {...} | None,
+                "status_code": int,
+                "error": None | str
+            }
+
+        Example:
+            >>> response = client.request(
+            ...     endpoint="users/{user_id}",
+            ...     path_params={"user_id": 123},
+            ...     query_params={"correlation_id": "track-001"}
+            ... )
+        """
+        # Build URL
+        url = build_url(
+            self.base_url,
+            api_prefix if api_prefix is not None else self.default_api_prefix,
+            endpoint,
+            path_params,
+            query_params
+        )
+
+        # Prepare request data
+        json_data = None
+        if data:
+            if encrypt and self.ecc_public_key:
+                try:
+                    correlation_id = query_params.get("correlation_id", "default") if query_params else "default"
+                    encrypted = crypto.encrypt_data(data, self.ecc_public_key, correlation_id)
+                    json_data = encrypted
+                except Exception as e:
+                    logger.error(f"Encryption failed: {e}")
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "status_code": None,
+                        "error": f"Encryption failed: {str(e)}"
+                    }
+            else:
+                json_data = data
+
+        # Merge headers
+        request_headers = self.session.headers.copy()
+        if headers:
+            request_headers.update(headers)
+
+        # Make request with retry logic
+        for attempt in range(self.retry_attempts):
+            try:
+                logger.debug(f"{method} {url}")
+
+                response = self.session.request(
+                    method=method.upper(),
+                    url=url,
+                    json=json_data,
+                    headers=request_headers,
+                    timeout=timeout or self.timeout
+                )
+
+                # Handle HTTP errors
+                if response.status_code >= 400:
+                    logger.error(f"HTTP {response.status_code}: {response.text}")
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "status_code": response.status_code,
+                        "error": response.text
+                    }
+
+                # Parse response
+                response_data = response.json()
+
+                # Decrypt if needed
+                if decrypt and self.ecc_private_key:
+                    try:
+                        # Extract encrypted data from response
+                        if "encrypted_data" in response_data:
+                            correlation_id = query_params.get("correlation_id", "default") if query_params else "default"
+                            decrypted = crypto.decrypt_data(
+                                response_data["encrypted_data"],
+                                response_data["ephemeral_public_key"],
+                                response_data["nonce"],
+                                self.ecc_private_key,
+                                correlation_id
+                            )
+                            response_data["data"] = decrypted
+                    except Exception as e:
+                        logger.error(f"Decryption failed: {e}")
+                        return {
+                            "status": "error",
+                            "data": None,
+                            "status_code": response.status_code,
+                            "error": f"Decryption failed: {str(e)}"
+                        }
+
+                return {
+                    "status": "success",
+                    "data": response_data.get("data", response_data),
+                    "status_code": response.status_code,
+                    "error": None
+                }
+
+            except Timeout:
+                logger.warning(f"Request timeout (attempt {attempt + 1}/{self.retry_attempts})")
+                if attempt == self.retry_attempts - 1:
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "status_code": None,
+                        "error": f"Request timed out after {timeout or self.timeout} seconds"
+                    }
+                time.sleep(2 ** attempt)  # Exponential backoff
+
+            except RequestException as e:
+                logger.warning(f"Request failed (attempt {attempt + 1}/{self.retry_attempts}): {e}")
+                if attempt == self.retry_attempts - 1:
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "status_code": None,
+                        "error": str(e)
+                    }
+                time.sleep(2 ** attempt)  # Exponential backoff
+
+            except Exception as e:
+                logger.error(f"Unexpected error: {e}", exc_info=True)
+                return {
+                    "status": "error",
+                    "data": None,
+                    "status_code": None,
+                    "error": f"Unexpected error: {str(e)}"
+                }
+
+        # Should not reach here
+        return {
+            "status": "error",
+            "data": None,
+            "status_code": None,
+            "error": "Max retries exceeded"
+        }

inter_service_sdk/crypto.py

@@ -0,0 +1,177 @@
+"""
+ECC encryption/decryption for inter-service communication.
+Optional module - requires cryptography package.
+"""
+
+import base64
+import os
+from typing import Optional, Dict, Any
+from .exceptions import EncryptionError
+
+try:
+    from cryptography.hazmat.primitives import serialization, hashes
+    from cryptography.hazmat.primitives.asymmetric import ec
+    from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+    from cryptography.hazmat.backends import default_backend
+    CRYPTO_AVAILABLE = True
+except ImportError:
+    CRYPTO_AVAILABLE = False
+
+
+def encrypt_data(
+    data: Dict[str, Any],
+    public_key_pem: str,
+    correlation_id: str = "default"
+) -> Dict[str, Any]:
+    """
+    Encrypt data using ECC P-256 + ECDH-ES + AES-256-GCM.
+
+    Args:
+        data: Data dictionary to encrypt
+        public_key_pem: Public key in PEM format
+        correlation_id: Correlation ID for key derivation
+
+    Returns:
+        Dictionary with encrypted data structure:
+        {
+            "encrypted_data": str (base64),
+            "ephemeral_public_key": str (PEM),
+            "nonce": str (base64),
+            "encryption_algorithm": str,
+            "key_version": str
+        }
+
+    Raises:
+        EncryptionError: If encryption fails
+    """
+    if not CRYPTO_AVAILABLE:
+        raise EncryptionError(
+            "Cryptography package not installed. "
+            "Install with: pip install inter-service-sdk[crypto]"
+        )
+
+    try:
+        import json
+
+        # Parse public key
+        public_key = serialization.load_pem_public_key(
+            public_key_pem.encode('utf-8'),
+            backend=default_backend()
+        )
+
+        # Generate ephemeral key pair
+        ephemeral_private = ec.generate_private_key(ec.SECP256R1())
+        ephemeral_public = ephemeral_private.public_key()
+
+        # ECDH key exchange
+        shared_key = ephemeral_private.exchange(ec.ECDH(), public_key)
+
+        # Key derivation using HKDF
+        derived_key = HKDF(
+            algorithm=hashes.SHA256(),
+            length=32,  # 256-bit key for AES-256
+            salt=None,
+            info=f"ECC-inter-service-{correlation_id}".encode('utf-8'),
+            backend=default_backend()
+        ).derive(shared_key)
+
+        # Convert data to JSON bytes
+        data_json = json.dumps(data, separators=(',', ':'))
+        data_bytes = data_json.encode('utf-8')
+
+        # Generate random nonce (96-bit for GCM)
+        nonce = os.urandom(12)
+
+        # Encrypt using AES-256-GCM
+        aead = AESGCM(derived_key)
+        ciphertext = aead.encrypt(nonce, data_bytes, None)
+
+        # Serialize ephemeral public key
+        ephemeral_public_pem = ephemeral_public.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo
+        ).decode('utf-8')
+
+        return {
+            "encrypted_data": base64.b64encode(ciphertext).decode('utf-8'),
+            "ephemeral_public_key": ephemeral_public_pem,
+            "nonce": base64.b64encode(nonce).decode('utf-8'),
+            "encryption_algorithm": "ECC-P256+ECDH-ES+AES-256-GCM",
+            "key_version": "v2.0"
+        }
+
+    except Exception as e:
+        raise EncryptionError(f"Encryption failed: {str(e)}")
+
+
+def decrypt_data(
+    encrypted_data: str,
+    ephemeral_public_key_pem: str,
+    nonce: str,
+    private_key_pem: str,
+    correlation_id: str = "default"
+) -> Dict[str, Any]:
+    """
+    Decrypt data using ECC P-256 + ECDH-ES + AES-256-GCM.
+
+    Args:
+        encrypted_data: Base64-encoded ciphertext
+        ephemeral_public_key_pem: Ephemeral public key in PEM format
+        nonce: Base64-encoded nonce
+        private_key_pem: Private key in PEM format
+        correlation_id: Correlation ID for key derivation
+
+    Returns:
+        Decrypted data dictionary
+
+    Raises:
+        EncryptionError: If decryption fails
+    """
+    if not CRYPTO_AVAILABLE:
+        raise EncryptionError(
+            "Cryptography package not installed. "
+            "Install with: pip install inter-service-sdk[crypto]"
+        )
+
+    try:
+        import json
+
+        # Load private key
+        private_key = serialization.load_pem_private_key(
+            private_key_pem.encode('utf-8'),
+            password=None,
+            backend=default_backend()
+        )
+
+        # Parse ephemeral public key
+        ephemeral_public_key = serialization.load_pem_public_key(
+            ephemeral_public_key_pem.encode('utf-8'),
+            backend=default_backend()
+        )
+
+        # Perform ECDH key exchange
+        shared_key = private_key.exchange(ec.ECDH(), ephemeral_public_key)
+
+        # Derive AES key using HKDF
+        derived_key = HKDF(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=None,
+            info=f"ECC-inter-service-{correlation_id}".encode('utf-8'),
+            backend=default_backend()
+        ).derive(shared_key)
+
+        # Decode base64 data
+        nonce_bytes = base64.b64decode(nonce)
+        ciphertext_bytes = base64.b64decode(encrypted_data)
+
+        # Decrypt using AES-256-GCM
+        aead = AESGCM(derived_key)
+        decrypted_bytes = aead.decrypt(nonce_bytes, ciphertext_bytes, None)
+        decrypted_json = decrypted_bytes.decode('utf-8')
+
+        return json.loads(decrypted_json)
+
+    except Exception as e:
+        raise EncryptionError(f"Decryption failed: {str(e)}")

inter_service_sdk/exceptions.py

@@ -0,0 +1,31 @@
+"""
+Custom exceptions for inter-service SDK.
+"""
+
+
+class InterServiceError(Exception):
+    """Base exception for inter-service SDK."""
+    pass
+
+
+class AuthenticationError(InterServiceError):
+    """Authentication failed."""
+    pass
+
+
+class RequestError(InterServiceError):
+    """Request failed."""
+
+    def __init__(self, message: str, status_code: int = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class EncryptionError(InterServiceError):
+    """Encryption/decryption failed."""
+    pass
+
+
+class URLBuildError(InterServiceError):
+    """URL building failed."""
+    pass

inter_service_sdk/server.py

@@ -0,0 +1,238 @@
+"""
+Server-side utilities for creating inter-service API endpoints with FastAPI.
+
+Provides decorators and utilities to reduce boilerplate in inter-service endpoints:
+- Router factory with configurable auth
+- Automatic error handling and logging
+- Consistent response formatting
+- Correlation ID management
+"""
+
+import logging
+from typing import Callable, Any, Dict, Optional
+from functools import wraps
+from datetime import datetime, timezone
+from fastapi import APIRouter, Request, HTTPException, status
+
+logger = logging.getLogger(__name__)
+
+
+def create_inter_service_router(
+    prefix: str = "/api/v1/inter-service",
+    tags: Optional[list] = None,
+    auth_dependency: Optional[Any] = None
+) -> APIRouter:
+    """
+    Create FastAPI router for inter-service endpoints.
+
+    Returns router with:
+    - Configurable prefix (default: /api/v1/inter-service)
+    - Optional authentication dependency
+    - Custom or default tags
+
+    Example:
+        from fastapi import Depends
+        from your_auth import require_inter_service_auth
+
+        router = create_inter_service_router(
+            auth_dependency=Depends(require_inter_service_auth)
+        )
+
+        @router.get("/users/{user_id}")
+        async def get_user(user_id: int):
+            return {"user_id": user_id}
+
+    Args:
+        prefix: API prefix path
+        tags: List of tags for OpenAPI docs
+        auth_dependency: FastAPI dependency for authentication
+
+    Returns:
+        Configured APIRouter instance
+    """
+    dependencies = []
+    if auth_dependency is not None:
+        dependencies.append(auth_dependency)
+
+    return APIRouter(
+        prefix=prefix,
+        tags=tags or ["Inter-Service API"],
+        dependencies=dependencies
+    )
+
+
+def inter_service_endpoint(
+    endpoint_name: str,
+    require_correlation_id: bool = True
+):
+    """
+    Decorator for inter-service endpoints with automatic logging and error handling.
+
+    Provides:
+    - Request/response logging with correlation IDs
+    - Client host logging
+    - Automatic error handling and formatting
+    - Consistent timestamp formatting
+
+    Example:
+        @router.get("/users/{user_id}")
+        @inter_service_endpoint("get_user")
+        async def get_user(user_id: int, correlation_id: str, request: Request):
+            # Your endpoint logic here
+            return {"user_id": user_id, "name": "John Doe"}
+
+        # Automatically wrapped response:
+        # {
+        #     "status": "success",
+        #     "data": {"user_id": 123, "name": "John Doe"},
+        #     "correlation_id": "req-001",
+        #     "timestamp": "2025-01-01T00:00:00Z"
+        # }
+
+    Args:
+        endpoint_name: Name for logging (e.g., "get_credentials")
+        require_correlation_id: Whether correlation_id parameter is required
+
+    Returns:
+        Decorated function with automatic logging and error handling
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Extract common parameters
+            request: Optional[Request] = kwargs.get("request")
+            correlation_id = kwargs.get("correlation_id", "unknown")
+
+            # Validation
+            if require_correlation_id and correlation_id == "unknown":
+                logger.error(f"❌ [{endpoint_name}] Missing required correlation_id parameter")
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail="correlation_id query parameter is required"
+                )
+
+            # Log request
+            client_host = request.client.host if request and request.client else "unknown"
+            user_agent = request.headers.get("user-agent", "unknown") if request else "unknown"
+
+            logger.info(f"🔗 [{endpoint_name}] Request started - Correlation: {correlation_id}")
+            logger.info(f"   Client: {client_host}, User-Agent: {user_agent}")
+
+            try:
+                # Execute endpoint function
+                result = await func(*args, **kwargs)
+
+                # If result is already a dict with status field, return as-is
+                if isinstance(result, dict) and "status" in result:
+                    logger.info(f"✅ [{endpoint_name}] Request completed - Status: {result.get('status')}")
+                    return result
+
+                # Otherwise, wrap in standard response format
+                response = {
+                    "status": "success",
+                    "data": result,
+                    "correlation_id": correlation_id,
+                    "timestamp": datetime.now(timezone.utc).isoformat()
+                }
+
+                logger.info(f"✅ [{endpoint_name}] Request completed successfully")
+                return response
+
+            except HTTPException:
+                # Re-raise HTTP exceptions (already have proper status codes)
+                raise
+
+            except Exception as e:
+                logger.error(f"❌ [{endpoint_name}] Error: {str(e)}", exc_info=True)
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail=f"Internal server error in {endpoint_name}"
+                )
+
+        return wrapper
+    return decorator
+
+
+def format_error_response(
+    message: str,
+    correlation_id: str,
+    status_code: int = 500,
+    **extra_fields
+) -> Dict[str, Any]:
+    """
+    Format standard error response.
+
+    Args:
+        message: Error message
+        correlation_id: Request correlation ID
+        status_code: HTTP status code (not included in response, for reference)
+        **extra_fields: Additional fields to include in response
+
+    Returns:
+        Formatted error response dict
+
+    Example:
+        return format_error_response(
+            message="User not found",
+            correlation_id="req-001",
+            status_code=404,
+            user_id=123
+        )
+        # Returns:
+        # {
+        #     "status": "error",
+        #     "error": "User not found",
+        #     "correlation_id": "req-001",
+        #     "timestamp": "2025-01-01T00:00:00Z",
+        #     "user_id": 123
+        # }
+    """
+    response = {
+        "status": "error",
+        "error": message,
+        "correlation_id": correlation_id,
+        "timestamp": datetime.now(timezone.utc).isoformat()
+    }
+    response.update(extra_fields)
+    return response
+
+
+def format_success_response(
+    data: Any,
+    correlation_id: str,
+    **extra_fields
+) -> Dict[str, Any]:
+    """
+    Format standard success response.
+
+    Args:
+        data: Response data
+        correlation_id: Request correlation ID
+        **extra_fields: Additional fields to include in response
+
+    Returns:
+        Formatted success response dict
+
+    Example:
+        return format_success_response(
+            data={"user_id": 123, "name": "John"},
+            correlation_id="req-001",
+            cache_hit=True
+        )
+        # Returns:
+        # {
+        #     "status": "success",
+        #     "data": {"user_id": 123, "name": "John"},
+        #     "correlation_id": "req-001",
+        #     "timestamp": "2025-01-01T00:00:00Z",
+        #     "cache_hit": True
+        # }
+    """
+    response = {
+        "status": "success",
+        "data": data,
+        "correlation_id": correlation_id,
+        "timestamp": datetime.now(timezone.utc).isoformat()
+    }
+    response.update(extra_fields)
+    return response

inter_service_sdk/utils.py

@@ -0,0 +1,61 @@
+"""
+Utility functions for inter-service SDK.
+"""
+
+from typing import Dict, Any, Optional
+from urllib.parse import urlencode
+from .exceptions import URLBuildError
+
+
+def build_url(
+    base_url: str,
+    api_prefix: str,
+    endpoint: str,
+    path_params: Optional[Dict[str, Any]] = None,
+    query_params: Optional[Dict[str, Any]] = None
+) -> str:
+    """
+    Build complete URL with path parameter substitution.
+
+    Args:
+        base_url: Base URL (e.g., "https://api.example.com")
+        api_prefix: API prefix (e.g., "/api/v1/inter-service")
+        endpoint: Endpoint template (e.g., "users/{user_id}")
+        path_params: Path parameters for substitution
+        query_params: Query string parameters
+
+    Returns:
+        Complete URL string
+
+    Example:
+        >>> build_url(
+        ...     "https://api.example.com",
+        ...     "/api/v1/inter-service",
+        ...     "users/{user_id}",
+        ...     {"user_id": 123},
+        ...     {"correlation_id": "track-001"}
+        ... )
+        'https://api.example.com/api/v1/inter-service/users/123?correlation_id=track-001'
+    """
+    try:
+        # Substitute path parameters
+        if path_params is not None:
+            endpoint = endpoint.format(**path_params)
+
+        # Build full URL
+        url = f"{base_url}{api_prefix}/{endpoint}"
+
+        # Add query parameters
+        if query_params:
+            # Filter out None values
+            clean_params = {k: v for k, v in query_params.items() if v is not None}
+            if clean_params:
+                query_string = urlencode(clean_params)
+                url = f"{url}?{query_string}"
+
+        return url
+
+    except KeyError as e:
+        raise URLBuildError(f"Missing path parameter: {e}")
+    except Exception as e:
+        raise URLBuildError(f"Failed to build URL: {e}")

inter_service_sdk-1.0.2.dist-info/METADATA

@@ -0,0 +1,332 @@
+Metadata-Version: 2.4
+Name: inter-service-sdk
+Version: 1.0.2
+Summary: Complete framework for inter-service communication with client, server utilities, auth and encryption
+Home-page: https://github.com/AlexanderRyzhko/inter-service-sdk
+Author: Blazel
+Author-email: Blazel <dev@blazel.com>
+Project-URL: Homepage, https://github.com/AlexanderRyzhko/inter-service-sdk
+Project-URL: Bug Tracker, https://github.com/AlexanderRyzhko/inter-service-sdk/issues
+Project-URL: Documentation, https://github.com/AlexanderRyzhko/inter-service-sdk#readme
+Project-URL: Source Code, https://github.com/AlexanderRyzhko/inter-service-sdk
+Keywords: http,client,server,api,rest,fastapi,inter-service,microservices,authentication,encryption,ecc,bearer-token
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: fastapi>=0.104.0
+Provides-Extra: crypto
+Requires-Dist: cryptography>=41.0.0; extra == "crypto"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.11.1; extra == "dev"
+Requires-Dist: requests-mock>=1.11.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.1.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: types-requests>=2.31.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: cryptography>=41.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Inter-Service SDK
+
+Generic HTTP client for secure service-to-service communication with bearer token authentication and optional ECC encryption.
+
+## Features
+
+- 🔐 **Bearer Token Auth** - Automatic authentication headers
+- 🔒 **Optional ECC Encryption** - End-to-end encryption for sensitive data
+- 🎯 **Path & Query Parameters** - Clean parameter substitution
+- 🔄 **Automatic Retries** - Exponential backoff for failed requests
+- 📝 **Structured Logging** - Request/response tracking
+- 🚀 **Zero Dependencies** - Only requests and cryptography (optional)
+
+## Installation
+
+```bash
+pip install inter-service-sdk
+```
+
+## Quick Start
+
+```python
+from inter_service_sdk import InterServiceClient
+
+# Initialize client
+client = InterServiceClient(
+    base_url="https://api.example.com",
+    api_key="your-secret-key"
+)
+
+# Make a request
+response = client.request(
+    endpoint="users/{user_id}",
+    path_params={"user_id": 123}
+)
+
+print(response["data"])
+```
+
+## Usage
+
+### Basic GET Request
+
+```python
+client = InterServiceClient(
+    base_url="https://api.example.com",
+    api_key="your-api-key"
+)
+
+# GET /api/v1/inter-service/users/123
+user = client.request(
+    endpoint="users/{user_id}",
+    path_params={"user_id": 123}
+)
+```
+
+### With Query Parameters
+
+```python
+# GET /api/v1/inter-service/users/search?q=john&type=email&limit=10
+results = client.request(
+    endpoint="users/search",
+    query_params={
+        "q": "john",
+        "type": "email",
+        "limit": 10
+    }
+)
+```
+
+### POST Request
+
+```python
+# POST /api/v1/inter-service/users
+new_user = client.request(
+    endpoint="users",
+    method="POST",
+    data={
+        "name": "John Doe",
+        "email": "john@example.com"
+    }
+)
+```
+
+### With ECC Encryption
+
+```python
+client = InterServiceClient(
+    base_url="https://api.example.com",
+    api_key="your-api-key",
+    ecc_private_key=os.getenv("PRIVATE_KEY"),
+    ecc_public_key=os.getenv("PUBLIC_KEY")
+)
+
+# Auto-decrypt response
+credentials = client.request(
+    endpoint="credentials/{id}",
+    path_params={"id": 456},
+    decrypt=True
+)
+
+# Auto-encrypt request
+client.request(
+    endpoint="secrets",
+    method="POST",
+    data={"secret": "sensitive data"},
+    encrypt=True
+)
+```
+
+### Custom API Prefix
+
+```python
+# Default prefix: /api/v1/inter-service
+client = InterServiceClient(
+    base_url="https://api.example.com",
+    api_key="key",
+    api_prefix="/v2/api"  # Custom prefix
+)
+
+# Override per request
+response = client.request(
+    endpoint="custom",
+    api_prefix="/internal"
+)
+```
+
+## API Reference
+
+### InterServiceClient
+
+```python
+InterServiceClient(
+    base_url: str,
+    api_key: str,
+    api_prefix: str = "/api/v1/inter-service",
+    timeout: int = 30,
+    retry_attempts: int = 3,
+    ecc_private_key: str = None,
+    ecc_public_key: str = None
+)
+```
+
+#### Parameters
+
+- `base_url` (str): Base URL of the API (e.g., "https://api.example.com")
+- `api_key` (str): Bearer token for authentication
+- `api_prefix` (str, optional): API prefix. Default: "/api/v1/inter-service"
+- `timeout` (int, optional): Request timeout in seconds. Default: 30
+- `retry_attempts` (int, optional): Number of retry attempts. Default: 3
+- `ecc_private_key` (str, optional): ECC private key for decryption
+- `ecc_public_key` (str, optional): ECC public key for encryption
+
+### request()
+
+```python
+client.request(
+    endpoint: str,
+    path_params: dict = None,
+    query_params: dict = None,
+    method: str = "GET",
+    data: dict = None,
+    headers: dict = None,
+    encrypt: bool = False,
+    decrypt: bool = False,
+    timeout: int = None,
+    api_prefix: str = None
+) -> dict
+```
+
+#### Parameters
+
+- `endpoint` (str): Endpoint template (e.g., "users/{user_id}")
+- `path_params` (dict, optional): Path parameters for substitution
+- `query_params` (dict, optional): Query string parameters
+- `method` (str, optional): HTTP method. Default: "GET"
+- `data` (dict, optional): Request body (JSON)
+- `headers` (dict, optional): Additional headers
+- `encrypt` (bool, optional): Auto-encrypt request data. Default: False
+- `decrypt` (bool, optional): Auto-decrypt response. Default: False
+- `timeout` (int, optional): Override default timeout
+- `api_prefix` (str, optional): Override default API prefix
+
+#### Returns
+
+```python
+{
+    "status": "success" | "error",
+    "data": {...} | None,
+    "status_code": int,
+    "error": None | str
+}
+```
+
+## Error Handling
+
+```python
+response = client.request(endpoint="users/123")
+
+if response["status"] == "success":
+    user = response["data"]
+    print(user)
+else:
+    print(f"Error: {response['error']}")
+    print(f"Status code: {response['status_code']}")
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# Recommended approach
+export API_BASE_URL="https://api.example.com"
+export API_KEY="your-secret-key"
+export ECC_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----..."
+export ECC_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----..."
+```
+
+```python
+import os
+from inter_service_sdk import InterServiceClient
+
+client = InterServiceClient(
+    base_url=os.getenv("API_BASE_URL"),
+    api_key=os.getenv("API_KEY"),
+    ecc_private_key=os.getenv("ECC_PRIVATE_KEY"),
+    ecc_public_key=os.getenv("ECC_PUBLIC_KEY")
+)
+```
+
+## Development
+
+### Install Development Dependencies
+
+```bash
+pip install -r requirements-dev.txt
+```
+
+### Run Tests
+
+```bash
+pytest tests/ -v
+```
+
+### Run Tests with Coverage
+
+```bash
+pytest tests/ --cov=inter_service_sdk --cov-report=html
+```
+
+### Code Formatting
+
+```bash
+black inter_service_sdk tests
+```
+
+### Type Checking
+
+```bash
+mypy inter_service_sdk
+```
+
+## Examples
+
+See the `examples/` directory for more usage examples:
+
+- `basic_usage.py` - Simple GET request
+- `with_encryption.py` - ECC encryption example
+- `search_example.py` - Query parameters example
+- `post_example.py` - POST request example
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Support
+
+For questions or issues, please open a GitHub issue.

inter_service_sdk-1.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+inter_service_sdk/__init__.py,sha256=jh8ssdcY-xx8YqU-95bS66Hwk0MuTBgb4WLa29mm4KA,1029
+inter_service_sdk/client.py,sha256=vVxVFwz1PUAqar2oB4xvnjnK9Q2K7aUXHOD61c1LhEQ,9083
+inter_service_sdk/crypto.py,sha256=TAZdYwY31oqcXtD-jiMGI78JB8sXLmcH-5FtbrW9QzM,5454
+inter_service_sdk/exceptions.py,sha256=fsSTlzFONRkp-XyDTurBukYLxVW0Jv92oiRzJckSf20,613
+inter_service_sdk/server.py,sha256=o_yTeJsZEaENaWu7sXsoOoYIHyTaQlKIErPZ97LnMhc,7444
+inter_service_sdk/utils.py,sha256=RUsAvfW4SR88pEIAeALlsgCVvZW0dh7fMrFXyKoJLAI,1814
+inter_service_sdk-1.0.2.dist-info/licenses/LICENSE,sha256=XEFRrh9UxgguPd7guDSATVu6fD-ELas15sua3tt-P1A,1062
+inter_service_sdk-1.0.2.dist-info/METADATA,sha256=K0vtMkaqzUPwdk0mJehg7yw5os58Bp3uh000uwlVgbo,8264
+inter_service_sdk-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+inter_service_sdk-1.0.2.dist-info/top_level.txt,sha256=xamGXNnKO2HPkQewZcNFzMi8ex2aur43r-ENiu5Lmj8,18
+inter_service_sdk-1.0.2.dist-info/RECORD,,

inter_service_sdk-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

inter_service_sdk-1.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Blazel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inter_service_sdk-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+inter_service_sdk