def duration2str(seconds): t = Time(hour=seconds // 3600, minute=(seconds // 60) % 60, second=seconds % 60) if t.hour: return t.strftime('%H:%M:%S') else: return t.strftime('%M:%S')
def request_flight(self, number: int, destination: str, departure_time: datetime, check_in_time: time, check_in_status: bool = 0): flight = json.dumps({ 'airline': self.airline_name, 'flight_number': self.airline_name + str(number), 'destination': destination, 'departure_time': departure_time.strftime("%d/%m/%Y, %H:%M:%S"), 'check_in_time': check_in_time.strftime("%H:%M:%S"), 'check_in_status': check_in_status, }) self.channel.basic_publish(exchange=self.exchange_name, routing_key='request', body=flight) print(f'Sent {flight}')
def time2str(time: dt.time, fmt: str = STD_TIME_FMT) -> str: """ :param time: dt.time object :param fmt: [optional] defaults to H:M:S :return: string """ return time.strftime(fmt)
def within_time_range(self, start_time: time, end_time: time) -> "Ezlink": """Return ezlink where each journey start or/and end within the specified time range.""" if self.meta.get("within_time_range"): raise RuntimeError("Ezlink is already within_time_range=" .format(self.meta.get("within_time_range"))) start_time_str = start_time.strftime("%H:%M:%S") end_time_str = end_time.strftime("%H:%M:%S") predicate_board = (F.date_format(self.tap_in_time, "HH:mm:ss") .between(start_time_str, end_time_str)) predicate_alight = (F.date_format(self.tap_out_time, "HH:mm:ss") .between(start_time_str, end_time_str)) dataframe = (self.dataframe .filter(predicate_board | predicate_alight)) return (Ezlink(dataframe, **self.columns) .annotate("within_time_range", (start_time, end_time)))
def _jsonify_time(obj: datetime.time, camel_case_keys: bool = True, arg_struct: bool = True) -> JSONType: if not arg_struct: return obj.strftime('%H:%M:%S.%f') return { MODULE_KEY: datetime.time.__module__, NAME_KEY: datetime.time.__name__, 'hour': obj.hour, 'minute': obj.minute, 'second': obj.second, 'microsecond': obj.microsecond }
def _format_time(_time: datetime.time = None, days: int = None) -> str: """Formats time + shift days as a string for use in __repr__.""" if _time is None: time_repr = "??:??" else: time_repr = _time.strftime("%H:%M:%S" if _time.second else "%H:%M") if days is None: days_repr = "" elif days < 0: days_repr = "{}d".format(days) else: days_repr = "+{}d".format(days) return "{}{}".format(time_repr, days_repr)
def get_users_by_timing(time_: datetime.time) -> List[Dict[str, Any]]: table = dynamodb.Table(DYNAMODB_TABLE) attrs = ['id', 'active', 'message', 'name', 'last_updated'] filter = { 'active': { 'AttributeValueList': [True], 'ComparisonOperator': 'EQ' }, 'timing': { 'AttributeValueList': [time_.strftime('%H:%M')], 'ComparisonOperator': 'EQ' } } return table.scan(AttributesToGet=attrs, ScanFilter=filter)['Items']
def _find_replacement_master(order: Order, time: datetime.time, order_service_id, old_master: Master): """ Tries to assign a replacement master to the `order_item` of the `order` :return: replacement `Master` or None """ # since order is canceled # the master should not rely on that money client = order.client # looking for a replacement location = client.home_address.location logger.info( f'Looking for a replacement for master {old_master.first_name} ' f'with params: service={order_service_id}, ' f'date={order.date}, time={time}, location={location}') params = FilteringParams( { 'service': order_service_id, 'date': str(order.date), 'time': time.strftime('%H:%M'), 'coordinates': f'{location.lat},{location.lon}' }, client=client, ignore_taken_slots=True) masters, slots = master_utils.search(params, FilteringFunctions.datetime) if len(masters) == 0: logger.info(f'Unable to find replacement ' f'for master {old_master.first_name}') # unable to find replacement # TODO add push notification to client and other masters return None masters = master_utils.sort_masters(masters, params.coordinates, params.distance) # we can't pick the same master masters = list(filter(lambda m: m.id != old_master.id, masters)) if len(masters) == 0: logger.info(f'After removing duplicates, no masters can be ' f'a replacement for master {old_master.first_name}') # if the old master is the only one who fits # TODO add push notification to client and other masters return None return masters[0]
def caption_time_to_caption(srt: bool, sequence_number: int, start_time: datetime.time, end_time: datetime.time, text: str, language: Optional[str]) -> str: result = "" format = "" if True == srt: # SRT format requires ',' as decimal separator rather than '.'. format = '%H:%M:%S,%f' result += "{}{}".format(sequence_number, linesep) else: format = '%H:%M:%S.%f' # Trucate microseconds to milliseconds. result += '{} --> {}{}'.format( start_time.strftime(format)[:-3], end_time.strftime(format)[:-3], linesep) if language is not None: result += '[{}] {}{}{}'.format(language, text, linesep, linesep) else: result += '{}{}{}'.format(text, linesep, linesep) return result
def getScheduleLine(token_: str, stopId_: str, date_: date, mintime_: time, maxtime_: time): """ Using https://api-v3.mbta.com/schedules to query lines of data. """ schedules = [] url_ = SCHEDULE_MBTA_URL.format(MBTA_V3_URL) params_ = {'filter[stop]': stopId_, 'sort': 'arrival_time', 'filter[direction_id]': '0', 'filter[date]': date_.strftime('%Y-%m-%d'), 'filter[min_time]': mintime_.strftime('%H:%M'), 'filter[max_time]': maxtime_.strftime('%H:%M')} headers_ = {'x-api-key': token_} resp = requests.get(url=url_, params=params_, headers=headers_) raw_json = resp.json() for line in raw_json['data']: try: schedule_id = line['id'] schedule = line['attributes'] drop_off_type = schedule['drop_off_type'] pickup_type = schedule['pickup_type'] arrival_time = schedule['arrival_time'] departure_time = schedule['departure_time'] schedules.append((schedule_id, drop_off_type, pickup_type, date_, arrival_time, departure_time)) except KeyError: pass return schedules
def time_to_str(time_to_convert: time) -> str: """Converts a time object to str""" return time_to_convert.strftime('%H:%M:%S')
def localized_time_string(self, time: datetime.time) -> Text: return "{} {}".format( time.strftime("%-I%p"), self.game_time_zone.localize(datetime.datetime.now()).tzname())
def format_backend_time(time:datetime.time, format:str=time_format) -> str: return time.strftime(format)
def get_time_str(self, atime: time): return atime.strftime(self.time_str_format)
def time_to_str(value: datetime.time) -> str: return value.strftime(TIME_STR_FORMAT)
def make_booking_string(start_datetime: datetime.datetime, end_time: datetime.time) -> str: start_time_and_date_string = start_datetime.strftime( '%-m/%-d from %-I:%M%p') end_time_string = end_time.strftime('%-I:%M%p') return f'{start_time_and_date_string} to {end_time_string}'
def progress(self, new_progress: time): """Sets the progress to a different time""" if type(new_progress) is time: self._progress = new_progress.strftime("%M") else: raise ValueError('Argument is not of type datetime')
def hour_to_string(hour: time) -> str: return hour.strftime('%-H:%M')
def format_time(time_obj: time) -> str: """ Formats a time object to a string HH:MM, for use with section serializer """ return '' if time_obj is None else time_obj.strftime('%H:%M')
def time_window_fmt(start:datetime.time, dur:datetime.timedelta): if start is None or dur is None: return "Anytime" finish = nptime.from_time(start) + dur fmt = "%-H%M" return "%s to %s" % (start.strftime(fmt), finish.strftime(fmt))
def datetimeToString(dt_time: dt.time) -> str: if not dt_time: return None return str(dt_time.strftime('%H:%M:%S'))
def format_time(time: dt.time) -> str: return time.strftime('%H:%M:%S.%f')[:-3]
def _time_to_snowflake(self, value: dt_t) -> str: if value.microsecond: return value.strftime("%H:%M:%S.%%06d") % value.microsecond return value.strftime("%H:%M:%S")
def set_subscription_time(self, user_id: int, t: time) -> None: self.redis.hset(str(user_id), "subscription_time", t.strftime("%H:%M"))
def localized_time_string(self, time: datetime.time) -> str: return "{} {}".format( _normalize_am_pm_annotation(time.strftime("%-I%p")), self.game_time_zone.localize(datetime.datetime.now()).tzname())
def _mk_time_format(time: dt.time) -> str: minutes = time.strftime("%M") minutes = "00" if minutes == "0" else minutes return f"{time.strftime('%H')}:{minutes}"
def _format_time(time_to_format: time_t) -> str: return time_to_format.strftime("%H:%M")
def str_time(cls, dt: datetime.time) -> str: """Return the time as a string""" return dt.strftime(cls.TIME_FORMATS[0])
def flatten_time(t: datetime.time): if t.second: return t.strftime('%H:%M:%S') else: return t.strftime('%H:%M')
def to_url(self, value: time) -> str: return value.strftime(self.format)
def format_time(when: datetime.time, format_str: str = TIME_FORMAT) -> str: """Returns a string representing the given datetime.time object. If no strftime-compatible format is provided, the default is used.""" return when.strftime(format_str)
def _cast_str_time(cls: Type[str], val: datetime.time, ctx): if ctx.time_format == 'iso': return cls(val.isoformat()) else: return cls(val.strftime(ctx.time_format))