def has_available_slots(office: Office, start_time: datetime,
end_time: datetime, service: Service):
"""Return if there is any available slot for the time period for the office."""
start_time = start_time.astimezone(
pytz.timezone(office.timezone.timezone_name))
end_time = end_time.astimezone(
pytz.timezone(office.timezone.timezone_name))
available_day_slots = AvailabilityService.get_available_slots(
office=office,
days=[start_time],
format_time=False,
service=service)
has_available_slot = False
for slot in available_day_slots[start_time.strftime(
'%m/%d/%Y')]: # Iterate the only item from the list
# Because services can be artbitary duration, we just check if times fall within duration
# e.g slot is 8-9, but start_time/end_time are 8:30-8:45.
# We do NOT check across slots, only within an individual slot
if slot['start_time'] <= start_time.time(
) and slot['end_time'] >= end_time.time():
has_available_slot = True
return has_available_slot
def __init__(self, config, sim_st: datetime, all_sampling_data, all_future_data):
self.logger = logging.getLogger(self.__class__.__name__)
self.config = config
self.sim_root = self.config.sim_root + sim_st.date().isoformat() + "/" + sim_st.time().isoformat() + "/"
self.params_root = self.config.params_output_root + sim_st.date().isoformat() + "/"
pathlib.Path(self.params_root).mkdir(parents=True, exist_ok=True)
sim_logs_dir = self.config.sim_logs_root + sim_st.date().isoformat() + "/"
pathlib.Path(sim_logs_dir).mkdir(parents=True, exist_ok=True)
self.sim_logs_path = sim_logs_dir + sim_st.time().isoformat() + ".log"
self.sim_st = sim_st
self.sampling_window_start_time = sim_st - timedelta(seconds=self.config.sampling_window)
self.sampling_window_end_time = sim_st
self.orderbook_window_start_time = sim_st - datetime.timedelta(seconds=self.config.orderbook_window)
self.orderbook_window_end_time = sim_st
self.all_sampling_data = all_sampling_data
self.all_future_data = all_future_data
self.graphing = Graphing(config, "Backtest @ " + sim_st.isoformat())
def check_if_available(person: int, service: int, date_time: datetime) -> bool:
bool_list = []
current_reservations = Reservation.objects.filter(user=person,
date=date_time.date())
service = Service.objects.get(id=service)
duration = service.duration
start_time = date_time.time()
end_time = date_time.time() + datetime.timedelta(minutes=duration)
for reservation in current_reservations:
reservation_end_time = reservation.start_time + datetime.timedelta(
minutes=duration)
bool_list.append(
reservation.start_time <= start_time <= reservation_end_time
or reservation.start_time <= end_time <= reservation_end_time)
if bool_list:
return True not in bool_list
else:
return True
def has_available_slots(office: Office, start_time: datetime,
end_time: datetime):
"""Return if there is any available slot for the time period for the office."""
start_time = start_time.astimezone(
pytz.timezone(office.timezone.timezone_name))
end_time = end_time.astimezone(
pytz.timezone(office.timezone.timezone_name))
available_day_slots = AvailabilityService.get_available_slots(
office=office, days=[start_time], format_time=False)
has_available_slot = False
for slot in available_day_slots[start_time.strftime(
'%m/%d/%Y')]: # Iterate the only item from the list
if slot['start_time'] == start_time.time(
) and slot['end_time'] == end_time.time():
has_available_slot = True
return has_available_slot
def updateTimeIndex(severityEntry:dict, accident:dict,accidentDate: datetime, )->None:
"""
Actualiza las entradas del indice Time.
parametros:
severityEntry(OrderedMap): Contiene un TimeIndex
accident(dict): Contiene la informacion acerca del accidente
"""
id = accident['ID']
accidentTime = blockTime(accidentDate.time())
entryExist = om.contains(severityEntry,accidentTime)
if entryExist:
timeEntry = om.get(severityEntry, accidentTime)
timeEntry = me.getValue(timeEntry)
else:
timeEntry = newIDList()
om.put(severityEntry,accidentTime,timeEntry)
lt.addFirst(timeEntry['idList'],id)
timeEntry['size'] += 1
def check_if_any_collisions(person: int, service: int, date_time: datetime, client: int = None) -> \
Union[bool, Dict[str, bool]]:
current_reservations = Reservation.objects.filter(user=person,
date=date_time.date())
service = Service.objects.get(id=service)
duration = service.duration
start_time = date_time.time()
end_time = (datetime.datetime.combine(datetime.date.today(), start_time) +
datetime.timedelta(minutes=duration)).time()
time_range = [
(reservation.start_time,
(datetime.datetime.combine(datetime.date.today(),
reservation.start_time) +
datetime.timedelta(minutes=reservation.service.duration)).time())
for reservation in current_reservations
]
no_collisions_with_current_reservations = check_time_collisions(
time_range, start_time, end_time)
no_collisions_with_client_reservations = True
if client is not None:
client_reservations = Reservation.objects.filter(client=client,
date=date_time.date())
time_range = [
(reservation.start_time,
(datetime.datetime.combine(datetime.date.today(),
reservation.start_time) +
datetime.timedelta(minutes=reservation.service.duration)).time())
for reservation in client_reservations
]
no_collisions_with_client_reservations = check_time_collisions(
time_range, start_time, end_time)
if no_collisions_with_current_reservations and no_collisions_with_client_reservations:
return True
else:
return {
'current_reservations': no_collisions_with_current_reservations,
'client_reservations': no_collisions_with_client_reservations
}
def _filter_stop_times_window(self, stop_times: list,
window_start: datetime,
window_end: datetime) -> list:
"""
This method will only retain the stop times in the given time window
:param stop_times: The list of stop times to filter.
:param window_start: The start of the time window.
:param window_end: End of the time window
:return: The filtered list
"""
logging.debug("Filtering stop times")
# Check if the time window spans across midnight
window_crosses_midnight = window_end.date() > window_start.date()
# Calculate the seconds from midnight. This way we can do all later comparisons using integers
window_start_secs_since_midnight = window_start.time().hour * 3600 \
+ window_start.time().minute * 60 \
+ window_start.time().second
window_end_secs_since_midnight = window_end.time().hour * 3600 \
+ window_end.time().minute * 60 \
+ window_end.time().second
# Get the day before the start date, needed to check if a trip that spans multiple days was active on this day.
day_before_start = window_start.date() - timedelta(days=1)
filtered_stop_times = list()
for stop_time in stop_times:
# We already calculated the seconds from midnight in the StopTimesCache.
secs_since_midnight = stop_time['departure_seconds']
# The first, easy, check is to see if the time lies between the start and end time.
# If this fails, we can skip all other checks
if not self._is_time_in_window(secs_since_midnight,
window_start_secs_since_midnight,
window_end_secs_since_midnight):
continue
# Alright, so the time is valid. Is the trip actually ran on that day? Get the service id so we can check
trip = self._trips_cache.get_trip(stop_time['trip_id'])
service_id = trip['service_id']
# Get the hour part from the time. If it is more than 23, it is a trip that started the day before.
hour_int = secs_since_midnight // 3600
# This is a trip that started the same day
if hour_int < 24:
# If the window doesn't cross midnight, the departure date is the same as the date of the window start.
# Check if the service_id is active that day
if not window_crosses_midnight \
and self._calendar_dates_cache.is_serviced(service_id, window_start.date()):
filtered_stop_times.append(stop_time)
# If it crosses midnight, we need to determine the departure date first
elif window_crosses_midnight:
# We have constrained the time window to no more than 24h. This means that, if the time window
# crosses midnight, the end time will lie before the start time. This simplifies the following tests
if secs_since_midnight >= window_start_secs_since_midnight:
if self._calendar_dates_cache.is_serviced(
service_id, window_start.date()):
filtered_stop_times.append(stop_time)
else:
if self._calendar_dates_cache.is_serviced(
service_id, window_start.date()):
filtered_stop_times.append(stop_time)
# This is a trip that started the day before (it's past midnight),
# check if it was active on the day it started
elif hour_int >= 24:
if not window_crosses_midnight and self._calendar_dates_cache.is_serviced(
service_id, day_before_start):
filtered_stop_times.append(stop_time)
# Alright, so the window crosses midnight and this trip started the day before.
# Since this trip planner is restricted to 1-day intervals, we know the day before is start date
elif window_crosses_midnight:
# We have constrained the time window to no more than 24h. This means that, if the time window
# crosses midnight, the end time will lie before the start time. This simplifies the following tests
# First day. Comparison corrects for the 24h offset since the hour part is larger than 24h
if secs_since_midnight - 86400 >= window_start_secs_since_midnight:
if self._calendar_dates_cache.is_serviced(
service_id, day_before_start):
filtered_stop_times.append(stop_time)
# Second day
else:
if self._calendar_dates_cache.is_serviced(
service_id, window_start.date()):
filtered_stop_times.append(stop_time)
return filtered_stop_times
def func_extract_time(some_date: datetime) -> Callable:
return lambda: some_date.time()
def fillTrainTime(self, departureTime: datetime):
time = departureTime.time()
seconds = (time.hour * 60 + time.minute) * 60 + time.second
approximation = seconds - (seconds % TIME_INTERVAL)
self.trainX[self.trainRowsIndex][self.columns[approximation]] = 1
def format_time_for_request(time_datetime: datetime) -> str:
time = time_datetime.time().strftime('%H:%M:%S')
date = time_datetime.date().strftime('%Y-%m-%d')
request_string = date + 'T' + time
return request_string
