def value(self):
"""
Returns the value for this BoundField, using the initial value if
the form is not bound or the data otherwise.
"""
if not self.form.is_bound:
data = self.form.initial.get(self.name, self.field.initial)
if callable(data):
if self._initial_value is not UNSET:
data = self._initial_value
else:
data = data()
# If this is an auto-generated default date, nix the
# microseconds for standardized handling. See #22502.
if (isinstance(data, (datetime.datetime, datetime.time)) and
not self.field.widget.supports_microseconds):
data = data.replace(microsecond=0)
self._initial_value = data
else:
data = self.field.bound_data(
self.data, self.form.initial.get(self.name, self.field.initial)
)
return self.field.prepare_value(data)
python类time()的实例源码
def adapt_unknown_value(self, value):
"""
Transforms a value to something compatible with the backend driver.
This method only depends on the type of the value. It's designed for
cases where the target type isn't known, such as .raw() SQL queries.
As a consequence it may not work perfectly in all circumstances.
"""
if isinstance(value, datetime.datetime): # must be before date
return self.adapt_datetimefield_value(value)
elif isinstance(value, datetime.date):
return self.adapt_datefield_value(value)
elif isinstance(value, datetime.time):
return self.adapt_timefield_value(value)
elif isinstance(value, decimal.Decimal):
return self.adapt_decimalfield_value(value)
else:
return value
def executemany(self, sql, param_list):
start = time()
try:
return super(CursorDebugWrapper, self).executemany(sql, param_list)
finally:
stop = time()
duration = stop - start
try:
times = len(param_list)
except TypeError: # param_list could be an iterator
times = '?'
self.db.queries_log.append({
'sql': '%s times: %s' % (times, sql),
'time': "%.3f" % duration,
})
logger.debug('(%.3f) %s; args=%s' % (duration, sql, param_list),
extra={'duration': duration, 'sql': sql, 'params': param_list}
)
###############################################
# Converters from database (string) to Python #
###############################################
def get_prep_value(self, value):
value = super(DateTimeField, self).get_prep_value(value)
value = self.to_python(value)
if value is not None and settings.USE_TZ and timezone.is_naive(value):
# For backwards compatibility, interpret naive datetimes in local
# time. This won't work during DST change, but we can't do much
# about it, so we let the exceptions percolate up the call stack.
try:
name = '%s.%s' % (self.model.__name__, self.name)
except AttributeError:
name = '(unbound)'
warnings.warn("DateTimeField %s received a naive datetime (%s)"
" while time zone support is active." %
(name, value),
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(value, default_timezone)
return value
def localize(value, use_l10n=None):
"""
Checks if value is a localizable type (date, number...) and returns it
formatted as a string using current locale format.
If use_l10n is provided and is not None, that will force the value to
be localized (or not), overriding the value of settings.USE_L10N.
"""
if isinstance(value, bool):
return mark_safe(six.text_type(value))
elif isinstance(value, (decimal.Decimal, float) + six.integer_types):
return number_format(value, use_l10n=use_l10n)
elif isinstance(value, datetime.datetime):
return date_format(value, 'DATETIME_FORMAT', use_l10n=use_l10n)
elif isinstance(value, datetime.date):
return date_format(value, use_l10n=use_l10n)
elif isinstance(value, datetime.time):
return time_format(value, 'TIME_FORMAT', use_l10n=use_l10n)
else:
return value
def localize_input(value, default=None):
"""
Checks if an input value is a localizable type and returns it
formatted with the appropriate formatting string of the current locale.
"""
if isinstance(value, (decimal.Decimal, float) + six.integer_types):
return number_format(value)
elif isinstance(value, datetime.datetime):
value = datetime_safe.new_datetime(value)
format = force_str(default or get_format('DATETIME_INPUT_FORMATS')[0])
return value.strftime(format)
elif isinstance(value, datetime.date):
value = datetime_safe.new_date(value)
format = force_str(default or get_format('DATE_INPUT_FORMATS')[0])
return value.strftime(format)
elif isinstance(value, datetime.time):
format = force_str(default or get_format('TIME_INPUT_FORMATS')[0])
return value.strftime(format)
return value
def parse_time(value):
"""Parses a string and return a datetime.time.
This function doesn't support time zone offsets.
Raises ValueError if the input is well formatted but not a valid time.
Returns None if the input isn't well formatted, in particular if it
contains an offset.
"""
match = time_re.match(value)
if match:
kw = match.groupdict()
if kw['microsecond']:
kw['microsecond'] = kw['microsecond'].ljust(6, '0')
kw = {k: int(v) for k, v in six.iteritems(kw) if v is not None}
return datetime.time(**kw)
def display_for_value(value, empty_value_display, boolean=False):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
if boolean:
return _boolean_icon(value)
elif value is None:
return empty_value_display
elif isinstance(value, datetime.datetime):
return formats.localize(timezone.template_localtime(value))
elif isinstance(value, (datetime.date, datetime.time)):
return formats.localize(value)
elif isinstance(value, six.integer_types + (decimal.Decimal, float)):
return formats.number_format(value)
elif isinstance(value, (list, tuple)):
return ', '.join(force_text(v) for v in value)
else:
return smart_text(value)
def getDaysFromTimes(times):
days = set()
for time in times:
try:
for day in time.get("days"):
if type(day) == int:
days.add(day % 7)
except:
pass
return sorted(days)
##
## @brief Convert days to their text representation in a list.
##
## @param days (int)(list) The days
##
## @return A list of strings.
##
def parse_time(time_string):
try:
return datetime.datetime.strptime(time_string, "%I:%M%p").time()
except:
pass
try:
return datetime.datetime.strptime(time_string, "%H:%M").time()
except:
return None
##
## @brief Get the mini term.
##
## @return (int) The current mini if no date is provided.
##
def db_value(self, value):
if value is None:
return
if isinstance(value, datetime.datetime):
pass
elif isinstance(value, datetime.date):
value = datetime.datetime(value.year, value.month, value.day)
else:
return int(round(value * self.resolution))
if self.utc:
timestamp = calendar.timegm(value.utctimetuple())
else:
timestamp = time.mktime(value.timetuple())
timestamp += (value.microsecond * .000001)
if self.resolution > 1:
timestamp *= self.resolution
return int(round(timestamp))
def __init__(self):
"""SecurityOptions()
Initialize.
"""
# I don't believe any of these types can ever pose a security hazard,
# except perhaps "reference"...
self.allowedTypes = {"None": 1,
"bool": 1,
"boolean": 1,
"string": 1,
"str": 1,
"int": 1,
"float": 1,
"datetime": 1,
"time": 1,
"date": 1,
"timedelta": 1,
"NoneType": 1}
if hasattr(types, 'UnicodeType'):
self.allowedTypes['unicode'] = 1
self.allowedModules = {}
self.allowedClasses = {}
def occurrences(self):
import datetime
from dateutil import rrule
datelist = []
if self.rrule:
rr = rrule.rrulestr(self.rrule, dtstart=self.start_date)
start = datetime.datetime.combine(self.start_date, datetime.datetime.min.time())
end = start + datetime.timedelta(days=365)
datelist = rr.between(start, end, inc=True)
else:
if self.start_date >= datetime.date.today():
datelist.append(datetime.datetime.combine(self.start_date, datetime.time(0, 0, 0)))
if not self.start_time:
return datelist
return [datetime.datetime.combine(x.date(), self.start_time) for x in datelist]
def format_time(hour_tuple):
"""
Convert to a 12hour time
"""
hour = hour_tuple[0]
duration = hour_tuple[1]
if hour is None:
return ''
elif isinstance(hour, datetime.time):
time = _parse_time_to_string(hour)
if duration:
end_hour = _add_minutes(hour, duration)
end_time = _parse_time_to_string(end_hour)
time = '%s - %s' % (time, end_time)
return time
else:
try:
if hour < 12:
return "%s AM" % str(hour)
elif hour == 12:
return "%s PM" % str(hour)
else:
return "%s PM" % str(hour - 12)
except ValueError:
return hour
def make_schedule_array(event):
"""
Convert an event's schedules into a schedule_array
"""
# Since the schedules in the event are time-fixed, events with multiple
# times will have the same start_date, rrule and place combination
# This groups the times according to the start_date/rrule combination
# {
# (<start_date>, "<rrule>", <place>): [<start_time>, ]
# }
schedules = OrderedDict()
for s in event.dates.all().order_by("start_date", "start_time"):
key = (s.start_date, s.rrule, s.place, s.more_info_url)
if key in schedules:
schedules[key].append((s.start_time, s.duration))
else:
schedules[key] = [(s.start_time, s.duration), ]
return schedules
def at(self, time_str):
"""Schedule the job every day at a specific time.
Calling this is only valid for jobs scheduled to run every
N day(s).
"""
assert self.unit in ('days', 'hours') or self.start_day
hour, minute = time_str.split(':')
minute = int(minute)
if self.unit == 'days' or self.start_day:
hour = int(hour)
assert 0 <= hour <= 23
elif self.unit == 'hours':
hour = 0
assert 0 <= minute <= 59
self.at_time = datetime.time(hour, minute)
return self
def do(self, job_func, *args, **kwargs):
"""Specifies the job_func that should be called every time the
job runs.
Any additional arguments are passed on to job_func when
the job runs.
"""
self.job_func = functools.partial(job_func, *args, **kwargs)
try:
functools.update_wrapper(self.job_func, job_func)
except AttributeError:
# job_funcs already wrapped by functools.partial won't have
# __name__, __module__ or __doc__ and the update_wrapper()
# call will fail.
pass
self._schedule_next_run()
return self
def get_time_interval_to_message_statistic(self, time_interval,
message_statistic):
"""
Maps each value of time interval to the sum of the values of a message
statistic over all messages from that time interval value. Wrapper
function for the functions 'get_' + time_interval.replace(' ', '_') +
'_to_message_statistic'.
Args:
time_interval: One of 'minute in hour', 'minute in day', 'hour',
'date', 'week', 'month', 'year'.
message_statistic: A function mapping a Message object to an int or
a float.
Returns:
time_interval_to_message_statistic: A dict mapping each value of a
time interval to the sum of the values of message_statistic
over all messages in self.messages from that time interval
value.
"""
if time_interval not in self.TIME_INTERVALS:
raise ValueError('time_interval must be in {}'.format(self.TIME_INTERVALS))
getter = getattr(self, 'get_' + time_interval.replace(' ', '_') + '_to_message_statistic')
time_interval_to_message_statistic = getter(message_statistic)
return time_interval_to_message_statistic
def ensure_utc(time, tz='UTC'):
"""
Normalize a time. If the time is tz-naive, assume it is UTC.
"""
if not time.tzinfo:
time = time.replace(tzinfo=pytz.timezone(tz))
return time.replace(tzinfo=pytz.utc)
def _build_time(time, kwargs):
"""
Builds the time argument for event rules.
"""
tz = kwargs.pop('tz', 'UTC')
if time:
if kwargs:
raise ValueError('Cannot pass kwargs and a time')
else:
return ensure_utc(time, tz)
elif not kwargs:
raise ValueError('Must pass a time or kwargs')
else:
return datetime.time(**kwargs)
