yeonjae-universal-schedule-manager 1.0.1__py3-none-any.whl

universal_schedule_manager/__init__.py

@@ -0,0 +1,3 @@
+"""Universal Schedule Manager - 주기적 작업과 백그라운드 태스크를 관리하고 실행하는 범용 모듈"""
+
+__version__ = "1.0.0"

universal_schedule_manager/exceptions.py

@@ -0,0 +1,69 @@
+"""
+ScheduleManager 모듈의 예외 클래스
+
+스케줄링 작업과 관련된 모든 예외를 정의합니다.
+"""
+
+
+class ScheduleManagerException(Exception):
+    """ScheduleManager 기본 예외"""
+    def __init__(self, message: str, details: dict = None):
+        self.message = message
+        self.details = details or {}
+        super().__init__(self.message)
+
+
+class JobNotFoundException(ScheduleManagerException):
+    """작업을 찾을 수 없는 경우"""
+    def __init__(self, job_id: str):
+        message = f"Job not found: {job_id}"
+        super().__init__(message, {"job_id": job_id})
+
+
+class SchedulerNotRunningException(ScheduleManagerException):
+    """스케줄러가 실행되지 않은 경우"""
+    def __init__(self):
+        message = "Scheduler is not running"
+        super().__init__(message)
+
+
+class JobExecutionException(ScheduleManagerException):
+    """작업 실행 중 오류가 발생한 경우"""
+    def __init__(self, job_id: str, error: Exception):
+        message = f"Job execution failed: {job_id}"
+        super().__init__(message, {
+            "job_id": job_id,
+            "error_type": type(error).__name__,
+            "error_message": str(error)
+        })
+
+
+class InvalidScheduleConfigException(ScheduleManagerException):
+    """잘못된 스케줄 설정인 경우"""
+    def __init__(self, config_field: str, reason: str):
+        message = f"Invalid schedule config - {config_field}: {reason}"
+        super().__init__(message, {
+            "config_field": config_field,
+            "reason": reason
+        })
+
+
+class InvalidScheduleException(ScheduleManagerException):
+    """잘못된 스케줄 예외"""
+    def __init__(self, schedule_type: str, expression: str):
+        message = f"Invalid schedule type '{schedule_type}' with expression '{expression}'"
+        super().__init__(message, {
+            "schedule_type": schedule_type,
+            "expression": expression
+        })
+
+
+class DataRetrievalException(ScheduleManagerException):
+    """데이터 조회 중 오류가 발생한 경우"""
+    def __init__(self, operation: str, error: Exception):
+        message = f"Data retrieval failed during {operation}"
+        super().__init__(message, {
+            "operation": operation,
+            "error_type": type(error).__name__,
+            "error_message": str(error)
+        }) 

universal_schedule_manager/models.py

@@ -0,0 +1,150 @@
+"""
+ScheduleManager 모듈의 데이터 모델
+
+스케줄링 작업과 관련된 모든 데이터 구조를 정의합니다.
+"""
+
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional, Any
+from pydantic import BaseModel, Field
+
+
+class ScheduleType(str, Enum):
+    """스케줄 타입"""
+    CRON = "cron"
+    INTERVAL = "interval"
+    ONE_TIME = "one_time"
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    MONTHLY = "monthly"
+    CUSTOM = "custom"
+
+
+class ScheduleStatus(str, Enum):
+    """스케줄 상태"""
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    PAUSED = "paused"
+
+
+class JobStatus(str, Enum):
+    """작업 상태"""
+    SCHEDULED = "scheduled"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    PAUSED = "paused"
+
+
+class ScheduleConfig(BaseModel):
+    """스케줄 설정"""
+    schedule_type: ScheduleType = Field(..., description="스케줄 타입")
+    expression: str = Field(..., description="스케줄 표현식 (cron, interval 등)")
+    timezone: str = Field(default="Asia/Seoul", description="시간대 설정")
+    max_instances: int = Field(default=1, description="최대 동시 실행 인스턴스 수")
+    replace_existing: bool = Field(default=True, description="기존 작업 교체 여부")
+
+
+class JobExecutionInfo(BaseModel):
+    """작업 실행 정보"""
+    timestamp: datetime = Field(..., description="실행 시간")
+    status: JobStatus = Field(..., description="실행 상태")
+    error_message: Optional[str] = Field(None, description="에러 메시지")
+    execution_time_seconds: Optional[float] = Field(None, description="실행 시간(초)")
+
+
+class ScheduleJobInfo(BaseModel):
+    """스케줄 작업 정보"""
+    job_id: str = Field(..., description="작업 ID")
+    name: str = Field(..., description="작업 이름")
+    status: JobStatus = Field(..., description="작업 상태")
+    next_run_time: Optional[datetime] = Field(None, description="다음 실행 시간")
+    last_execution: Optional[JobExecutionInfo] = Field(None, description="마지막 실행 결과")
+    schedule_config: ScheduleConfig = Field(..., description="스케줄 설정")
+
+
+class CommitData(BaseModel):
+    """커밋 데이터"""
+    commit_id: str = Field(..., description="커밋 ID")
+    message: str = Field(..., description="커밋 메시지")
+    author: str = Field(..., description="작성자")
+    timestamp: datetime = Field(..., description="커밋 시간")
+    repository: str = Field(..., description="저장소 이름")
+    branch: str = Field(..., description="브랜치명")
+
+
+class DiffData(BaseModel):
+    """Diff 데이터"""
+    file_path: str = Field(..., description="파일 경로")
+    additions: int = Field(..., description="추가된 라인 수")
+    deletions: int = Field(..., description="삭제된 라인 수")
+    changes: str = Field(..., description="변경 내용")
+    complexity_score: Optional[float] = Field(None, description="복잡도 점수")
+    language: Optional[str] = Field(None, description="프로그래밍 언어")
+
+
+class DeveloperSummary(BaseModel):
+    """개발자 요약 데이터"""
+    developer_id: str = Field(..., description="개발자 ID")
+    developer_name: str = Field(..., description="개발자 이름")
+    commits: List[CommitData] = Field(default_factory=list, description="커밋 목록")
+    diffs: List[DiffData] = Field(default_factory=list, description="diff 목록")
+    statistics: Dict[str, int] = Field(default_factory=dict, description="통계 정보")
+    date_range: Dict[str, str] = Field(..., description="조회 날짜 범위")
+
+
+class ScheduleExecutionResult(BaseModel):
+    """스케줄 실행 결과"""
+    job_id: str = Field(..., description="작업 ID")
+    execution_time: datetime = Field(..., description="실행 시간")
+    success: bool = Field(..., description="성공 여부")
+    processed_developers: List[str] = Field(default_factory=list, description="처리된 개발자 목록")
+    error_message: Optional[str] = Field(None, description="에러 메시지")
+    performance_metrics: Dict[str, float] = Field(default_factory=dict, description="성능 메트릭")
+    total_execution_time_seconds: float = Field(..., description="총 실행 시간(초)")
+
+
+class DailyReportRequest(BaseModel):
+    """일일 리포트 요청"""
+    target_date: Optional[datetime] = Field(None, description="대상 날짜 (기본값: 어제)")
+    include_statistics: bool = Field(default=True, description="통계 포함 여부")
+    developer_filters: Optional[List[str]] = Field(None, description="개발자 필터")
+    repository_filters: Optional[List[str]] = Field(None, description="저장소 필터")
+
+
+class ScheduleRequest(BaseModel):
+    """스케줄 요청"""
+    name: str = Field(..., description="스케줄 이름")
+    description: str = Field(..., description="스케줄 설명")
+    schedule_config: ScheduleConfig = Field(..., description="스케줄 설정")
+    job_data: Dict[str, Any] = Field(default_factory=dict, description="작업 데이터")
+    enabled: bool = Field(default=True, description="활성화 여부")
+
+
+class ScheduleResponse(BaseModel):
+    """스케줄 응답"""
+    schedule_id: str = Field(..., description="스케줄 ID")
+    name: str = Field(..., description="스케줄 이름")
+    status: ScheduleStatus = Field(..., description="스케줄 상태")
+    next_run_time: Optional[datetime] = Field(None, description="다음 실행 시간")
+    created_at: datetime = Field(..., description="생성 시간")
+    updated_at: datetime = Field(..., description="수정 시간")
+
+
+class JobExecution(BaseModel):
+    """작업 실행"""
+    job_id: str = Field(..., description="작업 ID")
+    schedule_id: str = Field(..., description="스케줄 ID")
+    started_at: datetime = Field(..., description="시작 시간")
+    ended_at: Optional[datetime] = Field(None, description="종료 시간")
+    status: str = Field(..., description="실행 상태")
+    result: Optional[Dict[str, Any]] = Field(None, description="실행 결과")
+
+
+class WeeklySummaryRequest(BaseModel):
+    """주간 요약 요청"""
+    start_date: Optional[datetime] = Field(None, description="시작 날짜")
+    end_date: Optional[datetime] = Field(None, description="종료 날짜")
+    include_trends: bool = Field(default=True, description="트렌드 분석 포함 여부")
+    team_grouping: bool = Field(default=False, description="팀별 그룹핑 여부") 

universal_schedule_manager/service.py

@@ -0,0 +1,368 @@
+"""
+ScheduleManager 서비스
+
+매일 오전 8시에 데이터 분석 및 알림 작업을 예약하고 실행하는 범용 스케줄러입니다.
+APScheduler를 사용하여 안정적인 스케줄링을 제공하며, 스케줄 상태 모니터링 및 실패 처리를 지원합니다.
+"""
+
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Callable, Any
+
+try:
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+    from apscheduler.triggers.cron import CronTrigger
+    from apscheduler.jobstores.memory import MemoryJobStore
+    from apscheduler.executors.asyncio import AsyncIOExecutor
+    APSCHEDULER_AVAILABLE = True
+except ImportError:
+    APSCHEDULER_AVAILABLE = False
+
+from .models import (
+    ScheduleConfig,
+    JobStatus,
+    ScheduleJobInfo,
+    ScheduleExecutionResult,
+    DeveloperSummary,
+    JobExecutionInfo,
+    DailyReportRequest,
+    WeeklySummaryRequest
+)
+from .exceptions import (
+    ScheduleManagerException,
+    JobNotFoundException,
+    SchedulerNotRunningException,
+    JobExecutionException
+)
+
+
+class MockScheduler:
+    """APScheduler가 없을 때 사용하는 Mock 스케줄러"""
+    
+    def __init__(self, timezone='Asia/Seoul'):
+        self.timezone = timezone
+        self.jobs = {}
+        self.running = False
+        self.logger = logging.getLogger(__name__)
+    
+    def add_job(self, func, trigger=None, id=None, name=None, **kwargs):
+        """Mock job 추가"""
+        job_info = {
+            'id': id,
+            'name': name,
+            'func': func,
+            'trigger': trigger,
+            'kwargs': kwargs
+        }
+        self.jobs[id] = job_info
+        self.logger.info(f"Mock job added: {id}")
+        return job_info
+    
+    def start(self):
+        """Mock 스케줄러 시작"""
+        self.running = True
+        self.logger.info("Mock scheduler started")
+    
+    def shutdown(self, wait=True):
+        """Mock 스케줄러 중지"""
+        self.running = False
+        self.logger.info("Mock scheduler stopped")
+    
+    def get_job(self, job_id):
+        """Mock job 조회"""
+        return self.jobs.get(job_id)
+    
+    def remove_job(self, job_id):
+        """Mock job 제거"""
+        if job_id in self.jobs:
+            del self.jobs[job_id]
+            self.logger.info(f"Mock job removed: {job_id}")
+
+
+class ScheduleManagerService:
+    """스케줄 관리 서비스"""
+    
+    def __init__(self, timezone: str = "Asia/Seoul"):
+        """
+        ScheduleManagerService 초기화
+        
+        Args:
+            timezone: 시간대 설정 (기본값: Asia/Seoul)
+        """
+        self.timezone = timezone
+        self.logger = logging.getLogger(__name__)
+        self.jobs: Dict[str, ScheduleJobInfo] = {}
+        self.execution_history: Dict[str, List[JobExecutionInfo]] = {}
+        
+        # APScheduler 설정 또는 Mock 사용
+        if APSCHEDULER_AVAILABLE:
+            jobstores = {
+                'default': MemoryJobStore()
+            }
+            executors = {
+                'default': AsyncIOExecutor()
+            }
+            job_defaults = {
+                'coalesce': False,
+                'max_instances': 3
+            }
+            
+            self.scheduler = AsyncIOScheduler(
+                jobstores=jobstores,
+                executors=executors,
+                job_defaults=job_defaults,
+                timezone=timezone
+            )
+            self.logger.info("APScheduler initialized")
+        else:
+            self.scheduler = MockScheduler(timezone)
+            self.logger.warning("APScheduler not available, using mock scheduler")
+    
+    async def start(self) -> None:
+        """
+        스케줄러 시작 및 기본 작업 등록
+        
+        메모리에 따라 매일 08:00 Asia/Seoul 시간대에 일일 요약 스케줄러를 등록합니다.
+        """
+        try:
+            # 스케줄러 시작
+            self.scheduler.start()
+            
+            # 기본 일일 리포트 작업 등록 (매일 08:00 Asia/Seoul)
+            await self.add_daily_report_job()
+            
+            self.logger.info("ScheduleManager started successfully")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start ScheduleManager: {e}")
+            raise ScheduleManagerException(f"Failed to start scheduler: {str(e)}")
+    
+    async def stop(self) -> None:
+        """스케줄러 중지"""
+        try:
+            if hasattr(self.scheduler, 'running') and self.scheduler.running:
+                self.scheduler.shutdown(wait=True)
+                self.logger.info("ScheduleManager stopped")
+        except Exception as e:
+            self.logger.error(f"Error stopping scheduler: {e}")
+    
+    async def add_daily_report_job(self) -> str:
+        """
+        일일 리포트 작업 등록 (매일 08:00 Asia/Seoul)
+        
+        Returns:
+            str: 등록된 작업 ID
+        """
+        config = ScheduleConfig(
+            schedule_time="0 8 * * *",  # 매일 오전 8시
+            job_id="daily_developer_report",
+            function_name="trigger_daily_report",
+            timezone="Asia/Seoul"
+        )
+        
+        return await self.add_job(config, self.trigger_daily_report)
+    
+    async def add_job(
+        self, 
+        config: ScheduleConfig, 
+        func: Callable,
+        **kwargs
+    ) -> str:
+        """
+        새로운 스케줄 작업 추가
+        
+        Args:
+            config: 스케줄 설정
+            func: 실행할 함수
+            **kwargs: 추가 인자
+            
+        Returns:
+            str: 등록된 작업 ID
+        """
+        try:
+            # 설정 검증
+            self._validate_schedule_config(config)
+            
+            # APScheduler에 작업 등록
+            if APSCHEDULER_AVAILABLE:
+                job = self.scheduler.add_job(
+                    func=func,
+                    trigger=CronTrigger.from_crontab(config.schedule_time, timezone=config.timezone),
+                    id=config.job_id,
+                    name=f"{config.function_name}_{config.job_id}",
+                    replace_existing=config.replace_existing,
+                    max_instances=config.max_instances,
+                    **kwargs
+                )
+                next_run_time = job.next_run_time
+            else:
+                # Mock 스케줄러 사용
+                job = self.scheduler.add_job(
+                    func=func,
+                    trigger=config.schedule_time,
+                    id=config.job_id,
+                    name=f"{config.function_name}_{config.job_id}",
+                    **kwargs
+                )
+                next_run_time = None
+            
+            # 작업 정보 저장
+            job_info = ScheduleJobInfo(
+                job_id=config.job_id,
+                name=f"{config.function_name}_{config.job_id}",
+                status=JobStatus.SCHEDULED,
+                next_run_time=next_run_time,
+                schedule_config=config
+            )
+            
+            self.jobs[config.job_id] = job_info
+            self.execution_history[config.job_id] = []
+            
+            self.logger.info(f"Job added successfully: {config.job_id}")
+            return config.job_id
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add job {config.job_id}: {e}")
+            raise ScheduleManagerException(f"Failed to add job: {str(e)}")
+    
+    def get_job_status(self, job_id: str) -> ScheduleJobInfo:
+        """
+        작업 상태 조회
+        
+        Args:
+            job_id: 작업 ID
+            
+        Returns:
+            ScheduleJobInfo: 작업 정보
+        """
+        if job_id not in self.jobs:
+            raise JobNotFoundException(job_id)
+        
+        return self.jobs[job_id]
+    
+    def list_jobs(self) -> List[ScheduleJobInfo]:
+        """
+        모든 작업 목록 조회
+        
+        Returns:
+            List[ScheduleJobInfo]: 작업 목록
+        """
+        return list(self.jobs.values())
+    
+    async def trigger_daily_report(self) -> ScheduleExecutionResult:
+        """
+        일일 개발자 활동 리포트 생성
+        
+        Returns:
+            ScheduleExecutionResult: 실행 결과
+        """
+        job_id = "daily_developer_report"
+        start_time = datetime.now()
+        
+        try:
+            self.logger.info("Starting daily report generation")
+            
+            # 작업 상태 업데이트
+            if job_id in self.jobs:
+                self.jobs[job_id].status = JobStatus.RUNNING
+            
+            # 어제 날짜 범위 계산
+            yesterday = datetime.now() - timedelta(days=1)
+            date_range = {
+                "start": yesterday.replace(hour=0, minute=0, second=0).isoformat(),
+                "end": yesterday.replace(hour=23, minute=59, second=59).isoformat()
+            }
+            
+            # DataRetriever를 통한 데이터 조회는 실제 구현 시 추가
+            # 현재는 기본 구조만 구현
+            processed_developers = []
+            
+            # 실행 시간 계산
+            execution_time = (datetime.now() - start_time).total_seconds()
+            
+            # 실행 결과 생성
+            result = ScheduleExecutionResult(
+                job_id=job_id,
+                execution_time=start_time,
+                success=True,
+                processed_developers=processed_developers,
+                performance_metrics={
+                    "execution_time_seconds": execution_time,
+                    "processed_count": len(processed_developers)
+                },
+                total_execution_time_seconds=execution_time
+            )
+            
+            # 실행 기록 저장
+            execution_info = JobExecutionInfo(
+                timestamp=start_time,
+                status=JobStatus.COMPLETED,
+                execution_time_seconds=execution_time
+            )
+            
+            if job_id in self.execution_history:
+                self.execution_history[job_id].append(execution_info)
+            
+            # 작업 상태 업데이트
+            if job_id in self.jobs:
+                self.jobs[job_id].status = JobStatus.COMPLETED
+                self.jobs[job_id].last_execution = execution_info
+            
+            self.logger.info(f"Daily report completed in {execution_time:.2f}s")
+            return result
+            
+        except Exception as e:
+            # 실행 실패 처리
+            execution_time = (datetime.now() - start_time).total_seconds()
+            
+            execution_info = JobExecutionInfo(
+                timestamp=start_time,
+                status=JobStatus.FAILED,
+                error_message=str(e),
+                execution_time_seconds=execution_time
+            )
+            
+            if job_id in self.execution_history:
+                self.execution_history[job_id].append(execution_info)
+            
+            if job_id in self.jobs:
+                self.jobs[job_id].status = JobStatus.FAILED
+                self.jobs[job_id].last_execution = execution_info
+            
+            self.logger.error(f"Daily report generation failed: {e}")
+            
+            return ScheduleExecutionResult(
+                job_id=job_id,
+                execution_time=start_time,
+                success=False,
+                error_message=str(e),
+                total_execution_time_seconds=execution_time
+            )
+    
+    def _validate_schedule_config(self, config: ScheduleConfig) -> None:
+        """
+        스케줄 설정 검증
+        
+        Args:
+            config: 스케줄 설정
+            
+        Raises:
+            InvalidScheduleConfigException: 잘못된 설정인 경우
+        """
+        if not config.job_id:
+            raise InvalidScheduleConfigException("job_id", "Job ID is required")
+        
+        if not config.function_name:
+            raise InvalidScheduleConfigException("function_name", "Function name is required")
+        
+        if not config.schedule_time:
+            raise InvalidScheduleConfigException("schedule_time", "Schedule time is required")
+        
+        # Cron 표현식 기본 검증 (5개 필드)
+        cron_parts = config.schedule_time.split()
+        if len(cron_parts) != 5:
+            raise InvalidScheduleConfigException(
+                "schedule_time", 
+                "Invalid cron format. Expected 5 fields: minute hour day month day_of_week"
+            ) 

universal_schedule_manager/tasks.py

@@ -0,0 +1,330 @@
+"""Celery tasks for schedule manager."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Any
+
+from celery import shared_task
+
+from modules.data_retriever.service import DataRetrieverService
+from universal_llm_service import LLMService, LLMInput, LLMProvider, ModelConfig
+from modules.data_aggregator.service import DataAggregatorService
+from modules.prompt_builder.service import PromptBuilderService
+from universal_notification_service import NotificationService
+# Simplified logging for standalone operation
+def log_module_io(module_name: str, operation: str, data: dict):
+    pass
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task(name="schedule_manager.daily_summary_task")
+def daily_summary_task() -> Dict[str, Any]:
+    """
+    매일 오전 8시에 실행되는 일일 개발자 활동 요약 작업
+    
+    기획서 준수 흐름:
+    ScheduleManager → DataRetriever → DataAggregator → PromptBuilder → LLMService → NotificationService
+    
+    Returns:
+        Dict[str, Any]: 실행 결과
+    """
+    start_time = datetime.now()
+    
+    try:
+        logger.info("🌅 Starting daily developer summary at 08:00 Asia/Seoul")
+        
+        # 어제 날짜 범위 계산 (Asia/Seoul 기준)
+        from zoneinfo import ZoneInfo
+        seoul_tz = ZoneInfo("Asia/Seoul")
+        now_seoul = datetime.now(seoul_tz)
+        yesterday_start = (now_seoul - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+        yesterday_end = (now_seoul - timedelta(days=1)).replace(hour=23, minute=59, second=59, microsecond=999999)
+        
+        logger.info(f"📅 Processing data for: {yesterday_start.strftime('%Y-%m-%d')} (Asia/Seoul)")
+        
+        # 1️⃣ DataRetriever: 어제 데이터 조회
+        logger.info("📊 DataRetriever: Starting data retrieval")
+        
+        log_module_io("DataRetriever", "INPUT", metadata={
+            "operation": "get_daily_summary",
+            "target_date": yesterday_start.isoformat(),
+            "timezone": "Asia/Seoul"
+        })
+        
+        data_retriever = DataRetrieverService()
+        retrieved_data = data_retriever.get_daily_summary(target_date=yesterday_start)
+        
+        log_module_io("DataRetriever", "OUTPUT", output_data=retrieved_data, metadata={
+            "commits_found": len(retrieved_data.commits),
+            "developers_count": len(set(commit.author for commit in retrieved_data.commits)),
+            "query_time": retrieved_data.metadata.query_time_seconds if retrieved_data.metadata else 0
+        })
+        
+        logger.info(
+            "✅ DataRetriever: Found %d records from daily summary",
+            len(retrieved_data.commits)
+        )
+        
+        # 데이터가 없으면 종료
+        if not retrieved_data.commits:
+            logger.info("📭 No data found for yesterday. Skipping daily summary.")
+            return {
+                "success": True,
+                "message": "No data found for yesterday",
+                "execution_time_seconds": (datetime.now() - start_time).total_seconds()
+            }
+        
+        # 2️⃣ DataAggregator: 개발자별 활동 집계
+        logger.info("🔢 DataAggregator: Starting data aggregation")
+        
+        # 데이터를 AggregationInput 형태로 변환
+        from modules.data_aggregator.models import AggregationInput, CommitData, DiffInfo, DateRange
+        
+        commits = []
+        for commit_info in retrieved_data.commits:
+            # CommitInfo를 CommitData로 변환
+            commit_data = CommitData(
+                commit_id=commit_info.commit_hash,
+                author=commit_info.author,
+                author_email=commit_info.author_email,
+                timestamp=commit_info.timestamp,
+                message=commit_info.message,
+                repository=commit_info.repository,
+                branch=commit_info.branch,
+                diff_info=[]  # 기본값
+            )
+            commits.append(commit_data)
+        
+        # DateRange를 문자열 형식으로 생성
+        date_range = DateRange(
+            start=yesterday_start.strftime('%Y-%m-%d'),
+            end=yesterday_end.strftime('%Y-%m-%d')
+        )
+        
+        aggregation_input = AggregationInput(
+            commits=commits,
+            date_range=date_range
+        )
+        
+        log_module_io("DataAggregator", "INPUT", input_data=aggregation_input, metadata={
+            "operation": "aggregate_data",
+            "input_commits_count": len(commits)
+        })
+        
+        data_aggregator = DataAggregatorService()
+        # async 메서드를 동기적으로 실행
+        import asyncio
+        try:
+            # 이미 이벤트 루프가 실행 중인 경우 새 루프 생성
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, data_aggregator.aggregate_data(aggregation_input))
+                    aggregated_data = future.result()
+            else:
+                aggregated_data = asyncio.run(data_aggregator.aggregate_data(aggregation_input))
+        except RuntimeError:
+            # 이벤트 루프가 없는 경우
+            aggregated_data = asyncio.run(data_aggregator.aggregate_data(aggregation_input))
+        
+        log_module_io("DataAggregator", "OUTPUT", output_data=aggregated_data, metadata={
+            "developers_processed": len(aggregated_data.developer_stats),
+            "repositories_processed": len(aggregated_data.repository_stats),
+            "time_analysis_completed": aggregated_data.time_analysis is not None,
+            "complexity_metrics_completed": aggregated_data.complexity_metrics is not None
+        })
+        
+        logger.info(
+            "✅ DataAggregator: Processed %d developers, %d repositories",
+            len(aggregated_data.developer_stats),
+            len(aggregated_data.repository_stats)
+        )
+        
+        # 3️⃣ PromptBuilder: LLM용 프롬프트 생성
+        logger.info("📝 PromptBuilder: Starting prompt generation")
+        
+        log_module_io("PromptBuilder", "INPUT", input_data=aggregated_data, metadata={
+            "operation": "build_daily_summary_prompt",
+            "template_type": "daily_developer_summary",
+            "language": "korean"
+        })
+        
+        prompt_builder = PromptBuilderService()
+        
+        # 전체 개발자 목록에서 첫 번째 개발자를 대상으로 하거나, 
+        # 개발자가 없으면 "전체 팀"으로 설정
+        if aggregated_data.developer_stats:
+            # 첫 번째 개발자 선택
+            first_developer = list(aggregated_data.developer_stats.values())[0]
+            target_developer = first_developer.developer
+        else:
+            target_developer = "개발팀"
+        
+        # AggregationResult를 딕셔너리로 변환
+        aggregated_dict = {
+            "developer_stats": {
+                email: {
+                    "developer": stats.developer,
+                    "commit_count": stats.commit_count,
+                    "lines_added": stats.lines_added,
+                    "lines_deleted": stats.lines_deleted,
+                    "files_changed": stats.files_changed,
+                    "languages_used": stats.languages_used,
+                    "avg_complexity": stats.avg_complexity
+                }
+                for email, stats in aggregated_data.developer_stats.items()
+            }
+        }
+        
+        prompt_result = prompt_builder.build_daily_summary_prompt(aggregated_dict, target_developer)
+        
+        log_module_io("PromptBuilder", "OUTPUT", output_data=prompt_result, metadata={
+            "prompt_length": len(prompt_result.prompt),
+            "template_used": prompt_result.template_used,
+            "variables_count": len(prompt_result.context_data) if hasattr(prompt_result, 'context_data') else 0
+        })
+        
+        logger.info(
+            "✅ PromptBuilder: Generated prompt (%d chars) using template '%s'",
+            len(prompt_result.prompt),
+            prompt_result.template_used
+        )
+        
+        # 4️⃣ LLMService: 코드 분석 및 요약 생성
+        logger.info("🤖 LLMService: Starting LLM analysis")
+        
+        log_module_io("LLMService", "INPUT", input_data=prompt_result, metadata={
+            "operation": "generate_summary",
+            "prompt_length": len(prompt_result.prompt),
+            "provider": "openai"  # 기본값
+        })
+        
+        llm_service = LLMService()
+        
+        # LLMInput 객체 생성
+        model_config = ModelConfig(
+            model="gpt-3.5-turbo",  # 기본 모델
+            temperature=0.7,
+            max_tokens=1000
+        )
+        
+        llm_input = LLMInput(
+            prompt=prompt_result.prompt,
+            llm_provider=LLMProvider.OPENAI,
+            model_config=model_config
+        )
+        
+        # async 메서드를 동기적으로 실행
+        try:
+            # 이미 이벤트 루프가 실행 중인 경우 새 루프 생성
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, llm_service.generate_summary(llm_input))
+                    llm_response = future.result()
+            else:
+                llm_response = asyncio.run(llm_service.generate_summary(llm_input))
+        except RuntimeError:
+            # 이벤트 루프가 없는 경우
+            llm_response = asyncio.run(llm_service.generate_summary(llm_input))
+        
+        log_module_io("LLMService", "OUTPUT", output_data=llm_response, metadata={
+            "response_length": len(llm_response.summary),
+            "confidence_score": llm_response.confidence_score,
+            "provider_used": llm_response.metadata.provider if llm_response.metadata else "unknown",
+            "model_used": llm_response.metadata.model_used if llm_response.metadata else "unknown"
+        })
+        
+        logger.info(
+            "✅ LLMService: Generated summary (%d chars) using %s/%s",
+            len(llm_response.summary),
+            llm_response.metadata.provider if llm_response.metadata else "unknown",
+            llm_response.metadata.model_used if llm_response.metadata else "unknown"
+        )
+        
+        # 5️⃣ NotificationService: Slack 알림 전송
+        logger.info("📢 NotificationService: Starting notification delivery")
+        
+        # 알림 메시지 구성
+        notification_message = f"""🌅 **일일 개발 활동 요약** - {yesterday_start.strftime('%Y년 %m월 %d일')}
+
+{llm_response.summary}
+
+---
+📊 **전체 통계**
+• 개발자: {len(aggregated_data.developer_stats)}명
+• 저장소: {len(aggregated_data.repository_stats)}개
+• 처리된 커밋: {len(commits)}개
+
+_CodePing.AI 자동 생성 리포트_"""
+        
+        log_module_io("NotificationService", "INPUT", metadata={
+            "operation": "send_slack_message",
+            "message_length": len(notification_message),
+            "channel": "default"
+        })
+        
+        notification_service = NotificationService()
+        notification_result = notification_service.send_daily_summary(
+            summary_report=notification_message,
+            developer=target_developer,
+            developer_email="team@codeping.ai",  # 기본 이메일
+            slack_channel="#dev-reports"  # 기본 채널
+        )
+        
+        log_module_io("NotificationService", "OUTPUT", output_data=notification_result, metadata={
+            "success": notification_result.success,
+            "channel_used": notification_result.channel,
+            "delivery_time": notification_result.timestamp.isoformat() if notification_result.timestamp else None
+        })
+        
+        if notification_result.success:
+            logger.info(
+                "✅ NotificationService: Message sent successfully to %s",
+                notification_result.channel
+            )
+        else:
+            logger.error(
+                "❌ NotificationService: Failed to send message: %s",
+                notification_result.error_message
+            )
+        
+        # 실행 완료
+        total_execution_time = (datetime.now() - start_time).total_seconds()
+        
+        result = {
+            "success": True,
+            "date_processed": yesterday_start.strftime('%Y-%m-%d'),
+            "developers_count": len(aggregated_data.developer_stats),
+            "commits_count": len(commits),
+            "notification_sent": notification_result.success,
+            "execution_time_seconds": total_execution_time,
+            "modules_executed": ["DataRetriever", "DataAggregator", "PromptBuilder", "LLMService", "NotificationService"]
+        }
+        
+        logger.info(
+            "🎉 Daily summary completed successfully in %.2fs: %d developers, %d commits, notification=%s",
+            total_execution_time,
+            len(aggregated_data.developer_stats),
+            len(commits),
+            "✅" if notification_result.success else "❌"
+        )
+        
+        return result
+        
+    except Exception as exc:
+        total_execution_time = (datetime.now() - start_time).total_seconds()
+        
+        logger.exception("❌ Daily summary task failed: %s", exc)
+        
+        return {
+            "success": False,
+            "error": str(exc),
+            "error_type": type(exc).__name__,
+            "execution_time_seconds": total_execution_time
+        }

yeonjae_universal_schedule_manager-1.0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: yeonjae-universal-schedule-manager
+Version: 1.0.1
+Summary: Universal schedule manager module for job scheduling and execution
+Author-email: Yeonjae <dev@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yeonjae/universal-modules
+Project-URL: Repository, https://github.com/yeonjae/universal-modules
+Project-URL: Issues, https://github.com/yeonjae/universal-modules/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: croniter>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.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"
+
+# Universal schedule manager
+
+범용 schedule manager 모듈
+
+## 설치
+
+```bash
+pip install git+https://github.com/yeonjae-work/universal-modules.git#subdirectory=packages/universal-schedule-manager
+```

yeonjae_universal_schedule_manager-1.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+universal_schedule_manager/__init__.py,sha256=d1asEdvyEKLqcPgRKWG602TWPjGjZK8_UOX21tfDhiE,147
+universal_schedule_manager/exceptions.py,sha256=ZIUxSMdHeSt0QI5UCzpYESnffgLHulPvAacKOtyY8oQ,2356
+universal_schedule_manager/models.py,sha256=nvxvh05gRPCzYrNu6mTe0hSPK4WJp1nQwkGAU55jP2U,6464
+universal_schedule_manager/service.py,sha256=egt94nxGvTyDNuqcNxnu3bDWye7SDXohdaiKzdw28ZA,12571
+universal_schedule_manager/tasks.py,sha256=iKP_m4F2SM0r7eU2KI-J2KKhCkoeiPEVNTN7oSo2WHU,13806
+yeonjae_universal_schedule_manager-1.0.1.dist-info/METADATA,sha256=qRlc5QUreqnlrAP0Qf-utDLDWDaQ5ta84pZ1fQbhJxQ,1483
+yeonjae_universal_schedule_manager-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+yeonjae_universal_schedule_manager-1.0.1.dist-info/top_level.txt,sha256=IvPXSrhGzvT4LCf911hF8U9bUTkrR__hgi45sLP5vvA,27
+yeonjae_universal_schedule_manager-1.0.1.dist-info/RECORD,,

yeonjae_universal_schedule_manager-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_schedule_manager-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+universal_schedule_manager