vacation algo management - what i learned from 8 days offline

from datetime import datetime, timedelta
from typing import Optional
import asyncio

class VacationManager:
    """
    Manages positions and trading during vacation periods
    """

    def __init__(self, broker_client, vacation_start: datetime, vacation_end: datetime):
        self.broker = broker_client
        self.vacation_start = vacation_start
        self.vacation_end = vacation_end
        self.pre_vacation_days = 3
        self.emergency_flatten_enabled = True

    def is_pre_vacation_period(self) -> bool:
        """Check if we're in pre-vacation wind-down"""
        days_until = (self.vacation_start - datetime.now()).days
        return 0 < days_until <= self.pre_vacation_days

    def is_vacation_period(self) -> bool:
        """Check if currently on vacation"""
        now = datetime.now()
        return self.vacation_start <= now <= self.vacation_end

    def get_max_dte_allowed(self) -> int:
        """
        Returns maximum DTE for new positions based on vacation proximity
        """
        if self.is_vacation_period():
            return 0  # no new positions

        days_until = (self.vacation_start - datetime.now()).days

        if days_until <= 1:
            return 0  # no new positions
        elif days_until <= 3:
            return days_until - 1  # must expire before vacation
        elif days_until <= 7:
            return 5  # short-term only
        else:
            return 45  # normal max DTE

    def should_close_position(self, position: dict) -> dict:
        """
        Determine if position should be closed for vacation
        """
        days_until = (self.vacation_start - datetime.now()).days
        expiry = position.get('expiration_date')
        pnl_pct = position.get('unrealized_pnl_pct', 0)

        # T-5: Close winners >50%
        if days_until <= 5 and pnl_pct > 0.5:
            return {'close': True, 'reason': 'pre_vacation_profit_take'}

        # T-3: Close all profitable
        if days_until <= 3 and pnl_pct > 0:
            return {'close': True, 'reason': 'pre_vacation_flatten'}

        # T-1: Close everything
        if days_until <= 1:
            return {'close': True, 'reason': 'vacation_start'}

        # Position expires during vacation
        if expiry and self.vacation_start <= expiry <= self.vacation_end:
            return {'close': True, 'reason': 'expires_during_vacation'}

        return {'close': False, 'reason': None}

    async def run_vacation_protocol(self):
        """
        Execute vacation position management
        """
        positions = await self.broker.get_positions()

        for position in positions:
            decision = self.should_close_position(position)

            if decision['close']:
                print(f"Closing {position['symbol']}: {decision['reason']}")
                await self.broker.close_position(position['id'])

        # Disable new trades during vacation
        if self.is_vacation_period():
            await self.broker.set_trading_enabled(False)


class EmergencyFlatten:
    """
    Emergency position closer if things go wrong during vacation
    Can be triggered remotely via simple webhook
    """

    def __init__(self, broker_client):
        self.broker = broker_client
        self.flatten_triggered = False

    async def flatten_all(self, reason: str = "emergency"):
        """
        Close all positions immediately
        """
        if self.flatten_triggered:
            return {'status': 'already_triggered'}

        positions = await self.broker.get_positions()
        closed = []

        for position in positions:
            try:
                await self.broker.close_position(
                    position['id'],
                    order_type='market'  # immediate execution
                )
                closed.append(position['symbol'])
            except Exception as e:
                print(f"Failed to close {position['symbol']}: {e}")

        self.flatten_triggered = True

        return {
            'status': 'flattened',
            'positions_closed': len(closed),
            'symbols': closed,
            'reason': reason
        }