aiteamutils 0.2.41__tar.gz → 0.2.43__tar.gz

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/PKG-INFO

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

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/aiteamutils/__init__.py

@@ -1,9 +1,10 @@
 from .base_model import Base
 from .database import (
     DatabaseService,
+    DatabaseServiceManager,
     get_db,
     get_database_service,
-    get_database_session
+    lifespan
 )
 from .exceptions import (
     CustomException,
@@ -35,9 +36,10 @@ __all__ = [
     
     # Database
     "DatabaseService",
+    "DatabaseServiceManager",
     "get_db",
     "get_database_service",
-    "get_database_session",
+    "lifespan",
     
     # Exceptions
     "CustomException",

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/aiteamutils/cache.py

@@ -1,6 +1,6 @@
 from typing import Any, Optional
 from redis.asyncio import Redis
-from app.config import settings
+from .config import get_settings
 
 class Cache:
     _instance = None
@@ -15,6 +15,7 @@ class Cache:
         """
         if not cls._instance:
             cls._instance = cls()
+            settings = get_settings()
             cls._redis = Redis.from_url(settings.REDIS_URL, encoding="utf-8", decode_responses=True)
         return cls._instance
 

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/aiteamutils/config.py

@@ -1,6 +1,6 @@
 """설정 모듈."""
 from typing import Union
-from .database import init_database_service
+from .database import DatabaseServiceManager
 from .exceptions import CustomException, ErrorCode
 
 class Settings:
@@ -21,7 +21,7 @@ class Settings:
 
 _settings: Union[Settings, None] = None
 
-def init_settings(
+async def init_settings(
     jwt_secret: str,
     jwt_algorithm: str = "HS256",
     access_token_expire_minutes: int = 30,
@@ -59,7 +59,7 @@ def init_settings(
     )
     
     if db_url:
-        init_database_service(
+        await DatabaseServiceManager.get_instance(
             db_url=db_url,
             db_echo=db_echo,
             db_pool_size=db_pool_size,

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/aiteamutils/database.py

@@ -1,3 +1,5 @@
+import asyncio
+import logging
 from typing import Any, Dict, Optional, Type, AsyncGenerator, TypeVar, List, Union
 from sqlalchemy import select, update, and_, Table
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, AsyncEngine
@@ -6,10 +8,9 @@ from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 from sqlalchemy.pool import QueuePool
 from contextlib import asynccontextmanager
 from sqlalchemy import or_
-from fastapi import Request, Depends
+from fastapi import Request, Depends, FastAPI
 from ulid import ULID
 from sqlalchemy.sql import Select
-import logging
 
 from .exceptions import ErrorCode, CustomException
 from .base_model import Base, BaseColumn
@@ -17,60 +18,89 @@ from .enums import ActivityType
 
 T = TypeVar("T", bound=BaseColumn)
 
-# 전역 데이터베이스 서비스 인스턴스
-_database_service: Union['DatabaseService', None] = None
-
-def get_database_service() -> 'DatabaseService':
-    """DatabaseService 인스턴스를 반환하는 함수
+class DatabaseServiceManager:
+    _instance: Optional['DatabaseService'] = None
+    _lock = asyncio.Lock()
     
-    Returns:
-        DatabaseService: DatabaseService 인스턴스
-        
-    Raises:
-        CustomException: DatabaseService가 초기화되지 않은 경우
-    """
-    if _database_service is None:
-        raise CustomException(
-            ErrorCode.DB_CONNECTION_ERROR,
-            detail="Database service is not initialized. Call init_database_service() first.",
-            source_function="get_database_service"
-        )
-    return _database_service
+    @classmethod
+    async def get_instance(
+        cls,
+        db_url: str = None,
+        db_echo: bool = False,
+        db_pool_size: int = 5,
+        db_max_overflow: int = 10,
+        db_pool_timeout: int = 30,
+        db_pool_recycle: int = 1800,
+        **kwargs
+    ) -> 'DatabaseService':
+        """데이터베이스 서비스의 싱글톤 인스턴스를 반환합니다.
 
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """데이터베이스 세션을 생성하고 반환하는 비동기 제너레이터.
-    
-    Yields:
-        AsyncSession: 데이터베이스 세션
-        
-    Raises:
-        CustomException: 세션 생성 실패 시
-    """
-    db_service = get_database_service()
-    try:
-        async with db_service.get_session() as session:
-            yield session
-    except Exception as e:
-        raise CustomException(
-            ErrorCode.DB_CONNECTION_ERROR,
-            detail=f"Failed to get database session: {str(e)}",
-            source_function="get_db",
-            original_error=e
-        )
-    finally:
-        if 'session' in locals():
-            await session.close()
+        Args:
+            db_url (str, optional): 데이터베이스 URL
+            db_echo (bool, optional): SQL 로깅 여부
+            db_pool_size (int, optional): DB 커넥션 풀 크기
+            db_max_overflow (int, optional): 최대 초과 커넥션 수
+            db_pool_timeout (int, optional): 커넥션 풀 타임아웃
+            db_pool_recycle (int, optional): 커넥션 재활용 시간
 
-def get_database_session(db: AsyncSession = Depends(get_db)) -> 'DatabaseService':
-    """DatabaseService 의존성
+        Returns:
+            DatabaseService: 데이터베이스 서비스 인스턴스
 
-    Args:
-        db (AsyncSession): 데이터베이스 세션
+        Raises:
+            CustomException: 데이터베이스 초기화 실패 시
+        """
+        async with cls._lock:
+            if not cls._instance:
+                if not db_url:
+                    raise CustomException(
+                        ErrorCode.DB_CONNECTION_ERROR,
+                        detail="Database URL is required for initialization",
+                        source_function="DatabaseServiceManager.get_instance"
+                    )
+                try:
+                    cls._instance = DatabaseService(
+                        db_url=db_url,
+                        db_echo=db_echo,
+                        db_pool_size=db_pool_size,
+                        db_max_overflow=db_max_overflow,
+                        db_pool_timeout=db_pool_timeout,
+                        db_pool_recycle=db_pool_recycle,
+                        **kwargs
+                    )
+                    logging.info("Database service initialized successfully")
+                except Exception as e:
+                    logging.error(f"Failed to initialize database service: {str(e)}")
+                    raise CustomException(
+                        ErrorCode.DB_CONNECTION_ERROR,
+                        detail=f"Failed to initialize database service: {str(e)}",
+                        source_function="DatabaseServiceManager.get_instance",
+                        original_error=e
+                    )
+            return cls._instance
 
-    Returns:
-        DatabaseService: DatabaseService 인스턴스
-    """
-    return DatabaseService(session=db)
+    @classmethod
+    async def cleanup(cls) -> None:
+        """데이터베이스 서비스 인스턴스를 정리합니다."""
+        async with cls._lock:
+            if cls._instance:
+                try:
+                    if cls._instance.engine:
+                        await cls._instance.engine.dispose()
+                    cls._instance = None
+                    logging.info("Database service cleaned up successfully")
+                except Exception as e:
+                    logging.error(f"Error during database service cleanup: {str(e)}")
+                    raise CustomException(
+                        ErrorCode.DB_CONNECTION_ERROR,
+                        detail=f"Failed to cleanup database service: {str(e)}",
+                        source_function="DatabaseServiceManager.cleanup",
+                        original_error=e
+                    )
+
+    @classmethod
+    async def is_initialized(cls) -> bool:
+        """데이터베이스 서비스가 초기화되었는지 확인합니다."""
+        return cls._instance is not None
 
 class DatabaseService:
     def __init__(
@@ -122,10 +152,42 @@ class DatabaseService:
         else:
             raise CustomException(
                 ErrorCode.DB_CONNECTION_ERROR,
-                detail="db_url|session",
+                detail="Either db_url or session must be provided",
                 source_function="DatabaseService.__init__"
             )
 
+    async def is_connected(self) -> bool:
+        """데이터베이스 연결 상태를 확인합니다."""
+        try:
+            if not self.engine:
+                return False
+            async with self.engine.connect() as conn:
+                await conn.execute(select(1))
+            return True
+        except Exception:
+            return False
+
+    async def retry_connection(self, retries: int = 3, delay: int = 2) -> bool:
+        """데이터베이스 연결을 재시도합니다.
+
+        Args:
+            retries (int): 재시도 횟수
+            delay (int): 재시도 간 대기 시간(초)
+
+        Returns:
+            bool: 연결 성공 여부
+        """
+        for attempt in range(retries):
+            try:
+                if await self.is_connected():
+                    return True
+                await asyncio.sleep(delay)
+            except Exception as e:
+                logging.error(f"Connection retry attempt {attempt + 1} failed: {str(e)}")
+                if attempt == retries - 1:
+                    return False
+        return False
+
     @asynccontextmanager
     async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
         """데이터베이스 세션을 생성하고 반환하는 비동기 컨텍스트 매니저."""
@@ -934,60 +996,99 @@ class DatabaseService:
                 original_error=e
             )
 
-def init_database_service(
-    db_url: str,
-    db_echo: bool = False,
-    db_pool_size: int = 5,
-    db_max_overflow: int = 10,
-    db_pool_timeout: int = 30,
-    db_pool_recycle: int = 1800
-) -> DatabaseService:
-    """데이터베이스 서비스를 초기화합니다.
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """데이터베이스 세션을 생성하고 반환하는 비동기 제너레이터.
     
-    Args:
-        db_url (str): 데이터베이스 URL
-        db_echo (bool, optional): SQL 로깅 여부
-        db_pool_size (int, optional): DB 커넥션 풀 크기
-        db_max_overflow (int, optional): 최대 초과 커넥션 수
-        db_pool_timeout (int, optional): 커넥션 풀 타임아웃
-        db_pool_recycle (int, optional): 커넥션 재활용 시간
-        
-    Returns:
-        DatabaseService: 초기화된 데이터베이스 서비스 인스턴스
+    Yields:
+        AsyncSession: 데이터베이스 세션
         
     Raises:
-        CustomException: 데이터베이스 초기화 실패 시
+        CustomException: 세션 생성 실패 시
     """
-    try:
-        global _database_service
-        if _database_service is not None:
-            logging.info("Database service already initialized")
-            return _database_service
-            
-        logging.info(f"Initializing database service with URL: {db_url}")
-        _database_service = DatabaseService(
-            db_url=db_url,
-            db_echo=db_echo,
-            db_pool_size=db_pool_size,
-            db_max_overflow=db_max_overflow,
-            db_pool_timeout=db_pool_timeout,
-            db_pool_recycle=db_pool_recycle
+    if not await DatabaseServiceManager.is_initialized():
+        raise CustomException(
+            ErrorCode.DB_CONNECTION_ERROR,
+            detail="Database service is not initialized",
+            source_function="get_db"
         )
-        
-        if not _database_service.engine:
-            raise CustomException(
-                ErrorCode.DB_CONNECTION_ERROR,
-                detail="Database engine initialization failed",
-                source_function="init_database_service"
-            )
+    
+    db_service = await DatabaseServiceManager.get_instance()
+    if not db_service or not db_service.engine:
+        raise CustomException(
+            ErrorCode.DB_CONNECTION_ERROR,
+            detail="Database service or engine is not properly initialized",
+            source_function="get_db"
+        )
+    
+    try:
+        async with db_service.get_session() as session:
+            if session is None:
+                raise CustomException(
+                    ErrorCode.DB_CONNECTION_ERROR,
+                    detail="Failed to create database session",
+                    source_function="get_db"
+                )
             
-        logging.info("Database service initialized successfully")
-        return _database_service
+            # 세션이 유효한지 확인
+            try:
+                await session.execute(select(1))
+            except Exception as e:
+                raise CustomException(
+                    ErrorCode.DB_CONNECTION_ERROR,
+                    detail="Database session is not valid",
+                    source_function="get_db",
+                    original_error=e
+                )
+                
+            yield session
     except Exception as e:
-        logging.error(f"Failed to initialize database service: {str(e)}")
         raise CustomException(
             ErrorCode.DB_CONNECTION_ERROR,
-            detail=f"Failed to initialize database service: {str(e)}",
-            source_function="init_database_service",
+            detail=f"Failed to get database session: {str(e)}",
+            source_function="get_db",
             original_error=e
-        )
+        )
+    finally:
+        if 'session' in locals() and session is not None:
+            await session.close()
+
+async def get_database_service() -> DatabaseService:
+    """DatabaseService 의존성
+
+    Returns:
+        DatabaseService: DatabaseService 인스턴스
+        
+    Raises:
+        CustomException: 데이터베이스 서비스가 초기화되지 않은 경우
+    """
+    if not await DatabaseServiceManager.is_initialized():
+        raise CustomException(
+            ErrorCode.DB_CONNECTION_ERROR,
+            detail="Database service is not initialized",
+            source_function="get_database_service"
+        )
+    
+    return await DatabaseServiceManager.get_instance()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """FastAPI 애플리케이션 라이프사이클 관리자.
+    
+    Args:
+        app (FastAPI): FastAPI 애플리케이션 인스턴스
+    """
+    try:
+        # 시작 시 초기화
+        if not await DatabaseServiceManager.is_initialized():
+            await DatabaseServiceManager.get_instance(
+                db_url=app.state.settings.DATABASE_URL,
+                db_echo=app.state.settings.DB_ECHO,
+                db_pool_size=app.state.settings.DB_POOL_SIZE,
+                db_max_overflow=app.state.settings.DB_MAX_OVERFLOW,
+                db_pool_timeout=app.state.settings.DB_POOL_TIMEOUT,
+                db_pool_recycle=app.state.settings.DB_POOL_RECYCLE
+            )
+        yield
+    finally:
+        # 종료 시 정리
+        await DatabaseServiceManager.cleanup()

{aiteamutils-0.2.41 → aiteamutils-0.2.43}/aiteamutils/dependencies.py

@@ -5,87 +5,49 @@ from jose import JWTError, jwt
 from sqlalchemy.ext.asyncio import AsyncSession
 import logging
 
-from .database import DatabaseService, get_database_service, get_db
+from .database import DatabaseServiceManager, get_db, get_database_service
 from .exceptions import CustomException, ErrorCode
 from .config import get_settings
 
 class ServiceRegistry:
-    """서비스 레지스트리를 관리하는 클래스"""
+    """서비스 레지스트리 클래스"""
     def __init__(self):
-        self._services: Dict[str, Tuple[Type, Type]] = {}
-        self._initialized = False
-
-    def clear(self):
-        """등록된 모든 서비스를 초기화합니다."""
-        self._services.clear()
-        self._initialized = False
-
-    def register(self, name: str, repository_class: Type, service_class: Type):
-        """서비스를 레지스트리에 등록
-
+        self._services: Dict[str, Tuple[Type[Any], Type[Any]]] = {}
+    
+    def register(self, name: str, repository_class: Type[Any], service_class: Type[Any]) -> None:
+        """서비스를 등록합니다.
+        
         Args:
             name (str): 서비스 이름
-            repository_class (Type): Repository 클래스
-            service_class (Type): Service 클래스
-
-        Raises:
-            CustomException: 이미 등록된 서비스인 경우
+            repository_class (Type[Any]): 레포지토리 클래스
+            service_class (Type[Any]): 서비스 클래스
         """
-        try:
-            if name in self._services:
-                logging.warning(f"Service '{name}' is already registered. Skipping...")
-                return
-                
-            if not repository_class or not service_class:
-                raise CustomException(
-                    ErrorCode.INTERNAL_ERROR,
-                    detail=f"Invalid service classes for '{name}'",
-                    source_function="ServiceRegistry.register"
-                )
-                
-            self._services[name] = (repository_class, service_class)
-            logging.info(f"Service '{name}' registered successfully")
-            
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
-                detail=f"Failed to register service '{name}': {str(e)}",
-                source_function="ServiceRegistry.register",
-                original_error=e
-            )
-
-    def get(self, name: str) -> Tuple[Type, Type]:
-        """등록된 서비스를 조회
-
+        self._services[name] = (repository_class, service_class)
+    
+    def get(self, name: str) -> Tuple[Type[Any], Type[Any]]:
+        """등록된 서비스를 가져옵니다.
+        
         Args:
             name (str): 서비스 이름
-
+            
         Returns:
-            Tuple[Type, Type]: (Repository 클래스, Service 클래스) 튜플
-
+            Tuple[Type[Any], Type[Any]]: (레포지토리 클래스, 서비스 클래스)
+            
         Raises:
             CustomException: 등록되지 않은 서비스인 경우
         """
         if name not in self._services:
             raise CustomException(
-                ErrorCode.SERVICE_NOT_REGISTERED,
+                ErrorCode.NOT_FOUND,
                 detail=f"Service '{name}' is not registered",
                 source_function="ServiceRegistry.get"
             )
         return self._services[name]
-        
-    def is_initialized(self) -> bool:
-        """서비스 레지스트리 초기화 여부를 반환합니다."""
-        return self._initialized
-        
-    def set_initialized(self):
-        """서비스 레지스트리를 초기화 상태로 설정합니다."""
-        self._initialized = True
 
 # ServiceRegistry 초기화
 service_registry = ServiceRegistry()
 
-def get_service(name: str):
+async def get_service(name: str):
     """등록된 서비스를 가져오는 의존성 함수
 
     Args:
@@ -97,11 +59,11 @@ def get_service(name: str):
     Raises:
         CustomException: 서비스 생성 실패 시
     """
-    def _get_service(db_service: DatabaseService = Depends(get_database_service)):
+    async def _get_service(db_service = Depends(get_database_service)):
         try:
             repository_class, service_class = service_registry.get(name)
             repository = repository_class(db_service)
-            return service_class(repository, db_service)
+            return service_class(repository)
         except CustomException as e:
             raise e
         except Exception as e:
@@ -116,13 +78,13 @@ def get_service(name: str):
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/token")
 async def get_current_user(
     token: str = Depends(oauth2_scheme),
-    db_service: DatabaseService = Depends(get_database_service)
+    db_service: DatabaseServiceManager = Depends(get_database_service)
 ):
     """현재 사용자를 가져오는 의존성 함수
 
     Args:
         token (str): OAuth2 토큰
-        db_service (DatabaseService): DatabaseService 객체
+        db_service (DatabaseServiceManager): DatabaseServiceManager 객체
 
     Returns:
         User: 현재 사용자

aiteamutils-0.2.43/aiteamutils/version.py

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

aiteamutils-0.2.41/aiteamutils/version.py

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