Design a Parking Lot

from enum import Enum

class VehicleType(Enum):
    MOTORCYCLE = "motorcycle"
    CAR = "car"
    BUS = "bus"

class Vehicle(ABC):
    def __init__(self, license_plate: str):
        self.license_plate = license_plate
    @property
    @abstractmethod
    def type(self) -> VehicleType: ...

class Car(Vehicle):
    @property
    def type(self) -> VehicleType: return VehicleType.CAR

class SpotSize(Enum):
    SMALL = 1     # motorcycles only
    MEDIUM = 2    # cars (and motorcycles)
    LARGE = 3     # buses (and cars, and motorcycles)

class ParkingSpot:
    def __init__(self, spot_id: str, size: SpotSize):
        self.spot_id = spot_id
        self.size = size
        self.vehicle: Vehicle | None = None

    def can_fit(self, vehicle: Vehicle) -> bool:
        required = {VehicleType.MOTORCYCLE: SpotSize.SMALL,
                    VehicleType.CAR: SpotSize.MEDIUM,
                    VehicleType.BUS: SpotSize.LARGE}[vehicle.type]
        return self.size.value >= required.value

    def is_free(self) -> bool:
        return self.vehicle is None

import threading

class ParkingLevel:
    def __init__(self, spots: list[ParkingSpot]):
        self._spots = spots
        self._lock = threading.Lock()

    def park(self, vehicle: Vehicle) -> ParkingSpot | None:
        with self._lock:                              # find AND assign, atomically
            for spot in self._spots:
                if spot.is_free() and spot.can_fit(vehicle):
                    spot.vehicle = vehicle
                    return spot
            return None                                # this level is full for this vehicle type

class ParkingLot:
    def __init__(self, levels: list[ParkingLevel]):
        self._levels = levels

    def park_vehicle(self, vehicle: Vehicle) -> "Ticket | None":
        for level in self._levels:
            spot = level.park(vehicle)
            if spot:
                return Ticket(vehicle, spot)
        return None                                    # lot is full