aiteamutils 0.2.58__py3-none-any.whl → 0.2.60__py3-none-any.whl

aiteamutils/database.py

@@ -1,207 +1,48 @@
-"""데이터베이스 유틸리티 모듈."""
-from typing import Any, Dict, Optional, Type, List, Union
-from sqlalchemy import select, and_
+#기본 라이브러리
+from typing import TypeVar, Generic, Type, Any, Dict, List, Optional
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+from sqlalchemy import select, and_
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.exc import SQLAlchemyError
 
-from .exceptions import ErrorCode, CustomException
-from .base_model import Base
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
-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
+#패키지 라이브러리
+from .exceptions import ErrorCode, CustomException
 
-    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
-            )
+##################
+# 1. 쿼리 실행 #
+##################
+async def list_entities(
+    session: AsyncSession,
+    model: Type[ModelType],
+    skip: int = 0,
+    limit: int = 100,
+    filters: Optional[Dict[str, Any]] = None,
+    joins: Optional[List[Any]] = None
+) -> List[Dict[str, Any]]:
+    try:
+        query = select(model)
 
-    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
-            )
+        # 필터 조건 적용
+        if filters:
+            conditions = [getattr(model, key) == value for key, value in filters.items()]
+            query = query.where(and_(*conditions))
 
-    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
-            )
+        # 조인 로딩 적용
+        if joins:
+            for join_option in joins:
+                query = query.options(join_option)
 
-    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
-            )
+        # 페이지네이션 적용
+        query = query.limit(limit).offset(skip)
 
-    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
-            )
+        result = await session.execute(query)
+        return result.scalars().unique().all()
+    except SQLAlchemyError as e:
+        raise CustomException(
+            ErrorCode.DB_READ_ERROR,
+            detail=f"{model.__name__}|{str(e)}",
+            source_function="database.list_entities",
+            original_error=e
+        )

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.58"
+__version__ = "0.2.60"

{aiteamutils-0.2.58.dist-info → aiteamutils-0.2.60.dist-info}/METADATA

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

aiteamutils-0.2.60.dist-info/RECORD

@@ -0,0 +1,15 @@
+aiteamutils/__init__.py,sha256=h7iFifWvRlaComsk4VPapRr16YhD19Kp1LuBzLHqdgQ,1170
+aiteamutils/base_model.py,sha256=ODEnjvUVoxQ1RPCfq8-uZTfTADIA4c7Z3E6G4EVsSX0,2708
+aiteamutils/base_repository.py,sha256=ir2ftophKKd_9BQ9B0LbszMqUyFeWkQ1MmFF6WBLcWc,1682
+aiteamutils/base_service.py,sha256=Ncomi5yBUL4oHrMx_J1yUKVrUIYo6YmnYJWAWOIwQx8,2217
+aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
+aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
+aiteamutils/database.py,sha256=MtmrX_pDzKFQM-P3OAfm2mALvhRg-v5JWtGBoiegeU0,1484
+aiteamutils/enums.py,sha256=ipZi6k_QD5-3QV7Yzv7bnL0MjDz-vqfO9I5L77biMKs,632
+aiteamutils/exceptions.py,sha256=_lKWXq_ujNj41xN6LDE149PwsecAP7lgYWbOBbLOntg,15368
+aiteamutils/security.py,sha256=xFVrjttxwXB1TTjqgRQQgQJQohQBT28vuW8FVLjvi-M,10103
+aiteamutils/validators.py,sha256=3N245cZFjgwtW_KzjESkizx5BBUDaJLbbxfNO4WOFZ0,7764
+aiteamutils/version.py,sha256=W0y4-03EvxLX9F9qSLA2iCovEsiyhT86gHqCOTRNhGU,42
+aiteamutils-0.2.60.dist-info/METADATA,sha256=Gu1bs923MYkC_xKFhMKgS8PrSsK2ne2UJRUxBBeflRI,1718
+aiteamutils-0.2.60.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.60.dist-info/RECORD,,

aiteamutils/dependencies.py

@@ -1,227 +0,0 @@
-"""의존성 관리 모듈."""
-from typing import Type, TypeVar, Dict, Any, Optional, Callable, List, AsyncGenerator
-from fastapi import Request, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from jose import jwt, JWTError
-import logging
-
-from .exceptions import CustomException, ErrorCode
-from .config import get_settings
-from .base_service import BaseService
-from .base_repository import BaseRepository
-from .database import DatabaseService
-
-T = TypeVar("T", bound=BaseService)
-R = TypeVar("R", bound=BaseRepository)
-
-_service_registry: Dict[str, Dict[str, Any]] = {}
-_session_provider = None
-
-__all__ = [
-    "setup_dependencies",
-    "register_service",
-    "get_service",
-    "get_current_user"
-]
-
-def setup_dependencies(session_provider: Callable[[], AsyncGenerator[AsyncSession, None]]) -> None:
-    """의존성 설정을 초기화합니다.
-    
-    Args:
-        session_provider: 데이터베이스 세션을 제공하는 함수
-    """
-    global _session_provider
-    _session_provider = session_provider
-
-def register_service(
-    service_class: Type[T],
-    repository_class: Optional[Type[R]] = None,
-    **kwargs
-) -> None:
-    """서비스를 등록합니다.
-    
-    Args:
-        service_class: 서비스 클래스
-        repository_class: 저장소 클래스 (선택)
-        **kwargs: 추가 의존성
-    """
-    if _session_provider is None:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail="Dependencies not initialized",
-            source_function="dependencies.register_service"
-        )
-        
-    service_name = service_class.__name__
-    _service_registry[service_name] = {
-        "service_class": service_class,
-        "repository_class": repository_class,
-        "dependencies": kwargs
-    }
-
-async def _get_service(
-    service_name: str,
-    session: AsyncSession,
-    request: Request
-) -> BaseService:
-    """서비스 인스턴스를 생성합니다.
-    
-    Args:
-        service_name: 서비스 이름
-        session: 데이터베이스 세션
-        request: FastAPI 요청 객체
-        
-    Returns:
-        BaseService: 서비스 인스턴스
-        
-    Raises:
-        CustomException: 서비스 생성 실패 시
-    """
-    try:
-        service_info = _service_registry.get(service_name)
-        if not service_info:
-            raise CustomException(
-                ErrorCode.SERVICE_NOT_FOUND,
-                detail=service_name,
-                source_function="dependencies._get_service"
-            )
-            
-        service_class = service_info["service_class"]
-        repository_class = service_info["repository_class"]
-        dependencies = service_info["dependencies"]
-        
-        # 데이터베이스 서비스 생성
-        db_service = DatabaseService(session=session)
-        
-        # 저장소 인스턴스 생성
-        repository = None
-        if repository_class:
-            repository = repository_class(session=session)
-            
-        # 서비스 인스턴스 생성
-        service = service_class(
-            db=db_service,
-            repository=repository,
-            request=request,
-            **dependencies
-        )
-        
-        return service
-        
-    except CustomException as e:
-        raise e
-    except Exception as e:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail=str(e),
-            source_function="dependencies._get_service",
-            original_error=e
-        )
-
-def get_service(service_name: str) -> Callable:
-    """서비스 의존성을 반환합니다.
-    
-    Args:
-        service_name: 서비스 이름
-        
-    Returns:
-        Callable: 서비스 의존성 함수
-    """
-    if _session_provider is None:
-        raise CustomException(
-            ErrorCode.INTERNAL_ERROR,
-            detail="Dependencies not initialized",
-            source_function="dependencies.get_service"
-        )
-    
-    async def _get_service_dependency(
-        request: Request,
-        session: AsyncSession = Depends(_session_provider)
-    ) -> BaseService:
-        return await _get_service(service_name, session, request)
-    return _get_service_dependency
-
-async def get_current_user(
-    request: Request,
-    session: AsyncSession,
-    auth_service: BaseService = Depends(get_service("AuthService"))
-) -> Dict[str, Any]:
-    """현재 사용자 정보를 반환합니다.
-    
-    Args:
-        request: FastAPI 요청 객체
-        session: 데이터베이스 세션
-        auth_service: 인증 서비스
-        
-    Returns:
-        Dict[str, Any]: 사용자 정보
-        
-    Raises:
-        HTTPException: 인증 실패 시
-    """
-    settings = get_settings()
-    
-    # Authorization 헤더 검증
-    authorization = request.headers.get("Authorization")
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Not authenticated",
-            headers={"WWW-Authenticate": "Bearer"}
-        )
-        
-    token = authorization.split(" ")[1]
-    
-    try:
-        # JWT 토큰 디코딩
-        payload = jwt.decode(
-            token,
-            settings.jwt_secret,
-            algorithms=[settings.jwt_algorithm],
-            issuer=settings.token_issuer,
-            audience=settings.token_audience
-        )
-        
-        # 토큰 타입 검증
-        token_type = payload.get("token_type")
-        if token_type != "access":
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid token type",
-                headers={"WWW-Authenticate": "Bearer"}
-            )
-            
-        # 사용자 조회
-        user_ulid = payload.get("user_ulid")
-        if not user_ulid:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid token payload",
-                headers={"WWW-Authenticate": "Bearer"}
-            )
-            
-        user = await auth_service.get_by_ulid(user_ulid)
-        if not user:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="User not found",
-                headers={"WWW-Authenticate": "Bearer"}
-            )
-            
-        return user
-        
-    except JWTError as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=str(e),
-            headers={"WWW-Authenticate": "Bearer"}
-        )
-    except HTTPException as e:
-        raise e
-    except Exception as e:
-        logging.error(f"Error in get_current_user: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Authentication failed",
-            headers={"WWW-Authenticate": "Bearer"}
-        )

aiteamutils-0.2.58.dist-info/RECORD

@@ -1,16 +0,0 @@
-aiteamutils/__init__.py,sha256=U9UEyU0AqpLZzbPJiBvwDEh-s2405y1IeWZ0zCqFSl0,1307
-aiteamutils/base_model.py,sha256=ODEnjvUVoxQ1RPCfq8-uZTfTADIA4c7Z3E6G4EVsSX0,2708
-aiteamutils/base_repository.py,sha256=vqsundoN0h7FVvgqTBEnnJNMcFpvMK0s_nxBWdIYg-U,7846
-aiteamutils/base_service.py,sha256=s2AcA-6_ogOQKgt2xf_3AG2s6tqBceU4nJoXO1II7S8,24588
-aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
-aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
-aiteamutils/database.py,sha256=x0x5gnSyGfwo_klL9O65RnGOQID6c9tH2miwFveVyoE,6326
-aiteamutils/dependencies.py,sha256=UjHGgee4qKxPwHJnfMZ3YKB7m7UQNIvKNr7IdOx590c,6899
-aiteamutils/enums.py,sha256=ipZi6k_QD5-3QV7Yzv7bnL0MjDz-vqfO9I5L77biMKs,632
-aiteamutils/exceptions.py,sha256=_lKWXq_ujNj41xN6LDE149PwsecAP7lgYWbOBbLOntg,15368
-aiteamutils/security.py,sha256=xFVrjttxwXB1TTjqgRQQgQJQohQBT28vuW8FVLjvi-M,10103
-aiteamutils/validators.py,sha256=3N245cZFjgwtW_KzjESkizx5BBUDaJLbbxfNO4WOFZ0,7764
-aiteamutils/version.py,sha256=57HkAV8pVrmV03eTVINw5qTQURkXwGPl2H--uJC4OWs,42
-aiteamutils-0.2.58.dist-info/METADATA,sha256=yULGE3mtpwvWXzHDczGJfqu52urFzknJhm5V9PgCOGc,1718
-aiteamutils-0.2.58.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.58.dist-info/RECORD,,