yeonjae-universal-http-api-client 1.0.1__py3-none-any.whl

universal_http_api_client/exceptions.py

@@ -0,0 +1,209 @@
+"""
+HTTPAPIClient 모듈의 예외 클래스 정의
+"""
+
+from typing import Optional, Dict, Any
+
+
+class APIError(Exception):
+    """API 호출 관련 기본 예외"""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_data: Optional[Dict[str, Any]] = None,
+        platform: Optional[str] = None
+    ):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.response_data = response_data or {}
+        self.platform = platform
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.platform:
+            parts.append(f"Platform: {self.platform}")
+        if self.status_code:
+            parts.append(f"Status: {self.status_code}")
+        return " | ".join(parts)
+
+
+class RateLimitError(APIError):
+    """Rate Limit 초과 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Rate limit exceeded",
+        retry_after: Optional[int] = None,
+        remaining: int = 0,
+        reset_time: Optional[int] = None,
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, 429, platform=platform)
+        self.retry_after = retry_after
+        self.remaining = remaining
+        self.reset_time = reset_time
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.platform:
+            parts.append(f"Platform: {self.platform}")
+        if self.retry_after:
+            parts.append(f"Retry after: {self.retry_after}s")
+        if self.remaining is not None:
+            parts.append(f"Remaining: {self.remaining}")
+        return " | ".join(parts)
+
+
+class AuthenticationError(APIError):
+    """인증 관련 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Authentication failed",
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, 401, platform=platform)
+
+
+class AuthorizationError(APIError):
+    """권한 관련 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Insufficient permissions",
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, 403, platform=platform)
+
+
+class NotFoundError(APIError):
+    """리소스를 찾을 수 없음 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Resource not found",
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, 404, platform=platform)
+
+
+class ServerError(APIError):
+    """서버 에러 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Internal server error",
+        status_code: int = 500,
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, status_code, platform=platform)
+
+
+class NetworkError(APIError):
+    """네트워크 관련 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Network error occurred",
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, platform=platform)
+
+
+class TimeoutError(APIError):
+    """타임아웃 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Request timeout",
+        timeout: Optional[float] = None,
+        platform: Optional[str] = None
+    ):
+        super().__init__(message, platform=platform)
+        self.timeout = timeout
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.platform:
+            parts.append(f"Platform: {self.platform}")
+        if self.timeout:
+            parts.append(f"Timeout: {self.timeout}s")
+        return " | ".join(parts)
+
+
+class ValidationError(APIError):
+    """데이터 검증 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Validation error",
+        field: Optional[str] = None,
+        value: Optional[Any] = None
+    ):
+        super().__init__(message)
+        self.field = field
+        self.value = value
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.field:
+            parts.append(f"Field: {self.field}")
+        if self.value is not None:
+            parts.append(f"Value: {self.value}")
+        return " | ".join(parts)
+
+
+class CacheError(APIError):
+    """캐시 관련 예외"""
+    
+    def __init__(
+        self,
+        message: str = "Cache operation failed",
+        operation: Optional[str] = None
+    ):
+        super().__init__(message)
+        self.operation = operation
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.operation:
+            parts.append(f"Operation: {self.operation}")
+        return " | ".join(parts)
+
+
+class PlatformNotSupportedError(APIError):
+    """지원하지 않는 플랫폼 예외"""
+    
+    def __init__(
+        self,
+        platform: str,
+        supported_platforms: Optional[list] = None
+    ):
+        message = f"Platform '{platform}' is not supported"
+        super().__init__(message, platform=platform)
+        self.supported_platforms = supported_platforms or []
+    
+    def __str__(self) -> str:
+        parts = [self.message]
+        if self.supported_platforms:
+            parts.append(f"Supported: {', '.join(self.supported_platforms)}")
+        return " | ".join(parts)
+
+
+def handle_http_error(status_code: int, message: str, platform: Optional[str] = None) -> APIError:
+    """HTTP 상태 코드에 따른 적절한 예외 반환"""
+    if status_code == 401:
+        return AuthenticationError(message, platform)
+    elif status_code == 403:
+        return AuthorizationError(message, platform)
+    elif status_code == 404:
+        return NotFoundError(message, platform)
+    elif status_code == 429:
+        return RateLimitError(message, platform=platform)
+    elif 500 <= status_code < 600:
+        return ServerError(message, status_code, platform)
+    else:
+        return APIError(message, status_code, platform=platform) 

universal_http_api_client/models.py

@@ -0,0 +1,200 @@
+"""
+HTTPAPIClient 모듈의 데이터 모델 정의
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional, Union, List
+from datetime import datetime
+from enum import Enum
+
+
+class HTTPMethod(Enum):
+    """HTTP 메서드 정의"""
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+    PATCH = "PATCH"
+
+
+class Platform(Enum):
+    """지원하는 플랫폼 정의"""
+    GITHUB = "github"
+    GITLAB = "gitlab"
+    BITBUCKET = "bitbucket"
+    GENERIC = "generic"
+
+
+@dataclass
+class PlatformConfig:
+    """플랫폼별 설정"""
+    name: str
+    base_url: str
+    auth_header: str
+    auth_prefix: str = ""
+    rate_limit_per_hour: int = 5000
+    rate_limit_per_minute: Optional[int] = None
+    default_headers: Dict[str, str] = field(default_factory=dict)
+    timeout: int = 30
+    
+    def get_auth_header(self, token: str) -> Dict[str, str]:
+        """인증 헤더 생성"""
+        if self.auth_prefix:
+            auth_value = f"{self.auth_prefix} {token}"
+        else:
+            auth_value = token
+        return {self.auth_header: auth_value}
+
+
+@dataclass
+class APIRequest:
+    """API 요청 정보"""
+    platform: Platform
+    method: HTTPMethod
+    endpoint: str
+    headers: Optional[Dict[str, str]] = None
+    params: Optional[Dict[str, Any]] = None
+    data: Optional[Dict[str, Any]] = None
+    timeout: Optional[int] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """딕셔너리 변환"""
+        return {
+            "platform": self.platform.value,
+            "method": self.method.value,
+            "endpoint": self.endpoint,
+            "headers": self.headers or {},
+            "params": self.params or {},
+            "data": self.data or {},
+            "timeout": self.timeout
+        }
+
+
+@dataclass
+class APIResponse:
+    """API 응답 정보"""
+    status_code: int
+    data: Dict[str, Any]
+    headers: Dict[str, str]
+    success: bool
+    error_message: Optional[str] = None
+    response_time: Optional[float] = None
+    cached: bool = False
+    
+    @classmethod
+    def success_response(
+        cls,
+        status_code: int,
+        data: Dict[str, Any],
+        headers: Dict[str, str],
+        response_time: Optional[float] = None,
+        cached: bool = False
+    ) -> 'APIResponse':
+        """성공 응답 생성"""
+        return cls(
+            status_code=status_code,
+            data=data,
+            headers=headers,
+            success=True,
+            response_time=response_time,
+            cached=cached
+        )
+    
+    @classmethod
+    def error_response(
+        cls,
+        status_code: int,
+        error_message: str,
+        headers: Optional[Dict[str, str]] = None
+    ) -> 'APIResponse':
+        """에러 응답 생성"""
+        return cls(
+            status_code=status_code,
+            data={},
+            headers=headers or {},
+            success=False,
+            error_message=error_message
+        )
+
+
+@dataclass
+class RateLimitInfo:
+    """Rate Limit 정보"""
+    remaining: int
+    limit: int
+    reset_time: datetime
+    retry_after: Optional[int] = None
+    
+    @property
+    def is_exhausted(self) -> bool:
+        """Rate limit 고갈 여부"""
+        return self.remaining <= 0
+    
+    def is_near_limit(self, threshold: int = 10) -> bool:
+        """Rate limit 임계값 근접 여부"""
+        return self.remaining <= threshold
+
+
+@dataclass
+class CacheKey:
+    """캐시 키 정보"""
+    platform: str
+    endpoint: str
+    params_hash: str
+    
+    def __str__(self) -> str:
+        return f"{self.platform}:{self.endpoint}:{self.params_hash}"
+
+
+@dataclass
+class CachedResponse:
+    """캐시된 응답 정보"""
+    response: APIResponse
+    cached_at: datetime
+    ttl: int
+    
+    @property
+    def is_expired(self) -> bool:
+        """캐시 만료 여부"""
+        from datetime import datetime, timedelta, timezone
+        return datetime.now(timezone.utc) > self.cached_at + timedelta(seconds=self.ttl)
+
+
+# 플랫폼별 설정 정의
+PLATFORM_CONFIGS = {
+    Platform.GITHUB: PlatformConfig(
+        name="GitHub",
+        base_url="https://api.github.com",
+        auth_header="Authorization",
+        auth_prefix="token",
+        rate_limit_per_hour=5000,
+        rate_limit_per_minute=None,
+        default_headers={
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "CodePing-HTTPAPIClient/1.0"
+        }
+    ),
+    Platform.GITLAB: PlatformConfig(
+        name="GitLab",
+        base_url="https://gitlab.com/api/v4",
+        auth_header="PRIVATE-TOKEN",
+        auth_prefix="",
+        rate_limit_per_hour=None,
+        rate_limit_per_minute=300,
+        default_headers={
+            "Content-Type": "application/json",
+            "User-Agent": "CodePing-HTTPAPIClient/1.0"
+        }
+    ),
+    Platform.BITBUCKET: PlatformConfig(
+        name="Bitbucket",
+        base_url="https://api.bitbucket.org/2.0",
+        auth_header="Authorization",
+        auth_prefix="Bearer",
+        rate_limit_per_hour=1000,
+        default_headers={
+            "Accept": "application/json",
+            "User-Agent": "CodePing-HTTPAPIClient/1.0"
+        }
+    )
+} 

universal_http_api_client/utils.py

@@ -0,0 +1,40 @@
+"""
+독립적인 유틸리티 모듈
+"""
+import logging
+import time
+from typing import Any, Dict, Optional
+
+
+class ModuleIOLogger:
+    """모듈 입출력 로거 - shared.utils.logging.ModuleIOLogger 대체"""
+    
+    def __init__(self, module_name: str):
+        self.module_name = module_name
+        self.logger = logging.getLogger(f"ModuleIO.{module_name}")
+    
+    def log_input(self, operation: str, **kwargs):
+        """입력 로깅"""
+        self.logger.debug(f"[{self.module_name}] INPUT {operation}: {kwargs}")
+    
+    def log_output(self, operation: str, result: Any, execution_time: Optional[float] = None):
+        """출력 로깅"""
+        log_msg = f"[{self.module_name}] OUTPUT {operation}: success"
+        if execution_time:
+            log_msg += f" (took {execution_time:.3f}s)"
+        self.logger.debug(log_msg)
+    
+    def log_error(self, operation: str, error: Exception, execution_time: Optional[float] = None):
+        """에러 로깅"""
+        log_msg = f"[{self.module_name}] ERROR {operation}: {type(error).__name__}: {error}"
+        if execution_time:
+            log_msg += f" (took {execution_time:.3f}s)"
+        self.logger.error(log_msg)
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """로깅 설정"""
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )

yeonjae_universal_http_api_client-1.0.1.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: yeonjae-universal-http-api-client
+Version: 1.0.1
+Summary: Universal HTTP API client supporting GitHub, GitLab, Bitbucket and other platforms
+Author-email: "CodePing.AI Team" <contact@codeping.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/yeonjae-work/universal-modules
+Project-URL: Repository, https://github.com/yeonjae-work/universal-modules
+Project-URL: Issues, https://github.com/yeonjae-work/universal-modules/issues
+Project-URL: Changelog, https://github.com/yeonjae-work/universal-modules/blob/main/packages/yeonjae-universal-http-api-client/CHANGELOG.md
+Keywords: http,api,client,github,gitlab,slack,notion,universal
+Classifier: Development Status :: 5 - Production/Stable
+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 :: HTTP Servers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: requests-mock>=1.9.0; extra == "dev"
+
+# Universal HTTP API Client
+
+Universal HTTP API client with platform-specific adapters for GitHub, GitLab, Slack, and Notion.
+
+## Features
+
+- **Multi-Platform Support**: GitHub, GitLab, Slack, Notion APIs
+- **Smart Caching**: Automatic request caching with configurable TTL
+- **Rate Limiting**: Built-in rate limiting with platform-specific rules
+- **Error Handling**: Comprehensive error handling with custom exceptions
+- **Async Support**: Full async/await support for all operations
+- **Type Safety**: Complete type annotations with mypy support
+
+## Installation
+
+```bash
+pip install universal-http-api-client
+```
+
+## Quick Start
+
+```python
+from universal_http_api_client import HTTPAPIClient, Platform
+
+# GitHub API
+client = HTTPAPIClient(Platform.GITHUB, "your-token")
+repo = client.get_repository("owner/repo")
+client.close()
+
+# Slack API
+slack_client = HTTPAPIClient(Platform.SLACK, "your-slack-token")
+response = slack_client.send_message("channel", "Hello World!")
+slack_client.close()
+```
+
+## License
+
+MIT License

yeonjae_universal_http_api_client-1.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+universal_http_api_client/__init__.py,sha256=sSioVC1Alh4IBNijvZiEShy8mbh3Xdqimnq5m1F--nI,1056
+universal_http_api_client/adapters.py,sha256=S_5zyH6NIy-dg_w7v1EMLPBi_KrIRixFMPRxELLZfLc,11699
+universal_http_api_client/client.py,sha256=lq9jFsO5bku4kkTT0VnqEi5GP2Zx9xqsoeOvk-YlfZQ,21774
+universal_http_api_client/exceptions.py,sha256=uuABwSQIMnHL92Rdo4Ojw4BNYEfERNsQnVICVzW5tec,5848
+universal_http_api_client/models.py,sha256=FaOQUitSBEuzbO6KXNiNRqGpYctWX-bBtN2bQB47224,5162
+universal_http_api_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_http_api_client/utils.py,sha256=PV3Xv-9VOc3OJ9vXHKsVagKOXbE1H66OyOvehHX1gp0,1407
+yeonjae_universal_http_api_client-1.0.1.dist-info/METADATA,sha256=NkYCWrCWs5R5oEkWPqX4kNsQ2hLVfLawF8EI0HeAdNw,2898
+yeonjae_universal_http_api_client-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+yeonjae_universal_http_api_client-1.0.1.dist-info/top_level.txt,sha256=eiCeozAaUmZUn2d3cu5PPa3fJShjaa1SsxU9wnBmAiI,26
+yeonjae_universal_http_api_client-1.0.1.dist-info/RECORD,,

yeonjae_universal_http_api_client-1.0.1.dist-info/WHEEL

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

yeonjae_universal_http_api_client-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+universal_http_api_client