parking lot code

Author: piyushraj-007

Parking Lot/code/__init__.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class VehicleType(Enum):
+    MOTORBIKE, CAR, TRUCK, = 1, 2, 3
+
+class RateType(Enum):
+    PER_HOUR, PER_DAY, = 1, 2  
+
+class ParkingLotType(Enum):
+    MALL, STADIUM, AIRPORT = 1, 2 ,3

Parking Lot/code/enums.py

@@ -0,0 +1,35 @@
+from enums import *
+from rates import FlatRate, DynamicRate
+from vehicles import MoterBike,  Car, Truck
+from parkingSpots import MoterBikeSpot, CarParkingSpot, TruckParkingSpot
+from parkingLots import MallParkingLot, AirportParkingLot 
+
+
+def main():
+    fkat_rate= FlatRate(10)
+    interval_rates=(("0-4",30),("4-12",60))
+    interval_rates=(("0-1",0),("1-8",40), ("8-60",40))
+    per_hour_rates=(RateType.PER_HOUR, 100 )
+    per_day_rates=(RateType.PER_DAY, 100 )
+    dy__rate= DynamicRate(interval_rates, per_hour_rates)
+
+    moterBike = MoterBike("123")
+
+    res= dy__rate.calculate_price(43.05)
+    
+
+    moterBike = MoterBike("123")
+    car = Car("car_123")
+    truck = Truck("truck_123")
+    
+
+    spot = MoterBikeSpot(100, dy__rate)
+    carspots = CarParkingSpot(100, dy__rate)
+    mall_parking  = AirportParkingLot("Airport", "noida")
+    mall_parking.add_moter_bike_parking_spot(spot)
+    mall_parking.add_car_parking_spot(carspots)
+    ticket = mall_parking.park_vehicle(moterBike)
+    mall_parking.unpark_vehicle(moterBike, ticket)
+            
+if __name__ == '__main__':
+    main()

Parking Lot/code/main.py

@@ -0,0 +1,158 @@
+from abc import ABC, abstractmethod
+from enums import *
+import datetime
+
+class ParkingTicket(ABC):
+    def __init__(self,token):
+        self.token= token
+        self.ammount =  0
+        self.issued_at = datetime.datetime.now()
+        self.payed = False
+        self.payedAt= None
+
+
+class ParkingLot(ABC):
+
+    def __init__(self,name,location):
+        self.name=name
+        self.location=location
+
+
+    def addVehicleToSpot(self, spot, vehicle):
+        parkingTicket = None
+        token = spot.assign_vehicle(vehicle)
+        if token != "OutOfCapcity":
+            parkingTicket = ParkingTicket(token)
+        return parkingTicket
+    
+    def removeVehicleFromSpot(self, spot, ticket):
+        spot.remove_vehicle(ticket.token)
+        now = datetime.datetime.now()
+        duration = now - ticket.issued_at
+        duration_in_s = duration.total_seconds() 
+        hours= duration_in_s / 3600
+        # hours = divmod(duration_in_s, 3600)[0]
+        return spot.pricingModel.calculate_price(hours)
+      
+        
+        
+
+    @abstractmethod
+    def park_vehicle(self, vehicle):
+        pass
+
+    @abstractmethod
+    def unpark_vehicle(self, vehicle):
+        pass
+
+    @abstractmethod
+    def add_moter_bike_parking_spot(self, spot):
+        pass
+
+    @abstractmethod
+    def add_car_parking_spot(self, spot):
+        pass
+
+    @abstractmethod
+    def add_truck_parking_spot(self, spot):
+        pass
+    
+
+class MallParkingLot(ParkingLot):
+    def __init__(self,name,location):
+        super().__init__(name, location)
+    
+    def add_moter_bike_parking_spot(self, spot):
+        self.moter_bike_spots = spot
+
+    def add_car_parking_spot(self, spot):
+        self.car_spots = spot
+
+    def add_truck_parking_spot(self, spot):
+        self.truck_sports = spot
+
+    def park_vehicle(self, vehicle):
+        switcher = {
+        VehicleType.MOTORBIKE: self.addVehicleToSpot(self.moter_bike_spots, vehicle),
+        VehicleType.CAR: self.addVehicleToSpot(self.car_spots, vehicle),
+        VehicleType.TRUCK: self.addVehicleToSpot(self.truck_sports, vehicle),
+        }
+        ticket = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        if ticket is None :
+            return "No Space Available"
+        return ticket
+
+    def unpark_vehicle(self, vehicle, ticket):
+        switcher = {
+        VehicleType.MOTORBIKE: self.removeVehicleFromSpot(self.moter_bike_spots, ticket),
+        VehicleType.CAR: self.removeVehicleFromSpot(self.car_spots, ticket),
+        VehicleType.TRUCK: self.removeVehicleFromSpot(self.truck_sports, ticket),
+        }
+        price = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        return price   
+
+class StadiumParkingLot(ParkingLot):
+    def __init__(self,name,location):
+        super().__init__(name, location)
+    
+    def add_moter_bike_parking_spot(self, spot):
+        self.moter_bike_spots = spot
+
+    def add_car_parking_spot(self, spot):
+        self.car_spots = spot
+
+    def add_truck_parking_spot(self, spot):
+        return "not supported"
+    
+    def park_vehicle(self, vehicle):
+        switcher = {
+        VehicleType.MOTORBIKE: self.addVehicleToSpot(self.moter_bike_spots, vehicle),
+        VehicleType.CAR: self.addVehicleToSpot(self.car_spots, vehicle),
+        VehicleType.TRUCK: "Not Supported",
+        }
+        ticket = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        if ticket is None :
+            return "No Space Available"
+        return ticket
+
+    def unpark_vehicle(self, vehicle, ticket):
+        switcher = {
+        VehicleType.MOTORBIKE: self.removeVehicleFromSpot(self.moter_bike_spots, ticket),
+        VehicleType.CAR: self.removeVehicleFromSpot(self.car_spots, ticket),
+        VehicleType.TRUCK: "Not Supported",
+        }
+        price = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        return price
+
+class AirportParkingLot(ParkingLot):
+    def __init__(self,name,location):
+        super().__init__(name, location)
+    
+    def add_moter_bike_parking_spot(self, spot):
+        self.moter_bike_spots = spot
+
+    def add_car_parking_spot(self, spot):
+        self.car_spots = spot
+
+    def add_truck_parking_spot(self, spot):
+        return "not supported"
+    
+    def park_vehicle(self, vehicle):
+        switcher = {
+        VehicleType.MOTORBIKE: self.addVehicleToSpot(self.moter_bike_spots, vehicle),
+        VehicleType.CAR: self.addVehicleToSpot(self.car_spots, vehicle),
+        VehicleType.TRUCK: "Not Supported",
+        }
+        ticket = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        if ticket is None :
+            return "No Space Available"
+        return ticket
+
+    def unpark_vehicle(self, vehicle, ticket):
+        switcher = {
+        VehicleType.MOTORBIKE: self.removeVehicleFromSpot(self.moter_bike_spots, ticket),
+        VehicleType.CAR: self.removeVehicleFromSpot(self.car_spots, ticket),
+        VehicleType.TRUCK: "Not Supported",
+        }
+        price = switcher.get(vehicle.vehical_type, lambda: 'Wrong vehicle type!')
+        return price

Parking Lot/code/parkingLots.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from enums import *
+
+class ParkingSpot(ABC):
+    def __init__(self,capcity):
+        self.capcity = capcity
+        self.spots={"%.3d" % num: None for num in range(self.capcity)}
+
+    def is_free(self):
+        return self.capcity > 0
+
+    def assign_vehicle(self, vehicle):
+        if self.is_free():
+            for key,val in self.spots.items():
+                if val is None :
+                    self.spots[key]= vehicle
+                    self.capcity=self.capcity-1
+                    return key
+        else:
+            return "OutOfCapcity"            
+        
+
+    def remove_vehicle(self, ticket):
+        self.spots[ticket]=None
+        self.capcity+=1    
+
+class MoterBikeSpot(ParkingSpot):
+    def __init__(self,capcity, pricingModel):
+        super().__init__(capcity)
+        self.parking_type = VehicleType.MOTORBIKE
+        self.pricingModel = pricingModel
+
+class CarParkingSpot(ParkingSpot):
+    def __init__(self,capcity,pricingModel):
+        super().__init__(capcity)
+        self.parking_type = VehicleType.CAR
+        self.pricingModel = pricingModel
+
+class TruckParkingSpot(ParkingSpot):
+    def __init__(self,capcity,pricingModel):
+        super().__init__(capcity)
+        self.parking_type = VehicleType.TRUCK
+        self.pricingModel = pricingModel

Parking Lot/code/parkingSpots.py

@@ -0,0 +1,72 @@
+from abc import ABC, abstractmethod
+from abc import ABCMeta, abstractmethod
+import math
+import datetime
+from enums import *
+
+class Rate(metaclass=ABCMeta):
+    @abstractmethod
+    def calculate_price(self):
+        pass
+
+class FlatRate(Rate):
+
+    def __init__(self,rate):
+        """
+        Parameters
+        ----------
+        rate : float
+            price based on per hour
+        
+        """
+        self.rate = rate
+
+    def calculate_price(self, hour):
+        return self.rate*hour 
+    
+
+class DynamicRate(Rate):
+
+    def __init__(self,interval_rates,dynamic_rate):
+        """
+        Parameters
+        ----------
+        interval_rates : tupple
+            price for different time interval in form for tupple ex: (("0-4",30),("4-12",60))
+        dynamic_rate : tupple
+            price after fixed interval has crossed ex: (RateType.PER_HOUR, 100 )
+        """
+
+        self.interval_rates = interval_rates
+        self.dynamic_rate = dynamic_rate
+
+    def calculate_price(self, hours):
+        price = 0
+        
+        if self.dynamic_rate[0] == RateType.PER_HOUR:
+            for rate in self.interval_rates:
+                if hours > 0:
+                    range = rate[0].split("-")
+                    total_hour_in_range = float(range[1])-float(range[0])
+                    price+=rate[1]
+                    hours-=total_hour_in_range
+                else:
+                    break 
+            hours=  math.ceil(hours) 
+                 
+            if hours > 0 :
+                price += hours*self.dynamic_rate[1]
+
+        else:
+            if hours >= 24 :
+                days = math.ceil(hours/24)
+                return days*self.dynamic_rate[1]
+            
+            else:
+                for rate in self.interval_rates:
+                    range = rate[0].split("-")
+                    if  float(range[0]) <= hours <= float(range[1]):
+                        price=rate[1]
+                        return price
+                     
+        return price