def __new__(cls, *args, **kwargs):
# print("args: ", args)
yy = args[0]
mm = args[1:2][0] if args[1:2] else 0
dd = args[2:3][0] if args[2:3] else 0
hh = args[3:4][0] if args[3:4] else 0
mi = args[4:5][0] if args[4:5] else 0
ss = args[5:6][0] if args[5:6] else 0
ms = args[6:7][0] if args[6:7] else 0
tz = args[7:8][0] if args[7:8] else timezone.utc
if isinstance(args[0], str):
yy = parse(args[0])
if isinstance(yy, datetime):
tz = yy.tzinfo if yy.tzinfo else timezone.utc
ms = yy.microsecond
ss = yy.second
mi = yy.minute
if isinstance(yy, date) or isinstance(yy, datetime):
hh = yy.hour
dd = yy.day
mm = yy.month
yy = yy.year
vals = tuple([yy, mm, dd, hh, mi, ss, ms, tz])
try:
return datetime.__new__(cls, *vals, **kwargs)
except:
vals = tuple([1900, 1, 1, 0, 0, 0, 0])
return datetime.__new__(cls, *vals)
def __new__(cls, dt=None, *args, **kwargs):
if isinstance(dt, datetime):
if type(dt) is cls:
return dt
return datetime.__new__(cls,
dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, dt.tzinfo)
return datetime.__new__(cls, dt, *args, **kwargs)
def __new__(cls, *args, **kwargs):
# print("args: ", args)
yy = args[0]
mm = args[1:2][0] if args[1:2] else 0
dd = args[2:3][0] if args[2:3] else 0
hh = args[3:4][0] if args[3:4] else 0
mi = args[4:5][0] if args[4:5] else 0
ss = args[5:6][0] if args[5:6] else 0
ms = args[6:7][0] if args[6:7] else 0
tz = args[7:8][0] if args[7:8] else timezone.utc
if isinstance(args[0], str):
yy = parse(args[0])
if isinstance(yy, datetime):
tz = yy.tzinfo if yy.tzinfo else timezone.utc
ms = yy.microsecond
ss = yy.second
mi = yy.minute
if isinstance(yy, date) or isinstance(yy, datetime):
hh = yy.hour
dd = yy.day
mm = yy.month
yy = yy.year
vals = tuple([yy, mm, dd, hh, mi, ss, ms, tz])
try:
return datetime.__new__(cls, *vals, **kwargs)
except:
vals = tuple([1900, 1, 1, 0, 0, 0, 0])
return datetime.__new__(cls, *vals)
def __new__(cls, year=1980, month=1, day=6, hour=0, minute=0, second=0,
microsecond=0, tzinfo=gpstz):
if isinstance(year, str) and isinstance(month, TZInfo):
return datetime.__new__(cls, year, month)
elif isinstance(year, str):
return datetime.__new__(cls, year)
return datetime.__new__(cls, year, month, day, hour, minute, second,
int(microsecond), tzinfo)
def __new__(cls, val, *args):
# The constructor may be called in various ways:
# - T(str), to explicitly convert from a time string
# - T(datetime), to explicitly convert from a datetime
# - T(int, int, int, int, int, int, int, tzinfo),
# used by __add__ and __sub__ in Python 3.8
# - T(bytes, tzinfo), used by pickle.loads
# Only the first two (single argument) forms should be used by
# applications.
if args:
return datetime.__new__(cls, val, *args)
if isinstance(val, datetime):
tz = val.tzinfo
if tz is None:
raise TypeError('missing timezone')
return datetime.__new__(
cls,
year = val.year,
month = val.month,
day = val.day,
hour = val.hour,
minute = val.minute,
second = val.second,
microsecond = val.microsecond,
tzinfo = tz)
m = T._pattern.match(val)
if m is None:
raise ValueError('malformed timestamp string %r' % (val,))
second = int(m.group(6))
microsecond = round(float(m.group(7) or 0) * 1000000)
# datetime doesn't support leap seconds, and DWC probably
# doesn't support them either, but allow for the possibility
# here just in case. If there is a leap second, it is
# silently compressed into the final millisecond of the
# preceding second; this will result in one or more
# discontinuities in the record time map.
if second == 60:
second = 59
microsecond = 999000 + microsecond // 1000
tzs = 1 if m.group(8) == '+' else -1
tz = timezone(timedelta(hours = tzs * int(m.group(9)),
minutes = tzs * int(m.group(10))))
return datetime.__new__(
cls,
year = int(m.group(1)),
month = int(m.group(2)),
day = int(m.group(3)),
hour = int(m.group(4)),
minute = int(m.group(5)),
second = second,
microsecond = microsecond,
tzinfo = tz)
def __new__(cls, string_or_year, *mdhms):
"""Create a new :class:`modeled.datetime` instance
by giving either a
"""
if isstring(string_or_year):
dt = base.strptime(string_or_year, cls.format)
return base.__new__(cls, *dt.timetuple()[:6])
return base.__new__(cls, string_or_year, *mdhms)
def __new__(cls, string_or_year, *mdhms):
"""Create a new :class:`modeled.datetime` instance
by giving either a
"""
if isstring(string_or_year):
dt = base.strptime(string_or_year, cls.format)
return base.__new__(cls, *dt.timetuple()[:6])
return base.__new__(cls, string_or_year, *mdhms)
def __new__(cls, val, *args, **kwargs):
if isinstance(val, str):
date = datetime.strptime(val, "%Y-%m-%dT%H:%M:%S%z")
return datetime.__new__(cls,
date.year,
date.month,
date.day,
date.hour,
date.minute,
date.second,
tzinfo=date.tzinfo)
else:
return datetime.__new__(cls, val, *args, **kwargs)
def __new__(cls,
year=1980,
month=1,
day=6,
hour=0,
minute=0,
second=0,
microsecond=0,
tzinfo=gpstz):
if isinstance(year, str) and isinstance(month, TZInfo):
return datetime.__new__(cls, year, month)
elif isinstance(year, str):
return datetime.__new__(cls, year)
return datetime.__new__(cls, year, month, day, hour, minute, second,
int(microsecond), tzinfo)
def __new__(cls, *args, **kw):
if len(args) == 1:
value = args[0]
if isinstance(value, cls):
return value
elif isinstance(value, basestring):
value = dateutil.parser.parse(value)
return cls(value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond, value.tzinfo)
elif isinstance(value, datetime):
return cls(value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond, value.tzinfo or tzlocal())
else:
return datetime.__new__(cls, *args, **kw)
else:
if len(args) < 8 and 'tzinfo' not in kw:
kw['tzinfo'] = tzlocal()
return datetime.__new__(cls, *args, **kw)
def __new__(
cls,
year: int,
month: int,
day: int,
hour: int,
minute: int,
second: int,
microsecond: int,
tzinfo: Optional[tzinfo],
*_: Any,
**kwargs: Any,
) -> datetime:
return datetime.__new__(
cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo=tzinfo,
**kwargs,
)
def __new__(cls, dt=datetime.now()):
if not isinstance(dt, datetime):
raise TypeError("Wrong type. Should be Datetime")
self = datetime.__new__(cls, dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second, dt.microsecond)
self._dt = dt
return self
def __new__(
cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo,
trivia,
raw,
**kwargs
): # type: (int, int, int, int, int, int, int, ..., Trivia, ...) -> datetime
return datetime.__new__(
cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo=tzinfo,
**kwargs
)
def __new__(cls, initial=None):
""" Create a CUI compliant DateTime Object, from the initial value
initial : Either
numeric - a timestamps of seconds since 1970-01-01 00:00
datetime - a value derived from the datetime module
string - a text value in nhs standard format (e.g. 01-Jan-1970 01:20)
if initial is not provided - defaults to now()
"""
initial_date = None
if initial is None:
initial_date = datetime.now()
if isinstance(initial, Real):
initial_date = datetime.utcfromtimestamp(initial)
if isinstance(initial, str):
initial_date = datetime.strptime(initial, '%d-%b-%Y %H:%M')
if isinstance(initial, datetime):
initial_date = initial
if initial_date is None:
raise ValueError(
'Invalid value for initial argument - must be a numeric, string, datetime, Callable or None')
return datetime.__new__(cls, initial_date.year, initial_date.month, initial_date.day,
initial_date.hour, initial_date.minute, initial_date.second, initial_date.microsecond,
initial_date.tzinfo)
def __new__(cls, *args, **kw):
if len(args) == 1:
value = args[0]
if isinstance(value, cls):
return value
elif isinstance(value, basestring):
value = dateutil.parser.parse(value)
return cls(value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond, value.tzinfo)
elif isinstance(value, datetime):
return cls(value.year, value.month, value.day, value.hour, value.minute, value.second, value.microsecond, value.tzinfo or tzlocal())
else:
return datetime.__new__(cls, *args, **kw)
else:
if len(args) < 8 and 'tzinfo' not in kw:
kw['tzinfo'] = tzlocal()
return datetime.__new__(cls, *args, **kw)
def __new__(cls,
year=1970,
month=1,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0,
tzinfo=None):
if tzinfo and isinstance(tzinfo, string_types):
tzinfo = pytz.timezone(tzinfo)
naive = datetime(year, month, day, hour, minute, second, microsecond)
if hasattr(tzinfo, 'localize'):
dt = tzinfo.localize(naive, is_dst=None)
elif tzinfo:
dt = naive.replace(tzinfo=tzinfo)
else:
dt = pytz.UTC.localize(naive, is_dst=None)
dt = dt.astimezone(pytz.UTC)
return datetime.__new__(cls,
dt.year,
dt.month,
dt.day,
dt.hour,
dt.minute,
dt.second,
dt.microsecond,
dt.tzinfo)
def __new__(cls, *args, **kargs):
if isinstance(args[0], pydatetime):
return args[0]
try:
return parser.parse(*args, **kargs)
except TypeError:
return pydatetime.__new__(cls, *args, **kargs)
def __new__(
cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo,
trivia,
raw,
**kwargs
): # type: (int, int, int, int, int, int, int, Optional[datetime.tzinfo], Trivia, str, Any) -> datetime
return datetime.__new__(
cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo=tzinfo,
**kwargs
)
def __new__(cls, month=1, day=1, hour=0, minute=0):
"""Create Ladybug datetime."""
try:
return datetime.__new__(cls, 2015, month, day, hour, minute)
except ValueError as e:
raise ValueError("{} > ({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute))
def __new__(cls, val, _tz=None):
if isinstance(val, datetime):
tz = val.tzinfo
if tz is None:
raise TypeError('missing timezone')
return datetime.__new__(cls,
year=val.year,
month=val.month,
day=val.day,
hour=val.hour,
minute=val.minute,
second=val.second,
microsecond=val.microsecond,
tzinfo=tz)
elif isinstance(val, bytes) and isinstance(_tz, timezone):
return datetime.__new__(cls, val, _tz)
m = T._pattern.match(val)
if m is None:
raise ValueError('malformed timestamp string')
second = int(m.group(6))
microsecond = round(float(m.group(7)) * 1000000)
# datetime doesn't support leap seconds, and DWC probably
# doesn't support them either, but allow for the possibility
# here just in case. If there is a leap second, it is
# silently compressed into the final millisecond of the
# preceding second; this will result in one or more
# discontinuities in the record time map.
if second == 60:
second = 59
microsecond = 999000 + microsecond // 1000
tzs = 1 if m.group(8) == '+' else -1
tz = timezone(
timedelta(hours=tzs * int(m.group(9)),
minutes=tzs * int(m.group(10))))
return datetime.__new__(cls,
year=int(m.group(1)),
month=int(m.group(2)),
day=int(m.group(3)),
hour=int(m.group(4)),
minute=int(m.group(5)),
second=second,
microsecond=microsecond,
tzinfo=tz)
def __new__(self, *args, **kwargs):
if len(args) == 1:
args = parse(args[0]).timetuple()[:6]
if len(args) > 2:
if args[2] == 99:
args = list(args)
args[2] = calendar.monthrange(args[0], args[1])[1]
return basedatetime.__new__(self, *args, **kwargs)
def __new__(cls,*args,**kargs):
"""
Adds a new types of constructors for up-casting from a datetime object.
AstroTime(datetime=dt)
AstroTime(datetime=dt,deltasecs=+33)
"""
if (len(args) == 0 and 'datetime' in kargs and
(len(kargs) == 1 or (len(kargs) == 2 and 'deltasecs' in kargs))):
if not isinstance(kargs['datetime'],datetime):
raise AstroTimeException('expect datetime instance')
deltasecs = kargs['deltasecs'] if 'deltasecs' in kargs else 0
dt = kargs['datetime'] + timedelta(seconds=deltasecs)
return datetime.__new__(cls,dt.year,dt.month,dt.day,
dt.hour,dt.minute,dt.second,dt.microsecond,dt.tzinfo)
else:
return datetime.__new__(cls,*args,**kargs)
def __new__(self, *args, **kwargs):
if len(args) == 1:
args = parse(args[0]).timetuple()[:6]
if len(args) > 2:
if args[2] == 99:
args = list(args)
args[2] = calendar.monthrange(args[0], args[1])[1]
return basedatetime.__new__(self, *args, **kwargs)
def __new__(cls, *args, **kargs):
"""
Extends constructor to support up-casting from a datetime object.
AstroTime(datetime=dt)
AstroTime(datetime=dt,deltasecs=+33)
"""
if (len(args) == 0 and 'datetime' in kargs and
(len(kargs) == 1 or (len(kargs) == 2 and 'deltasecs' in kargs))):
if not isinstance(kargs['datetime'], datetime):
raise AstroTimeException('expect datetime instance')
deltasecs = kargs['deltasecs'] if 'deltasecs' in kargs else 0
dt = kargs['datetime'] + timedelta(seconds=deltasecs)
return datetime.__new__(cls, dt.year, dt.month, dt.day, dt.hour,
dt.minute, dt.second, dt.microsecond,
dt.tzinfo)
else:
return datetime.__new__(cls, *args, **kargs)
def __new__(cls, month=1, day=1, hour=0, minute=0):
"""Create Ladybug datetime."""
hour, minute = cls._calculateHourAndMinute(hour + minute / 60.0)
try:
return datetime.__new__(cls, 2015, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute
))
def __new__(cls, month=1, day=1, hour=0, minute=0, leap_year=False):
"""Create Ladybug datetime.
"""
year = 2016 if leap_year else 2017
hour, minute = Time._calculate_hour_and_minute(hour + minute / 60.0)
try:
return datetime.__new__(cls, year, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute))
def __new__(self, arg):
if arg is None:
return None;
if isinstance(arg, int) or isinstance(arg, long) or isinstance(arg, float):
tmp = datetime.utcfromtimestamp(arg)
else:
tmp = datetime.utcfromtimestamp(arg.getTime() / 1000)
return datetime.__new__(self, tmp.year,tmp.month,
tmp.day, tmp.hour, tmp.minute, tmp.second)
def __new__(self, arg):
if arg is None:
return None;
if isinstance(arg, int) or isinstance(arg, long) or isinstance(arg, float):
tmp = datetime.utcfromtimestamp(arg)
else:
tmp = datetime.utcfromtimestamp(arg.getTime() / 1000)
return datetime.__new__(self, tmp.year,tmp.month,
tmp.day, tmp.hour, tmp.minute, tmp.second, tzinfo=GMT_ZONE)
def __new__(cls, value, *args, **kwargs):
if isinstance(value, cls):
return value
elif isinstance(value, datetime):
return cls(value.year, month=value.month, day=value.day,
hour=value.hour, minute=value.minute, second=value.second,
microsecond=value.microsecond)
elif isinstance(value, basestring):
return cls.parse(value)
else:
return datetime.__new__(cls, value, *args, **kwargs)
def __new__(cls, *args, **kwargs):
if cls._LOCAL_TIMEZONE is None:
raise NotImplementedError("Do not use the AccDatetime class, "
"but one of its children.")
if len(args) == 1 and isinstance(args[0], datetime):
dt = args[0]
else:
dt = datetime.__new__(cls, *args, **kwargs)
if dt.tzinfo is None:
dt = dt.replace(tzinfo=tz.tzutc())
return datetime.__new__(cls,
dt.year,
dt.month,
dt.day,
dt.hour,
dt.minute,
dt.second,
dt.microsecond,
tzinfo=dt.tzinfo)
def __new__(cls, year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, is_dst=False):
"""Creates a localized timestamp with the given parameters.
If tzinfo is omitted, the default time zone will be used."""
if tzinfo == None:
tzinfo = _default_tz
dt = _datetime(year, month, day, hour, minute, second, microsecond)
dt = tzinfo.localize(dt, is_dst=is_dst)
return _datetime.__new__(
cls, dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, dt.tzinfo
)
def __new__(cls, value, *_): # type: (datetime, ...) -> datetime
return datetime.__new__(
cls,
value.year,
value.month,
value.day,
value.hour,
value.minute,
value.second,
value.microsecond,
tzinfo=value.tzinfo,
)
def __new__(cls,
year,
month=None,
day=None,
hour=0,
minute=0,
second=0,
microsecond=0,
tzinfo=None):
if tzinfo is None:
raise ValueError('tzinfo must be specified')
return datetime.__new__(cls, year, month, day, hour, minute, second,
microsecond, tzinfo)
def __new__(cls, year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, is_dst=False):
"""Creates a localized timestamp with the given parameters.
If tzinfo is omitted, the default time zone will be used."""
if tzinfo == None:
tzinfo = _default_tz
dt = _datetime(year, month, day, hour, minute, second, microsecond)
dt = tzinfo.localize(dt, is_dst=is_dst)
return _datetime.__new__(
cls, dt.year, dt.month, dt.day,
dt.hour, dt.minute, dt.second,
dt.microsecond, dt.tzinfo)
def __new__(cls, source):
if isinstance(source, datetime):
return datetime.__new__(cls,
source.year,
source.month,
source.day,
source.hour,
source.minute,
source.second,
source.microsecond,
source.tzinfo,
fold=source.fold)
return super().__new__(cls, source)
def __new__(cls, month=1, day=1, hour=0, minute=0):
"""Create Ladybug datetime.
Returns: a datetime object, 2015, Jan 01 00h 00m by default
"""
hour, minute = cls._calculateHourAndMinute(hour + minute / 60.0)
try:
# super().__new__()
return datetime.__new__(cls, 2015, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute
))
def __new__(cls, month=1, day=1, hour=0, minute=0):
"""Create Ladybug datetime.
Args:
month: A value for month between 1-12. (Defualt: 1)
day: A value for day between 1-31. (Defualt: 1)
hour: A value for hour between 0-23. (Defualt: 0)
minute: A value for month between 0-59. (Defualt: 0)
"""
hour, minute = cls._calculate_hour_and_minute(hour + minute / 60.0)
try:
return datetime.__new__(cls, 2017, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute))
def __new__(cls, year, month, day, hour=None, minute=None, second=None,
microsecond=None, tzinfo=None):
if tzinfo is None:
kwargs = {'tzinfo':cls.localTZ()}
else:
kwargs = {'tzinfo':tzinfo}
if hour is not None:
kwargs['hour'] = hour
if minute is not None:
kwargs['minute'] = minute
if second is not None:
kwargs['second'] = second
if microsecond is not None:
kwargs['microsecond'] = microsecond
return _pydatetime.__new__(cls, year, month, day, **kwargs)
def __new__(cls, year, month, day, hour=None, minute=None, second=None,
microsecond=None, tzinfo=None):
if tzinfo is None:
kwargs = {'tzinfo':cls.localTZ()}
else:
kwargs = {'tzinfo':tzinfo}
if hour is not None:
kwargs['hour'] = hour
if minute is not None:
kwargs['minute'] = minute
if second is not None:
kwargs['second'] = second
if microsecond is not None:
kwargs['microsecond'] = microsecond
return _pydatetime.__new__(cls, year, month, day, **kwargs)
def __new__(cls, month=1, day=1, hour=0, minute=0, leap_year=False):
"""Create Ladybug datetime.
Args:
month: A value for month between 1-12 (Defualt: 1).
day: A value for day between 1-31 (Defualt: 1).
hour: A value for hour between 0-23 (Defualt: 0).
minute: A value for month between 0-59 (Defualt: 0).
leap_year: A boolean to indicate if datetime is for a leap year
(Default: False).
"""
year = 2016 if leap_year else 2017
hour, minute = cls._calculate_hour_and_minute(hour + minute / 60.0)
try:
return datetime.__new__(cls, year, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute))
def __new__(cls, month=1, day=1, hour=0, minute=0, leap_year=False):
"""Create Ladybug datetime.
Args:
month: A value for month between 1-12 (Defualt: 1).
day: A value for day between 1-31 (Defualt: 1).
hour: A value for hour between 0-23 (Defualt: 0).
minute: A value for month between 0-59 (Defualt: 0).
leap_year: A boolean to indicate if datetime is for a leap year
(Default: False).
"""
year = 2016 if leap_year else 2017
hour, minute = cls._calculate_hour_and_minute(hour + minute / 60.0)
try:
return datetime.__new__(cls, year, month, day, hour, minute)
except ValueError as e:
raise ValueError("{}:\n\t({}/{}@{}:{})(m/d@h:m)".format(
e, month, day, hour, minute
))
def __new__(cls, *args, **kwargs):
return datetime.__new__(datetime, *args, **kwargs)
def __new__(cls, *args, **kwargs):
if len(args) == 1:
if isinstance(args[0], basetime):
args = (basedatetime.combine(basedatetime.today(), args[0]), )
args = parse(args[0]).timetuple()[:6]
return basedatetime.__new__(cls, *args, **kwargs)
def __new__(cls, *args, **kwargs):
if len(args) == 1:
if isinstance(args[0], basetime):
args = (basedatetime.combine(basedatetime.today(), args[0]), )
args = parse(args[0]).timetuple()[:6]
return basedatetime.__new__(cls, *args, **kwargs)
def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0, microsecond=0, tzinfo=None):
if tzinfo is None:
raise ValueError('tzinfo must be specified')
return datetime.__new__(cls, year, month, day, hour, minute, second, microsecond, tzinfo)
def __new__(cls,
year=1970,
month=1,
day=1,
hour=0,
minute=0,
second=0,
microsecond=0,
tzinfo=None,
*,
fold=0):
if (isinstance(year, bytes) and
len(year) == 10 and
1 <= year[2] & 0x7F <= 12):
# Pickle support.
return cls.fromdatetime(datetime(year, month))
elif isinstance(year, dict):
obj = {key: value for key, value in year.items()
if key in DATETIME_ATTRS}
return cls(**obj)
extra = {'fold': fold} if FOLD_AVAILABLE else {}
if tzinfo:
# If tzinfo is provided, we first need to create a stdlib datetime
# with that tzinfo. Then, we need to convert it to UTC and extract
# the datetime properites from it so we can then create a Zulu
# datetime object. We use the stdlib datetime to avoid potential
# infinite recursion issues if we instead created a Zulu datetime
# and tried to shift it to UTC.
tzinfo = parser.get_timezone(tzinfo)
if hasattr(tzinfo, 'localize'):
# Support pytz timezones.
dt = tzinfo.localize(datetime(year,
month,
day,
hour,
minute,
second,
microsecond,
**extra),
is_dst=None)
else:
dt = datetime(year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo,
**extra)
if dt.utcoffset() != timedelta(0):
dt = dt.astimezone(UTC)
year = dt.year
month = dt.month
day = dt.day
hour = dt.hour
minute = dt.minute
second = dt.second
microsecond = dt.microsecond
tzinfo = dt.tzinfo
if FOLD_AVAILABLE: # pragma: no cover
fold = extra['fold'] = dt.fold
else:
tzinfo = UTC
return datetime.__new__(cls,
year,
month,
day,
hour,
minute,
second,
microsecond,
tzinfo,
**extra)
