aiteamutils 0.2.37__tar.gz → 0.2.39__tar.gz

{aiteamutils-0.2.37 → aiteamutils-0.2.39}/PKG-INFO

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

{aiteamutils-0.2.37 → aiteamutils-0.2.39}/aiteamutils/database.py

@@ -9,6 +9,7 @@ from sqlalchemy import or_
 from fastapi import Request, Depends
 from ulid import ULID
 from sqlalchemy.sql import Select
+import logging
 
 from .exceptions import ErrorCode, CustomException
 from .base_model import Base, BaseColumn
@@ -31,18 +32,33 @@ def get_database_service() -> 'DatabaseService':
     if _database_service is None:
         raise CustomException(
             ErrorCode.DB_CONNECTION_ERROR,
-            detail="database_service",
+            detail="Database service is not initialized. Call init_database_service() first.",
             source_function="get_database_service"
         )
     return _database_service
 
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """데이터베이스 세션을 생성하고 반환하는 비동기 제너레이터."""
+    """데이터베이스 세션을 생성하고 반환하는 비동기 제너레이터.
+    
+    Yields:
+        AsyncSession: 데이터베이스 세션
+        
+    Raises:
+        CustomException: 세션 생성 실패 시
+    """
     db_service = get_database_service()
-    async with db_service.get_session() as session:
-        try:
+    try:
+        async with db_service.get_session() as session:
             yield session
-        finally:
+    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()
 
 def get_database_session(db: AsyncSession = Depends(get_db)) -> 'DatabaseService':
@@ -921,14 +937,40 @@ def init_database_service(
         
     Returns:
         DatabaseService: 초기화된 데이터베이스 서비스 인스턴스
+        
+    Raises:
+        CustomException: 데이터베이스 초기화 실패 시
     """
-    global _database_service
-    _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
-    )
-    return _database_service
+    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 _database_service.engine:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Database engine initialization failed",
+                source_function="init_database_service"
+            )
+            
+        logging.info("Database service initialized successfully")
+        return _database_service
+    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",
+            original_error=e
+        )

{aiteamutils-0.2.37 → aiteamutils-0.2.39}/aiteamutils/dependencies.py

@@ -3,6 +3,7 @@ from fastapi import Depends, status
 from fastapi.security import OAuth2PasswordBearer
 from jose import JWTError, jwt
 from sqlalchemy.ext.asyncio import AsyncSession
+import logging
 
 from .database import DatabaseService, get_database_service, get_db
 from .exceptions import CustomException, ErrorCode
@@ -12,10 +13,12 @@ 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):
         """서비스를 레지스트리에 등록
@@ -28,13 +31,28 @@ class ServiceRegistry:
         Raises:
             CustomException: 이미 등록된 서비스인 경우
         """
-        if name in self._services:
+        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"service|{name}",
-                source_function="ServiceRegistry.register"
+                detail=f"Failed to register service '{name}': {str(e)}",
+                source_function="ServiceRegistry.register",
+                original_error=e
             )
-        self._services[name] = (repository_class, service_class)
 
     def get(self, name: str) -> Tuple[Type, Type]:
         """등록된 서비스를 조회
@@ -50,11 +68,19 @@ class ServiceRegistry:
         """
         if name not in self._services:
             raise CustomException(
-                ErrorCode.NOT_FOUND,
-                detail=f"service|{name}",
+                ErrorCode.SERVICE_NOT_REGISTERED,
+                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()
@@ -67,11 +93,44 @@ def get_service(name: str):
 
     Returns:
         Callable: 서비스 인스턴스를 반환하는 의존성 함수
+        
+    Raises:
+        CustomException: 서비스 생성 실패 시
     """
     def _get_service(db_service: DatabaseService = Depends(get_database_service)):
-        repository_class, service_class = service_registry.get(name)
-        repository = repository_class(db_service)
-        return service_class(repository, db_service)
+        try:
+            # 서비스 레지스트리에서 클래스 조회
+            try:
+                repository_class, service_class = service_registry.get(name)
+            except CustomException as e:
+                raise CustomException(
+                    ErrorCode.SERVICE_NOT_REGISTERED,
+                    detail=f"Service '{name}' is not registered",
+                    source_function="dependencies.get_service",
+                    original_error=e
+                )
+            
+            # 서비스 인스턴스 생성
+            try:
+                repository = repository_class(db_service)
+                return service_class(repository)
+            except Exception as e:
+                raise CustomException(
+                    ErrorCode.INTERNAL_ERROR,
+                    detail=f"Failed to create service instance for '{name}': {str(e)}",
+                    source_function="dependencies.get_service",
+                    original_error=e
+                )
+                
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=f"Unexpected error while creating service '{name}': {str(e)}",
+                source_function="dependencies.get_service",
+                original_error=e
+            )
     return _get_service
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/token")

{aiteamutils-0.2.37 → aiteamutils-0.2.39}/aiteamutils/exceptions.py

@@ -1,6 +1,6 @@
 """예외 처리 모듈."""
 import logging
-from enum import Enum
+from enum import Enum, IntEnum
 from typing import Dict, Any, Optional, Tuple, List
 from fastapi import Request
 from fastapi.responses import JSONResponse
@@ -69,6 +69,7 @@ class ErrorCode(Enum):
     NOT_FOUND = ErrorResponse(5001, "GENERAL_NOT_FOUND", 404, "리소스를 찾을 수 없습니다")
     INTERNAL_ERROR = ErrorResponse(5002, "GENERAL_INTERNAL_ERROR", 500, "내부 서버 오류")
     SERVICE_UNAVAILABLE = ErrorResponse(5003, "GENERAL_SERVICE_UNAVAILABLE", 503, "서비스를 사용할 수 없습니다")
+    SERVICE_NOT_REGISTERED = ErrorResponse(5003, "GENERAL_SERVICE_UNAVAILABLE", 503, "서비스를 사용할 수 없습니다")
 
 class CustomException(Exception):
     """사용자 정의 예외 클래스"""

aiteamutils-0.2.39/aiteamutils/version.py

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

aiteamutils-0.2.39/startup.py

@@ -0,0 +1,54 @@
+async def startup_event() -> None:
+    """Application startup event handler."""
+    try:
+        # 1. 설정 및 DB 초기화
+        init_settings(
+            jwt_secret=settings.JWT_SECRET,
+            jwt_algorithm=settings.JWT_ALGORITHM,
+            db_url=settings.CORE_DB_URL,
+            db_echo=settings.DB_ECHO,
+            db_pool_size=settings.DB_POOL_SIZE,
+            db_max_overflow=settings.DB_MAX_OVERFLOW,
+            db_pool_timeout=settings.DB_POOL_TIMEOUT,
+            db_pool_recycle=settings.DB_POOL_RECYCLE
+        )
+        db_service = get_database_service()
+
+        if not db_service or not db_service.engine:
+            raise RuntimeError("데이터베이스 서비스 초기화 실패")
+            
+        # 2. DB 연결 테스트
+        async with db_service.engine.begin() as conn:
+            await conn.run_sync(lambda _: None)
+            logging.info("데이터베이스 연결 성공")
+            
+        # 3. 테이블 생성
+        async with db_service.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+            logging.info("데이터베이스 테이블 생성 완료")
+        
+        # 4. 서비스 등록
+        register_services()
+        service_registry.set_initialized()  # 서비스 등록 완료 표시
+
+        logging.info("서비스 등록 완료")
+        
+    except Exception as e:
+        logging.error(f"애플리케이션 시작 실패: {str(e)}")
+        raise RuntimeError(f"애플리케이션 시작 실패: {str(e)}")
+
+async def shutdown_event() -> None:
+    """Application shutdown event handler."""
+    try:
+        # 1. 서비스 레지스트리 초기화
+        service_registry.clear()
+        logging.info("서비스 레지스트리 초기화 완료")
+        
+        # 2. 데이터베이스 연결 종료
+        db_service = get_database_service()
+        if db_service and db_service.engine:
+            await db_service.engine.dispose()
+            logging.info("데이터베이스 연결 종료")
+    except Exception as e:
+        logging.error(f"애플리케이션 종료 중 오류 발생: {str(e)}")
+        raise 

aiteamutils-0.2.37/aiteamutils/version.py

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