APIs & Class Members

For each class, define the attributes (data) it will hold and the methods (functions) that operate on the attributes. Ensure they align with the object's responsibilities and adhere to the principle of encapsulation. Write your code in the code editor below.

# Define your classes here

from abc import abstractmethod, ABC

from enum import Enum

import threading

class VehicleType(Enum):

MOTORCYCLE = 1

CAR = 2

TRUCK = 3

class SpotType(Enum):

SMALL = 1

MEDIUM = 2

LARGE = 3

class Vehicle:

def __init__(self, license_plate: str, vehicle_type: VehicleType):

self.license_plate = license_plate

self.vehicle_type = vehicle_type

def get_license_plate(self):

return self.license_plate

def get_vehicle_type(self):

return self.vehicle_type.ordinal()

class ParkingSpot:

def __init__(self, spot_type: SpotType):

self.id = uuid4().hex

self.vehicle = None

self.spot_type = spot_type

self.lock = threading.Lock()

def can_park(self, vehicle: Vehicle):

return self.vehicle is None and self.spot_type.ordinal() >= self.vehicle.get_vehicle_type().ordinal()

def park(self, vehicle: Vehicle):

with self.lock:

if self.can_park(vehicle):

self.vehicle = vehicle

return True

return False

def get_id(self):

return self.id

def clear(self):

with self.lock:

self.vehicle = None

class ParkingLevel:

def __init__(self, spots: list[ParkingSpot]):

self.spots = spots

def park(self, vehicle: Vehicle):

for i in range(len(self.spots)):

if self.spots[i].park(vehicle):

return self.spots[i].get_id()

def clear_spot(self, spot_id):

for spot in spots:

if spot.get_id() == spot_id:

spot.clear()

break

class PricingStrategy(ABC):

def __init__(self):

pass

@abstractmethod

def calculate_price(self, ticket: Ticket, end_time):

pass

class HourlyPricing(PricingStrategy):

def __init__(self, hourly_rate: float, base_rate: float):

super().__init__()

self.hourly_rate = hourly_rate

self.base_rate = base_rate

def calculate_price(self, ticket, end_time):

return self.base_rate + ((end_time-ticket.start_time) / 3600) * self.hourly_rate

class FlatRatePricing(PricingStrategy):

def __init__(self, flat_rate: float):

super().__init__()

self.flat_rate = flat_rate

def calculate_price(self, ticket, end_time):

return self.flat_rate

class ParkingGarage:

def __init__(self, levels: list[ParkingLevel], pricing_strategy: PricingStrategy):

self.levels = levels

self.pricing_strategy = pricing_strategy

def park_vehicle(self, vehicle: Vehicle, timestamp: float) -> Ticket | None:

for i in range(len(levels)):

spot_id = self.levels[i].park(vehicle)

if spot_id is not None:

return Ticket(start_time=timestamp, level_number=i, spot_id=spot_id, vehicle_license=vehicle.get_license_plate(), vehicle_type=vehicle.get_spot_type())

print("No spots available!")

return None

def handle_exit(self, ticket: Ticket, timestamp):

self.levels[ticket.level_number].clear_spot(ticket.spot_id)

price = ticket.calculate_fee(strategy, timestamp)

return price

@dataclass

class Ticket:

id: str = uuid4().hex

start_time: float

level_number: int

spot_id: str

vehicle_license: str

vehicle_type: VehicleType

def calculate_fee(self, strategy: PricingStrategy, end_time):

return strategy.calculate_price(self, end_time)

Submissions

Displaying Solutions with Scores Ranging from 1 to 10

Submissions

Displaying Solutions with Scores Ranging from 1 to 10