Define Class Members (write code)

Attributes: For each class, define the attributes (data) it will hold...
Methods: Define the methods (functions) that operate on the attributes. Ensure they align with the object's responsibilities and adhere to the principle of encapsulation.
from abc import ABC, abstractmethod
from enum import Enum

class VehicleSize(Enum):
  MOTORCYCLE = 0
  COMPACT = 1
  LARGE = 2

  def can_fit_in(self, spot_size: VehicleSize) -> bool:
    return self.value <= spot_size.value

class Vehicle(ABC):
  def __init__(self, license_plate: str, model: str, brand: str):
    self.license_plate = license_plate
    self.model = model
    self.brand = brand
  
  @property
  @abstractmethod
  def size(self) -> VehicleSize:
    pass

class MotorcycleVehicle(Vehicle):
  @property
  def size(self):
    return VehicleSize.MOTORCYCLE

class CompactVehicle(Vehicle):
  @property
  def size(self):
    return VehicleSize.COMPACT

class LargeVehicle(Vehicle):
  @property
  def size(self):
    return VehicleSize.LARGE

class Driver:
  def __init__(self, vehicle: Vehicle, is_handicapped: bool):
    self.vehicle = vehicle
    self.is_handicapped = is_handicapped

class ParkingSpot(ABC):
  def __init__(self, spot_id: int):
    self.spot_id = spot_id
    self.is_occupied = False
    self.driver: Driver = None
    self.is_handicap_only = False
    pass
  
  def can_accommodate(self, driver: Driver) -> bool:
    if self.is_handicap_only and not driver.is_handicapped:
      return False
    return driver.vehicle.spot_size.can_fit_in(self.spot_size)
 
  def assign_spot(self, driver: Driver):
    if self.is_occupied:
      raise Exception('The spot is already taken')

    if not self.can_accommodate(driver):
      raise Exception('You cannot occupy this spot')

    self.driver = driver
    self.is_occupied = True

  def return_spot(self):
    self.is_occupied = False
    self.driver = None
  
class MotorcycleSpot(ParkingSpot):
  fee_multiplier: float = 2.0
  fee_strategy: ParkingFeeStrategy = MotorcycleFeeStrategy
  spot_size: VehicleSize = VehicleSize.MOTORCYCLE

  def __init__(self, spot_id: int):
    super().__init__(spot_id)

class CompactSpot(ParkingSpot):
  fee_multiplier: float = 2.5
  fee_strategy: ParkingFeeStrategy = CompactFeeStrategy
  spot_size: VehicleSize = VehicleSize.COMPACT

  def __init__(self, spot_id: int):
    super().__init__(spot_id)

class LargeSpot(ParkingSpot):
  fee_multiplier: float = 3
  fee_strategy: ParkingFeeStrategy = LargeFeeStrategy
  spot_size: VehicleSize = VehicleSize.LARGE

  def __init__(self, spot_id: int):
    super().__init__(spot_id)

class HandicapSpot(LargeSpot):
  fee_multiplier: float = LargeSpot.fee_multipler / 2
  fee_strategy: ParkingFeeStrategy = HandicapFeeStrategy

  def __init__(self, spot_id: int):
    super().__init__(spot_id)
    self.is_handicap_only = True

class ParkingLevel:
  def __init__(self, level_number: int, spot_counts: dict[ParkingSpot, int]):
    self._spots: dict[VehicleSize, list[ParkingSpot]] = {}
    self.level_number = level_number

    for parking_spot, cnt in spot_counts.items():
      self._spots[parking_spot.spot_size] = [parking_spot(i) for i in range(1, count+1)]

  def find_available_spot(self, driver: Driver) -> Optional[ParkingSpot]: 
    for spot_size, spots in self._spots.items():
      for spot in spots:
        if spot.is_occupied or not spot.can_accomodate(driver):
          continue
      
        return spot

  def available_spots(self) -> dict[VehicleSize, int]:
    return {
      spot_size, sum(1 for spot in spots if not spot.is_occupied)
      for spot_size, spots in _spots.items()
    } 
  
class ParkingLot:
  def __init__(self, spots_per_level: list[dict[VehicleSize, int]]):
    self.levels: dict[int, ParkingLevel] = {}
    self.vehicle_directory: dict[str, ParkingSpot] = {}
    self.payment_service = PaymentService()

    for i, spot_counts in enumerate(spots_per_level):
      self.levels[i] = ParkingLevel(i, spot_counts)

  def park_vehicle(self, driver: Driver) -> ParkingTicket:
    for level_num, level in self.levels.items():
      spot = level.find_available_spot(driver)
      if not spot:
        continue

      if is_assigned := spot.assign_spot(driver):
        self.vehicle_directory[driver.vehicle.license_plate] = spot
        return ParkingTicket(driver, spot)

    raise Exception('No spots found, try again later')

  def initiate_exit(self, ticket: ParkingTicket) -> ParkingTicket:
    spot = self.vehicle_directory.get(ticket.license_plate)
    if not spot:
      raise Exception(f'Parking spot not found for license plate: {license_plate}')

    if not spot.driver or not spot.driver.vehicle:
      raise Exception('Parking spot found but no associated driver or vehicle')

    ticket.calculate_fee()
    return ticket

  def process_exit(self, ticket: ParkingTicket, payment_method: string):
    try:
      if self.payment_service.process_parking_payment(ticket, payment_method):
        spot = self.vehicle_directory.get(ticket.license_plate)
        spot.return_spot()
        del self.vehicle_directory[ticket.license_plate]
        return True
    except Exception as e:
      raise e
     
    raise Exception('Could not complete payment, try again')      

class PaymentService:
  def __init__(self):
    self.payment_processors = {
      'cash': CashPaymentProcessor(),
      'card': CreditCardPaymentProcessor()
    }

  def process_parking_payment(self, ticket: ParkingTicket, payment_method: str):
    if not ticket.is_valid():
      raise ValueError('Invalid ticket')
    
    processor = self.payment_processors.get(payment_method)
    if not processor:
      raise Exception('Invalid payment method')
    
    success = processor.process_payment(ticket)
    if success:
      self._generate_receipt(ticket)
      return True
    
    return False

  def _generate_receipt(ticket: ParkingTicket):
    pass

class TicketStatus(Enum):
  ACTIVE = 'active'
  PAID = 'paid'
  EXPIRED = 'expired'

class ParkingTicket:
  def __init__(self, driver: Driver, spot: ParkingSpot):
    self.ticket_id = self._generate_ticket_id()
    self.license_plate = driver.vehicle.license_plate
    self.spot_id = spot.spot_id
    self.fee_strategy = spot.fee_strategy
    self.entry_time = datetime.Now()
    self.exit_time = None
    self.duration = None
    self.status = TicketStatus.ACTIVE
    self.amount_due = None
    self.payment_id = None

  def _generate_ticket_id(self):
    // some UUID generator - maybe SHA256 
    pass

  def _calculate_duration(self):
    if self.exit_time is None:
      self.exit_time = datetime.Now()
    self.duration = self.exit_time - self.entry_time
    return self.duration

  def calculate_fee(self):
    if not self.is_valid:
      raise Exception('Ticket is not valid, cannot calculate fee')

    if self.exit_time and self.exit_time < self.entry_time:
      raise Exception('Exit time cannot be before entry time')

    if self.amount_due > 0:
      return self.amount_due

    if self.duration == 0:
      self._calculate_duration()

    self.amount_due = self.fee_strategy.calculate_fee(self.duration)
    return self.amount_due

  def mark_as_paid(self, payment_id: int):
    self.status = TicketStatus.PAID
    self.payment_id = payment_id

  def is_valid(self):
    return self.status == TicketStatus.ACTIVE

class PaymentProcessor(ABC):
  @abstractmethod
  def process_payment(self, ticket: ParkingTicket):
    pass

  @abstractmethod
  def _pay_amount(self, amount_due: float):
    pass

class CashPaymentProcessor(PaymentProcessor):
  def process_payment(self, ticket: ParkingTicket):
    try:
      if self._pay_amount(ticket.amount_due):
        return True
    except Exception as e:
      raise e
    return False

  def _pay_amount(self, amount_due: float):
    // call some API
    pass

class CreditCardPaymentProcessor(PaymentProcessor):
  def process_payment(self, ticket: ParkingTicket):
    try:
      if self._pay_amount(ticket.amount_due):
        return True
    except Exception as e:
      raise e
    return False

  def _pay_amount(self, amount_due: float):
    // call some API
    pass 
   
class ParkingFeeStrategy(ABC):
  @abstractclass
  def calculate_fee(self, duration: timedelta) -> float:
    pass

class CompactFeeStrategy(ParkingFeeStrategy):
  def calculate_fee(self, duration: timedelta) -> float:  
    return CompactSpot.fee_multiplier * duration

class MotorcycleFeeStrategy(ParkingFeeStrategy):
  def calculate_fee(self, duration: timedelta) -> float:  
    return MotorcycleSpot.fee_multiplier * duration

class LargeFeeStrategy(ParkingFeeStrategy):
  def calculate_fee(self, duration: timedelta) -> float:  
    return LargeSpot.fee_multiplier * duration

class HandicapFeeStrategy(LargeFeeStrategy):
  def calculate_fee(self, duration: timedelta) -> float:  
    return HandicapSpot.fee_multiplier * duration
Submissions

Displaying Solutions with Scores Ranging from 1 to 10

Submissions

Displaying Solutions with Scores Ranging from 1 to 10
