Teller Module

from dataclasses import dataclass
from typing import Optional

@dataclass
class Teller:
    id: str
    status: TellerStatus = TellerStatus.IDLE
    current_customer: Optional[Customer] = None
    sessions_served: int = 0

from enum import Enum

class TellerStatus(Enum):
    IDLE = "IDLE"       # Available for service
    BUSY = "BUSY"       # Currently serving
    BROKEN = "BROKEN"   # Out of service (future feature)

def start_service(self, customer: Customer, current_time: float) -> None:
    """
    Inicia el proceso de atención para un cliente específico.
    """
    self.status = TellerStatus.BUSY
    self.current_customer = customer
    customer.status = "BEING_SERVED"
    customer.service_start_time = current_time

def end_service(self) -> Optional[Customer]:
    """
    Finaliza el servicio del cliente que está siendo atendido.
    """
    if not self.current_customer:
        return None
    
    served = self.current_customer
    served.status = "COMPLETED"
    self.current_customer = None
    self.status = TellerStatus.IDLE
    self.sessions_served += 1
    return served

# In DiscreteEventSimulation.initialize()
for i in range(self.config.num_tellers):
    t_id = f"T-{i+1}"
    self.tellers[t_id] = Teller(id=t_id)

def _assign_free_teller(self) -> None:
    if not self.waiting_queue:
        return
    
    for t_id, teller in self.tellers.items():
        if teller.status == TellerStatus.IDLE:
            next_customer = self.waiting_queue.pop(0)
            self.schedule_event(
                SimulationEvent(
                    self.clock,
                    EventType.SERVICE_START,
                    customer=next_customer,
                    teller_id=t_id
                )
            )
            return  # Assign one at a time

utilization = busy_time / total_time

system_utilization = sum(teller.busy_time for teller in tellers) / (num_tellers * total_time)

total_served = sum(teller.sessions_served for teller in tellers.values())

def get_tellers_state() -> List[dict]:
    return [
        {
            "id": t.id,
            "status": t.status.value,
            "current_customer": t.current_customer.id if t.current_customer else None,
            "sessions_served": t.sessions_served
        }
        for t in tellers.values()
    ]

idle_time = total_time - busy_time
idle_percentage = (idle_time / total_time) * 100

busy_time = sum(customer.service_time for customer in served_customers)

for t_id, teller in tellers.items():
    if teller.status == TellerStatus.IDLE:
        # Assign to this teller
        break

class Teller:
    break_start_time: Optional[float] = None
    break_duration: float = 900  # 15 minutes
    
    def take_break(self, current_time: float):
        if self.status == TellerStatus.IDLE:
            self.status = TellerStatus.BROKEN
            self.break_start_time = current_time

class Teller:
    specialties: List[str] = field(default_factory=list)
    
    def can_serve(self, customer: Customer) -> bool:
        return customer.transaction_type in self.specialties

class Teller:
    skill_level: float = 1.0  # Multiplier on service time
    
    def get_service_time(self, base_time: float) -> float:
        return base_time / self.skill_level

def test_teller_lifecycle():
    teller = Teller(id="T-1")
    customer = Customer(id="C1", arrival_time=10.0, ...)
    
    # Initially idle
    assert teller.status == TellerStatus.IDLE
    assert teller.current_customer is None
    assert teller.sessions_served == 0
    
    # Start service
    teller.start_service(customer, 10.0)
    assert teller.status == TellerStatus.BUSY
    assert teller.current_customer == customer
    assert customer.status == "BEING_SERVED"
    assert customer.service_start_time == 10.0
    
    # End service
    served = teller.end_service()
    assert teller.status == TellerStatus.IDLE
    assert teller.current_customer is None
    assert teller.sessions_served == 1
    assert served == customer
    assert customer.status == "COMPLETED"