aiteamutils 0.2.52__tar.gz → 0.2.54__tar.gz

{aiteamutils-0.2.52 → aiteamutils-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiteamutils
-Version: 0.2.52
+Version: 0.2.54
 Summary: AI Team Utilities
 Project-URL: Homepage, https://github.com/yourusername/aiteamutils
 Project-URL: Issues, https://github.com/yourusername/aiteamutils/issues

aiteamutils-0.2.54/aiteamutils/database.py

@@ -0,0 +1,207 @@
+"""데이터베이스 유틸리티 모듈."""
+from typing import Any, Dict, Optional, Type, List, Union
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from .exceptions import ErrorCode, CustomException
+from .base_model import Base
+
+class DatabaseService:
+    def __init__(self, session: AsyncSession):
+        """DatabaseService 초기화
+        
+        Args:
+            session (AsyncSession): 외부에서 주입받은 데이터베이스 세션
+        """
+        self._session = session
+    
+    @property
+    def session(self) -> AsyncSession:
+        """현재 세션을 반환합니다."""
+        if self._session is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="session",
+                source_function="DatabaseService.session"
+            )
+        return self._session
+
+    async def create_entity(
+        self,
+        model: Type[Base],
+        entity_data: Dict[str, Any]
+    ) -> Any:
+        """엔티티를 생성합니다.
+        
+        Args:
+            model: 모델 클래스
+            entity_data: 생성할 엔티티 데이터
+            
+        Returns:
+            생성된 엔티티
+            
+        Raises:
+            CustomException: 엔티티 생성 실패 시
+        """
+        try:
+            entity = model(**entity_data)
+            self.session.add(entity)
+            await self.session.flush()
+            await self.session.refresh(entity)
+            return entity
+        except IntegrityError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_INTEGRITY_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.create_entity",
+                original_error=e
+            )
+        except Exception as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_CREATE_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.create_entity",
+                original_error=e
+            )
+
+    async def get_entity(
+        self,
+        model: Type[Base],
+        filters: Dict[str, Any]
+    ) -> Optional[Any]:
+        """필터 조건으로 엔티티를 조회합니다.
+        
+        Args:
+            model: 모델 클래스
+            filters: 필터 조건
+            
+        Returns:
+            조회된 엔티티 또는 None
+            
+        Raises:
+            CustomException: 조회 실패 시
+        """
+        try:
+            stmt = select(model).filter_by(**filters)
+            result = await self.session.execute(stmt)
+            return result.scalars().first()
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.DB_QUERY_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.get_entity",
+                original_error=e
+            )
+
+    async def list_entities(
+        self,
+        model: Type[Base],
+        filters: Optional[Dict[str, Any]] = None,
+        skip: int = 0,
+        limit: int = 100
+    ) -> List[Any]:
+        """엔티티 목록을 조회합니다.
+        
+        Args:
+            model: 모델 클래스
+            filters: 필터 조건
+            skip: 건너뛸 레코드 수
+            limit: 조회할 최대 레코드 수
+            
+        Returns:
+            엔티티 목록
+            
+        Raises:
+            CustomException: 조회 실패 시
+        """
+        try:
+            stmt = select(model)
+            if filters:
+                stmt = stmt.filter_by(**filters)
+            stmt = stmt.offset(skip).limit(limit)
+            result = await self.session.execute(stmt)
+            return result.scalars().all()
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.DB_QUERY_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.list_entities",
+                original_error=e
+            )
+
+    async def update_entity(
+        self,
+        entity: Base,
+        update_data: Dict[str, Any]
+    ) -> Any:
+        """엔티티를 수정합니다.
+        
+        Args:
+            entity: 수정할 엔티티
+            update_data: 수정할 데이터
+            
+        Returns:
+            수정된 엔티티
+            
+        Raises:
+            CustomException: 수정 실패 시
+        """
+        try:
+            for key, value in update_data.items():
+                setattr(entity, key, value)
+            await self.session.flush()
+            await self.session.refresh(entity)
+            return entity
+        except IntegrityError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_INTEGRITY_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.update_entity",
+                original_error=e
+            )
+        except Exception as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_UPDATE_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.update_entity",
+                original_error=e
+            )
+
+    async def delete_entity(
+        self,
+        entity: Base,
+        soft_delete: bool = True
+    ) -> bool:
+        """엔티티를 삭제합니다.
+        
+        Args:
+            entity: 삭제할 엔티티
+            soft_delete: 소프트 삭제 여부
+            
+        Returns:
+            삭제 성공 여부
+            
+        Raises:
+            CustomException: 삭제 실패 시
+        """
+        try:
+            if soft_delete:
+                entity.is_deleted = True
+                await self.session.flush()
+            else:
+                await self.session.delete(entity)
+                await self.session.flush()
+            return True
+        except Exception as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_DELETE_ERROR,
+                detail=str(e),
+                source_function="DatabaseService.delete_entity",
+                original_error=e
+            )

{aiteamutils-0.2.52 → aiteamutils-0.2.54}/aiteamutils/dependencies.py

@@ -9,33 +9,13 @@ from .exceptions import CustomException, ErrorCode
 from .config import get_settings
 from .base_service import BaseService
 from .base_repository import BaseRepository
-from .database import db_manager
+from .database import DatabaseService
 
 T = TypeVar("T", bound=BaseService)
 R = TypeVar("R", bound=BaseRepository)
 
 _service_registry: Dict[str, Dict[str, Any]] = {}
 
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """데이터베이스 세션을 반환합니다.
-    
-    Yields:
-        AsyncSession: 데이터베이스 세션
-        
-    Raises:
-        CustomException: 세션 생성 실패 시
-    """
-    try:
-        async with db_manager.get_session() as session:
-            yield session
-    except Exception as e:
-        raise CustomException(
-            ErrorCode.DATABASE_ERROR,
-            detail=str(e),
-            source_function="dependencies.get_db",
-            original_error=e
-        )
-
 def register_service(
     service_class: Type[T],
     repository_class: Optional[Type[R]] = None,
@@ -86,6 +66,9 @@ async def _get_service(
         repository_class = service_info["repository_class"]
         dependencies = service_info["dependencies"]
         
+        # 데이터베이스 서비스 생성
+        db_service = DatabaseService(session=session)
+        
         # 저장소 인스턴스 생성
         repository = None
         if repository_class:
@@ -93,8 +76,8 @@ async def _get_service(
             
         # 서비스 인스턴스 생성
         service = service_class(
+            db=db_service,
             repository=repository,
-            session=session,
             request=request,
             **dependencies
         )
@@ -122,14 +105,14 @@ def get_service(service_name: str) -> Callable:
     """
     async def _get_service_dependency(
         request: Request,
-        session: AsyncSession = Depends(get_db)
+        session: AsyncSession
     ) -> BaseService:
         return await _get_service(service_name, session, request)
     return _get_service_dependency
 
 async def get_current_user(
     request: Request,
-    session: AsyncSession = Depends(get_db),
+    session: AsyncSession,
     auth_service: BaseService = Depends(get_service("AuthService"))
 ) -> Dict[str, Any]:
     """현재 사용자 정보를 반환합니다.

{aiteamutils-0.2.52 → aiteamutils-0.2.54}/aiteamutils/security.py

@@ -1,12 +1,10 @@
 """보안 관련 유틸리티."""
 from datetime import datetime, timedelta, UTC
-from typing import Dict, Any, Optional, Literal, Callable, Type
-from sqlalchemy.orm import DeclarativeBase as Base
+from typing import Dict, Any, Optional, Literal, Callable, TYPE_CHECKING
 from fastapi import Request, HTTPException, status
 from functools import wraps
 from jose import jwt, JWTError
 from passlib.context import CryptContext
-from sqlalchemy.ext.asyncio import AsyncSession
 import logging
 
 from .exceptions import CustomException, ErrorCode
@@ -20,29 +18,12 @@ _rate_limits: Dict[str, Dict[str, Any]] = {}
 
 class RateLimitExceeded(CustomException):
     """Rate limit 초과 예외."""
-    
-    def __init__(
-        self,
-        detail: str,
-        source_function: str,
-        remaining_seconds: float,
-        max_requests: int,
-        window_seconds: int
-    ):
-        """Rate limit 초과 예외를 초기화합니다."""
+    def __init__(self, detail: str, source_function: str):
         super().__init__(
             ErrorCode.RATE_LIMIT_EXCEEDED,
             detail=detail,
-            source_function=source_function,
-            metadata={
-                "remaining_seconds": remaining_seconds,
-                "max_requests": max_requests,
-                "window_seconds": window_seconds
-            }
+            source_function=source_function
         )
-        self.remaining_seconds = remaining_seconds
-        self.max_requests = max_requests
-        self.window_seconds = window_seconds
 
 def verify_password(plain_password: str, hashed_password: str) -> bool:
     """비밀번호를 검증합니다."""
@@ -68,28 +49,97 @@ def hash_password(password: str) -> str:
             original_error=e
         )
 
+def rate_limit(
+    max_requests: int,
+    window_seconds: int,
+    key_func: Optional[Callable] = None
+):
+    """Rate limiting 데코레이터."""
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Request 객체 찾기
+            request = None
+            for arg in args:
+                if isinstance(arg, Request):
+                    request = arg
+                    break
+            if not request:
+                for arg in kwargs.values():
+                    if isinstance(arg, Request):
+                        request = arg
+                        break
+            if not request:
+                raise CustomException(
+                    ErrorCode.INTERNAL_ERROR,
+                    detail="Request object not found",
+                    source_function="rate_limit"
+                )
+            
+            # 레이트 리밋 키 생성
+            if key_func:
+                rate_limit_key = f"rate_limit:{key_func(request)}"
+            else:
+                client_ip = request.client.host
+                rate_limit_key = f"rate_limit:{client_ip}:{func.__name__}"
+            
+            try:
+                now = datetime.now(UTC)
+                
+                # 현재 rate limit 정보 가져오기
+                rate_info = _rate_limits.get(rate_limit_key)
+                
+                if rate_info is None or (now - rate_info["start_time"]).total_seconds() >= window_seconds:
+                    # 새로운 rate limit 설정
+                    _rate_limits[rate_limit_key] = {
+                        "count": 1,
+                        "start_time": now
+                    }
+                else:
+                    # 기존 rate limit 업데이트
+                    if rate_info["count"] >= max_requests:
+                        # rate limit 초과
+                        remaining_seconds = window_seconds - (now - rate_info["start_time"]).total_seconds()
+                        raise CustomException(
+                            ErrorCode.RATE_LIMIT_EXCEEDED,
+                            detail=f"{int(remaining_seconds)}",
+                            source_function=func.__name__
+                        )
+                    rate_info["count"] += 1
+                
+                try:
+                    # 원래 함수 실행
+                    return await func(*args, **kwargs)
+                except CustomException as e:
+                    raise e
+                except Exception as e:
+                    raise CustomException(
+                        ErrorCode.INTERNAL_ERROR,
+                        detail=str(e),
+                        source_function=func.__name__,
+                        original_error=e
+                    )
+                    
+            except CustomException as e:
+                raise e
+            except Exception as e:
+                raise CustomException(
+                    ErrorCode.INTERNAL_ERROR,
+                    detail=str(e),
+                    source_function="rate_limit",
+                    original_error=e
+                )
+                
+        return wrapper
+    return decorator
+
 async def create_jwt_token(
     user_data: Dict[str, Any],
     token_type: Literal["access", "refresh"],
-    session: AsyncSession,
-    log_model: Type[Base],
+    db_service: Any,
     request: Optional[Request] = None
 ) -> str:
-    """JWT 토큰을 생성합니다.
-    
-    Args:
-        user_data (Dict[str, Any]): 사용자 데이터
-        token_type (Literal["access", "refresh"]): 토큰 타입
-        session (AsyncSession): 데이터베이스 세션
-        log_model (Type[Base]): 로그 모델
-        request (Optional[Request], optional): FastAPI 요청 객체. Defaults to None.
-        
-    Returns:
-        str: 생성된 JWT 토큰
-        
-    Raises:
-        CustomException: 토큰 생성 실패 시
-    """
+    """JWT 토큰을 생성하고 로그를 기록합니다."""
     try:
         settings = get_settings()
         
@@ -98,7 +148,7 @@ async def create_jwt_token(
             token_data = {
                 # 등록 클레임
                 "iss": settings.token_issuer,
-                "sub": user_data["ulid"],
+                "sub": user_data["username"],
                 "aud": settings.token_audience,
                 "exp": expires_at,
                 
@@ -123,7 +173,7 @@ async def create_jwt_token(
             expires_at = datetime.now(UTC) + timedelta(days=14)
             token_data = {
                 "iss": settings.token_issuer,
-                "sub": user_data["ulid"],
+                "sub": user_data["username"],
                 "exp": expires_at,
                 "token_type": token_type,
                 "user_ulid": user_data["ulid"]
@@ -146,13 +196,14 @@ async def create_jwt_token(
         # 로그 생성
         try:
             activity_type = ActivityType.ACCESS_TOKEN_ISSUED if token_type == "access" else ActivityType.REFRESH_TOKEN_ISSUED
-            log_entry = log_model(
-                type=activity_type,
-                user_ulid=user_data["ulid"],
-                token=token
+            await db_service.create_log(
+                {
+                    "type": activity_type,
+                    "user_ulid": user_data["ulid"],
+                    "token": token
+                },
+                request
             )
-            session.add(log_entry)
-            await session.flush()
         except Exception as e:
             # 로그 생성 실패는 토큰 생성에 영향을 주지 않음
             logging.error(f"Failed to create token log: {str(e)}")
@@ -173,18 +224,7 @@ async def verify_jwt_token(
     token: str,
     expected_type: Optional[Literal["access", "refresh"]] = None
 ) -> Dict[str, Any]:
-    """JWT 토큰을 검증합니다.
-    
-    Args:
-        token: 검증할 JWT 토큰
-        expected_type: 예상되는 토큰 타입
-        
-    Returns:
-        Dict[str, Any]: 토큰 페이로드
-        
-    Raises:
-        CustomException: 토큰 검증 실패 시
-    """
+    """JWT 토큰을 검증합니다."""
     try:
         settings = get_settings()
         
@@ -202,23 +242,14 @@ async def verify_jwt_token(
         if not token_type:
             raise CustomException(
                 ErrorCode.INVALID_TOKEN,
-                detail="Token type is missing",
+                detail=token,
                 source_function="security.verify_jwt_token"
             )
             
         if expected_type and token_type != expected_type:
             raise CustomException(
                 ErrorCode.INVALID_TOKEN,
-                detail=f"Expected {expected_type} token but got {token_type}",
-                source_function="security.verify_jwt_token"
-            )
-            
-        # 사용자 식별자 검증
-        user_ulid = payload.get("user_ulid")
-        if not user_ulid:
-            raise CustomException(
-                ErrorCode.INVALID_TOKEN,
-                detail="User identifier is missing",
+                detail=token,
                 source_function="security.verify_jwt_token"
             )
             
@@ -227,7 +258,7 @@ async def verify_jwt_token(
     except JWTError as e:
         raise CustomException(
             ErrorCode.INVALID_TOKEN,
-            detail=str(e),
+            detail=token,
             source_function="security.verify_jwt_token",
             original_error=e
         )
@@ -239,4 +270,22 @@ async def verify_jwt_token(
             detail=str(e),
             source_function="security.verify_jwt_token",
             original_error=e
+        )
+
+def validate_token(token: str) -> Dict[str, Any]:
+    """JWT 토큰을 검증하고 페이로드를 반환합니다."""
+    try:
+        settings = get_settings()
+        payload = jwt.decode(
+            token, 
+            settings.jwt_secret, 
+            algorithms=[settings.jwt_algorithm]
+        )
+        return payload
+    except JWTError as e:
+        raise CustomException(
+            ErrorCode.INVALID_TOKEN,
+            detail=token,
+            source_function="security.validate_token",
+            original_error=e
         ) 

aiteamutils-0.2.54/aiteamutils/version.py

@@ -0,0 +1,2 @@
+"""버전 정보"""
+__version__ = "0.2.54"