def get_expired_time(start_time):
'''
Returns expired time in HH:MM:SS format calculated relative to start_time
Parameters
----------
start_time : int
Starting point in time
'''
curr_time = time.time()
delta = curr_time - start_time
hour = int(delta / 3600)
delta -= hour * 3600
minute = int(delta / 60)
delta -= minute * 60
seconds = delta
return '%02d' % hour + ':%02d' % minute + ':%02d' % seconds
python类hour()的实例源码
def __new__(cls, year=None, month=0, day=0, hour=0, minute=0, second=0, microsecond=0):
"""year may be a datetime.datetime"""
if year is None or year is Null:
return cls._null_datetime
ndt = object.__new__(cls)
if isinstance(year, basestring):
return DateTime.strptime(year)
elif isinstance(year, DateTime):
ndt._datetime = year._datetime
elif isinstance(year, datetime.datetime):
microsecond = year.microsecond // 1000 * 1000
hour, minute, second = year.hour, year.minute, year.second
year, month, day = year.year, year.month, year.day
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
elif year is not None:
microsecond = microsecond // 1000 * 1000
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
return ndt
def __new__(cls, hour=None, minute=0, second=0, microsecond=0):
"""
hour may be a datetime.time or a str(Time)
"""
if hour is None or hour is Null:
return cls._null_time
nt = object.__new__(cls)
if isinstance(hour, basestring):
hour = Time.strptime(hour)
if isinstance(hour, Time):
nt._time = hour._time
elif isinstance(hour, (datetime.time)):
microsecond = hour.microsecond // 1000 * 1000
hour, minute, second = hour.hour, hour.minute, hour.second
nt._time = datetime.time(hour, minute, second, microsecond)
elif hour is not None:
microsecond = microsecond // 1000 * 1000
nt._time = datetime.time(hour, minute, second, microsecond)
return nt
def retrieve_vfp_datetime(bytes, fielddef, *ignore):
"""
returns the date/time stored in bytes; dates <= 01/01/1981 00:00:00
may not be accurate; BC dates are nulled.
"""
# two four-byte integers store the date and time.
# millesecords are discarded from time
if bytes == array('B', [0] * 8):
cls = fielddef[EMPTY]
if cls is NoneType:
return None
return cls()
cls = fielddef[CLASS]
time = unpack_long_int(bytes[4:])
microseconds = (time % 1000) * 1000
time = time // 1000 # int(round(time, -3)) // 1000 discard milliseconds
hours = time // 3600
mins = time % 3600 // 60
secs = time % 3600 % 60
time = datetime.time(hours, mins, secs, microseconds)
possible = unpack_long_int(bytes[:4])
possible -= VFPTIME
possible = max(0, possible)
date = datetime.date.fromordinal(possible)
return cls(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond)
def update_vfp_datetime(moment, *ignore):
"""
Sets the date/time stored in moment
moment must have fields:
year, month, day, hour, minute, second, microsecond
"""
data = [0] * 8
if moment:
hour = moment.hour
minute = moment.minute
second = moment.second
millisecond = moment.microsecond // 1000 # convert from millionths to thousandths
time = ((hour * 3600) + (minute * 60) + second) * 1000 + millisecond
data[4:] = update_integer(time)
data[:4] = update_integer(moment.toordinal() + VFPTIME)
return bytes(data)
def __new__(cls, year=None, month=0, day=0, hour=0, minute=0, second=0, microsecond=0):
"""year may be a datetime.datetime"""
if year is None or year is Null:
return cls._null_datetime
ndt = object.__new__(cls)
if isinstance(year, basestring):
return DateTime.strptime(year)
elif isinstance(year, DateTime):
ndt._datetime = year._datetime
elif isinstance(year, datetime.datetime):
microsecond = year.microsecond // 1000 * 1000
hour, minute, second = year.hour, year.minute, year.second
year, month, day = year.year, year.month, year.day
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
elif year is not None:
microsecond = microsecond // 1000 * 1000
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
return ndt
def retrieve_vfp_datetime(bytes, fielddef, *ignore):
"""
returns the date/time stored in bytes; dates <= 01/01/1981 00:00:00
may not be accurate; BC dates are nulled.
"""
# two four-byte integers store the date and time.
# millesecords are discarded from time
if bytes == array('B', [0] * 8):
cls = fielddef[EMPTY]
if cls is NoneType:
return None
return cls()
cls = fielddef[CLASS]
time = unpack_long_int(bytes[4:])
microseconds = (time % 1000) * 1000
time = time // 1000 # int(round(time, -3)) // 1000 discard milliseconds
hours = time // 3600
mins = time % 3600 // 60
secs = time % 3600 % 60
time = datetime.time(hours, mins, secs, microseconds)
possible = unpack_long_int(bytes[:4])
possible -= VFPTIME
possible = max(0, possible)
date = datetime.date.fromordinal(possible)
return cls(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond)
def update_vfp_datetime(moment, *ignore):
"""
Sets the date/time stored in moment
moment must have fields:
year, month, day, hour, minute, second, microsecond
"""
data = [0] * 8
if moment:
hour = moment.hour
minute = moment.minute
second = moment.second
millisecond = moment.microsecond // 1000 # convert from millionths to thousandths
time = ((hour * 3600) + (minute * 60) + second) * 1000 + millisecond
data[4:] = update_integer(time)
data[:4] = update_integer(moment.toordinal() + VFPTIME)
return bytes(data)
def __new__(cls, year=None, month=0, day=0, hour=0, minute=0, second=0, microsecond=0):
"""year may be a datetime.datetime"""
if year is None or year is Null:
return cls._null_datetime
ndt = object.__new__(cls)
if isinstance(year, basestring):
return DateTime.strptime(year)
elif isinstance(year, (DateTime)):
ndt._datetime = year._datetime
elif isinstance(year, (datetime.datetime)):
microsecond = year.microsecond // 1000 * 1000
hour, minute, second = year.hour, year.minute, year.second
year, month, day = year.year, year.month, year.day
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
elif year is not None:
microsecond = microsecond // 1000 * 1000
ndt._datetime = datetime.datetime(year, month, day, hour, minute, second, microsecond)
return ndt
def __new__(cls, hour=None, minute=0, second=0, microsecond=0):
"""
hour may be a datetime.time or a str(Time)
"""
if hour is None or hour is Null:
return cls._null_time
nt = object.__new__(cls)
if isinstance(hour, basestring):
hour = Time.strptime(hour)
if isinstance(hour, (Time)):
nt._time = hour._time
elif isinstance(hour, (datetime.time)):
microsecond = hour.microsecond // 1000 * 1000
hour, minute, second = hour.hour, hour.minute, hour.second
nt._time = datetime.time(hour, minute, second, microsecond)
elif hour is not None:
microsecond = microsecond // 1000 * 1000
nt._time = datetime.time(hour, minute, second, microsecond)
return nt
def retrieve_vfp_datetime(bytes, fielddef, *ignore):
"""
returns the date/time stored in bytes; dates <= 01/01/1981 00:00:00
may not be accurate; BC dates are nulled.
"""
# two four-byte integers store the date and time.
# millesecords are discarded from time
if bytes == array('c', '\x00' * 8):
cls = fielddef[EMPTY]
if cls is NoneType:
return None
return cls()
cls = fielddef[CLASS]
time = unpack_long_int(bytes[4:])
microseconds = (time % 1000) * 1000
time = time // 1000 # int(round(time, -3)) // 1000 discard milliseconds
hours = time // 3600
mins = time % 3600 // 60
secs = time % 3600 % 60
time = datetime.time(hours, mins, secs, microseconds)
possible = unpack_long_int(bytes[:4])
possible -= VFPTIME
possible = max(0, possible)
date = datetime.date.fromordinal(possible)
return cls(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond)
def __asyncRequestWeatherData(self):
success = False
self.lastRequestedWeatherQueryTime = time.time()
while not success:
if not self.__isAlive:
return
try:
self.__weatherInfo = hourlyForecast(WEATHER_LOCATION[0], WEATHER_LOCATION[1], wundergroundApiKey)
success = True
except:
success = False
currTime = datetime.now()
print("FAIL: Weather request at {:02d}:{:02d}:{:02d}".format(currTime.hour, currTime.minute, currTime.second))
currTime = datetime.now()
print("SUCCESS: Weather request at {:02d}:{:02d}:{:02d}".format(currTime.hour, currTime.minute, currTime.second))
self.lastSuccessfulWeatherQueryTime = time.time()
self.newWeatherDataAvailable = True
def __asyncRequestDivisionData(self):
success = False
self.lastRequestedDivisionQueryTime = time.time()
while not success:
if not self.__isAlive:
return
try:
self.__divisionStandings = mlb.getDivisionStandings(DIVISION_OF_INTEREST)
self.__wildcardStandings = mlb.getDivisionStandings(WILDCARD_DIVISION_OF_INTEREST)
success = True
except:
currTime = datetime.now()
print("FAIL: Standings request at {:02d}:{:02d}:{:02d}".format(currTime.hour, currTime.minute, currTime.second))
success = False
currTime = datetime.now()
print("SUCCESS: Standings request at {:02d}:{:02d}:{:02d}".format(currTime.hour, currTime.minute, currTime.second))
self.lastSuccessfulDivisionQueryTime = time.time()
self.newDivisionDataAvailable = True
def get_timestamp_from_year_to_second(separator=False, date=None):
"""A compact timestamp.
Example: 20110523_234401 . date can be a datetime object.
If date is not specified, the current date and time (now) will be used."""
if date:
now = date
else:
now = datetime.now()
date = datetime.date(now)
time = datetime.time(now)
#return "%d-%02d-%02d @ %02dh%02d%02d" % (date.year, date.month, date.day, time.hour, time.minute, time.second)
template = "{year}{month:02}{day:02}_{hour:02}{minute:02}{second:02}"
if separator:
template = "{year}_{month:02}_{day:02}_{hour:02}{minute:02}{second:02}"
return template.format(year=date.year, month=date.month, day=date.day, hour=time.hour, minute=time.minute, second=time.second)
def get_time_string():
'''
Returns current time in day_month_HH-MM-SS/ format
'''
time = datetime.now()
name = (str(time.day) + '_' + str(time.month) + '_%02d' % time.hour +
'-%02d' % time.minute + '-%02d' % time.second + '/')
return name
def get_time():
'''
Returns current time in HH:MM:SS format
'''
time = datetime.now()
return '%02d' % time.hour + ':%02d' % time.minute + ':%02d' % time.second
def combine(cls, date, time):
if Date(date) and Time(time):
return cls(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond)
return cls()
def time(self):
if self:
return Time(self.hour, self.minute, self.second, self.microsecond)
return Time()
def __add__(self, other):
if self and isinstance(other, (datetime.timedelta)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
t += other
return Time(t.hour, t.minute, t.second, t.microsecond)
else:
return NotImplemented
def __repr__(self):
if self:
return "Time(%d, %d, %d, %d)" % (self.hour, self.minute, self.second, self.microsecond)
else:
return "Time()"
def __sub__(self, other):
if self and isinstance(other, (Time, datetime.time)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
o = datetime.datetime(2012, 6, 27, other.hour, other.minute, other.second, other.microsecond)
return t - o
elif self and isinstance(other, (datetime.timedelta)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
t -= other
return Time(t.hour, t.minute, t.second, t.microsecond)
else:
return NotImplemented
def replace(self, hour=None, minute=None, second=None, microsecond=None, delta_hour=0, delta_minute=0, delta_second=0):
if not self:
return self.__class__._null_time
old_hour, old_minute, old_second, old_micro = self.hour, self.minute, self.second, self.microsecond
hour = (hour or old_hour) + delta_hour
minute = (minute or old_minute) + delta_minute
second = (second or old_second) + delta_second
microsecond = microsecond or old_micro
while not (0 <= hour < 24) or not (0 <= minute < 60) or not (0 <= second < 60):
while second < 0:
minute -= 1
second = 60 + second
while second > 59:
minute += 1
second = second - 60
while minute < 0:
hour -= 1
minute = 60 + minute
while minute > 59:
hour += 1
minute = minute - 60
while hour < 1:
hour = 24 + hour
while hour > 23:
hour = hour - 24
return Time(hour, minute, second, microsecond)
def tofloat(self):
"returns Time as a float"
hour = self.hour
minute = self.minute * (1.0 / 60)
second = self.second * (1.0 / 3600)
microsecond = self.microsecond * (1.0 / 3600000)
return hour + minute + second + microsecond
def __init__(self, year=None, month=None, day=None, hour=None, minute=None, second=None, microsecond=None):
params = vars()
self._mask = {}
for attr in ('year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond'):
value = params[attr]
if value is not None:
self._mask[attr] = value
def combine(cls, date, time):
if Date(date) and Time(time):
return cls(date.year, date.month, date.day, time.hour, time.minute, time.second, time.microsecond)
return cls()
def time(self):
if self:
return Time(self.hour, self.minute, self.second, self.microsecond)
return Time()
def __add__(self, other):
if self and isinstance(other, (datetime.timedelta)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
t += other
return Time(t.hour, t.minute, t.second, t.microsecond)
else:
return NotImplemented
def __rsub__(self, other):
if self and isinstance(other, (Time, datetime.time)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
other = datetime.datetime(2012, 6, 27, other.hour, other.minute, other.second, other.microsecond)
other -= t
return other
else:
return NotImplemented
def __repr__(self):
if self:
return "Time(%d, %d, %d, %d)" % (self.hour, self.minute, self.second, self.microsecond)
else:
return "Time()"
def __sub__(self, other):
if self and isinstance(other, (Time, datetime.time)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
o = datetime.datetime(2012, 6, 27, other.hour, other.minute, other.second, other.microsecond)
return t - o
elif self and isinstance(other, (datetime.timedelta)):
t = self._time
t = datetime.datetime(2012, 6, 27, t.hour, t.minute, t.second, t.microsecond)
t -= other
return Time(t.hour, t.minute, t.second, t.microsecond)
else:
return NotImplemented
