Daily Worker

DAILY_INTERVAL = 86400  # 24 hours
MAX_DAILY_GENERATIONS = 5

class DailyWorker:
    def __init__(
        self,
        graph_manager: GraphManager,
        job_manager: JobManager | None,
        interval_seconds: int = DAILY_INTERVAL,
    ):
        self.gm = graph_manager
        self.jm = job_manager
        self.interval = interval_seconds

DAILY_CRON_ENABLED=true

async def start(self):
    logger.info("Daily worker starting")
    while True:
        try:
            await self._run_daily()
        except asyncio.CancelledError:
            logger.info("Daily worker cancelled")
            break
        except Exception as e:
            logger.error("Daily worker error: %s", e)
        await asyncio.sleep(self.interval)

daily_task = None
if settings.DAILY_CRON_ENABLED:
    from app.workers.daily import DailyWorker
    
    daily = DailyWorker(gm, job_manager)
    daily_task = asyncio.create_task(daily.start())
    logger.info("Daily worker started")

if daily_task:
    daily_task.cancel()

async def _run_daily(self):
    now = datetime.now(timezone.utc)
    events = await self.gm.today_in_history(now.month, now.day)
    logger.info(
        "Today in history (%s/%s): %d events found",
        now.month,
        now.day,
        len(events),
    )

def get_sceneless_events(self, events: list[dict]) -> list[dict]:
    return [e for e in events if not e.get("flash_timepoint_id")]

async def _rank_events(self, events: list[dict]) -> list[dict]:
    scored = []
    for e in events:
        path = e.get("path", "")
        deg = await self.gm.degree(path) if path else 0
        layer = e.get("layer", 0)
        scored.append((e, deg + layer * 2))
    scored.sort(key=lambda x: x[1], reverse=True)
    return [e for e, _ in scored]

to_generate = (await self._rank_events(sceneless))[:MAX_DAILY_GENERATIONS]

for event in to_generate:
    name = event.get("name", "")
    year = event.get("year", "")
    query = f"{name} ({year})"
    job = self.jm.create_job(
        query=query, preset="balanced", visibility="public"
    )
    await self.jm.process_job(job)
    logger.info("Daily generation queued: %s (job %s)", query, job.id)

2026-03-06 00:00:05 INFO clockchain.daily Daily worker starting
2026-03-06 00:00:10 INFO clockchain.daily Today in history (3/6): 42 events found
2026-03-06 00:00:10 INFO clockchain.daily Events without Flash scenes: 18
2026-03-06 00:00:15 INFO clockchain.daily Daily generation queued: Michelangelo born (1475) (job job_abc123)
2026-03-06 00:00:20 INFO clockchain.daily Daily generation queued: Alamo falls (1836) (job job_abc124)
2026-03-06 00:00:25 INFO clockchain.daily Daily generation queued: Ghana independence (1957) (job job_abc125)
2026-03-06 00:00:30 INFO clockchain.daily Daily generation queued: Cyrus Vance dies (2002) (job job_abc126)
2026-03-06 00:00:35 INFO clockchain.daily Daily generation queued: SpaceX Starship test (2021) (job job_abc127)

job = self.jm.create_job(
    query="Moon landing (1969)",
    preset="balanced",
    visibility="public"
)
await self.jm.process_job(job)

try:
    await self.jm.process_job(job)
except httpx.HTTPStatusError as e:
    if e.response.status_code == 429:
        logger.warning("Flash rate limited, deferring job %s", job.id)
        # Job remains in queue for retry

# Watch for daily runs
tail -f logs/clockchain.log | grep "clockchain.daily"

# Count generated scenes
curl http://localhost:8000/api/timepoints | jq '[.[] | select(.created_by == "daily")] | length'

try:
    await self._run_daily()
except asyncio.CancelledError:
    logger.info("Daily worker cancelled")
    break
except Exception as e:
    logger.error("Daily worker error: %s", e)

MAX_DAILY_GENERATIONS = 10  # Generate 10 scenes per day

daily = DailyWorker(
    gm, 
    job_manager, 
    interval_seconds=43200  # 12 hours
)

async def _rank_events(self, events: list[dict]) -> list[dict]:
    # Prioritize events with more figures
    scored = [
        (e, len(e.get("figures", []))) 
        for e in events
    ]
    scored.sort(key=lambda x: x[1], reverse=True)
    return [e for e, _ in scored]