def test_parse_isodate_error_text():
with pytest.raises(ValueError) as excinfo:
isoparser().parse_isodate('2014-0423')
# ensure the error message does not contain b' prefixes
if six.PY2:
expected_error = "String contains unknown ISO components: u'2014-0423'"
else:
expected_error = "String contains unknown ISO components: '2014-0423'"
assert expected_error == str(excinfo.value)
def search_yt_title_artist(track_name: str, artist_name: str) -> dict:
search_query = track_name + " " + artist_name
api_key = getenv("GOOGLE_APPLICATION_CREDENTIALS")
api_client = googleapiclient.discovery.build("youtube",
"v3",
developerKey=api_key,
cache_discovery=False)
request = api_client.search().list(part=["id"], q=search_query)
response = request.execute()
# first 5 items
items = response['items']
for item in items:
kind_id = item['id']['kind']
if kind_id == 'youtube#video':
video_id = item['id']['videoId']
video_request = api_client.videos().list(
part=["snippet", "statistics", "status"], id=video_id)
video_response = video_request.execute()
video = video_response['items'][0]
return {
"youtube": {
"title": video["snippet"]["title"],
"views": video["statistics"]["viewCount"],
"posted_date": isoparser(video["snippet"]["publishedAt"]),
"converted_link":
f"https://www.youtube.com/watch?v={video_id}",
"embeddable": video["status"]["embeddable"]
}
}
def test_isoparser_byte_sep(): #pragma: no cover
dt = datetime(2017, 12, 6, 12, 30, 45) #pragma: no cover
dt_str = dt.isoformat(sep=str('T')) #pragma: no cover
dt_rt = isoparser(sep=b'T').isoparse(dt_str) #pragma: no cover
assert dt == dt_rt #pragma: no cover
def test_isoparser_byte_sep():
dt = datetime(2017, 12, 6, 12, 30, 45)
dt_str = dt.isoformat(sep=str('T'))
dt_rt = isoparser(sep=b'T').isoparse(dt_str)
assert dt == dt_rt
def test_isoparser_byte_sep():
dt = datetime(2017, 12, 6, 12, 30, 45)
dt_str = dt.isoformat(sep=str('T'))
dt_rt = isoparser(sep=b'T').isoparse(dt_str)
assert dt == dt_rt
def get_extra_attrs(self) -> dict:
return {
"youtube": {
"title": self.api_data["snippet"]["title"],
"views": self.api_data["statistics"]["viewCount"],
"posted_date": isoparser(self.api_data["snippet"]["publishedAt"]),
}
}
def test_parse_isodate(d, dt_fmt, as_bytes):
d_str = d.strftime(dt_fmt)
if isinstance(d_str, six.text_type) and as_bytes:
d_str = d_str.encode('ascii')
elif isinstance(d_str, six.binary_type) and not as_bytes:
d_str = d_str.decode('ascii')
iparser = isoparser()
assert iparser.parse_isodate(d_str) == d
def test_parse_isodate(d, dt_fmt, as_bytes):
d_str = d.strftime(dt_fmt)
if isinstance(d_str, six.text_type) and as_bytes:
d_str = d_str.encode('ascii')
elif isinstance(d_str, bytes) and not as_bytes:
d_str = d_str.decode('ascii')
iparser = isoparser()
assert iparser.parse_isodate(d_str) == d
def test_isotime(time_val, time_fmt, as_bytes):
tstr = time_val.strftime(time_fmt)
if isinstance(tstr, six.text_type) and as_bytes:
tstr = tstr.encode('ascii')
elif isinstance(tstr, bytes) and not as_bytes:
tstr = tstr.decode('ascii')
iparser = isoparser()
assert iparser.parse_isotime(tstr) == time_val
def test_isotime(time_val, time_fmt, as_bytes):
tstr = time_val.strftime(time_fmt)
if isinstance(time_val, six.text_type) and as_bytes:
tstr = tstr.encode('ascii')
elif isinstance(time_val, six.binary_type) and not as_bytes:
tstr = tstr.decode('ascii')
iparser = isoparser()
assert iparser.parse_isotime(tstr) == time_val
def validate(self, val):
super().validate(val)
if isinstance(val, six.string_types):
try:
val = parser.isoparser().parse_isotime(val)
except Exception:
val = parser.parse(val)
elif isinstance(val, self.type):
pass
else:
raise ValidationError(u'{}: {} is not string type or {} type'.format(self.name or 'value', val, self.type))
return val
def dateobs2night(dateobs):
"""
Convert DATE-OBS ISO8601 UTC string to YEARMMDD int night of KPNO sunset
"""
# use astropy to flexibily handle multiple valid ISO8601 variants
from astropy.time import Time
try:
mjd = Time(dateobs).mjd
except ValueError:
#- only use optional dependency dateutil if needed;
#- it can handle some ISO8601 timezone variants that astropy can't
from dateutil.parser import isoparser
mjd = Time(isoparser().isoparse(dateobs))
return mjd2night(mjd)
def test_parse_isodate(d, dt_fmt, as_bytes):
if six.PY2:
#strftime returns str in python2
d_str_s = unicode(d.strftime(dt_fmt))
else:
d_str_s = d.strftime(dt_fmt)
d_str_b = d.strftime(dt_fmt).encode('ascii') #encode to bytes to test
for d_str in d_str_s, d_str_b:
if isinstance(d_str, six.text_type) and as_bytes:
d_str = d_str.encode('ascii')
elif isinstance(d_str, bytes) and not as_bytes:
d_str = d_str.decode('ascii')
iparser = isoparser()
assert iparser.parse_isodate(d_str) == d
def test_isotime(time_val, time_fmt, as_bytes):
if six.PY2:
tstr_s = unicode(time_val.strftime(time_fmt))
else:
tstr_s = time_val.strftime(time_fmt)
tstr_b = time_val.strftime(time_fmt).encode('ascii')
for tstr in tstr_s, tstr_b:
if isinstance(tstr, six.text_type) and as_bytes:
tstr = tstr.encode('ascii')
elif isinstance(tstr, bytes) and not as_bytes:
tstr = tstr.decode('ascii')
iparser = isoparser()
assert iparser.parse_isotime(tstr) == time_val
def decode_datetime(self, value: str):
"""Returns an appropriate Python datetime time, date, or datetime
object by using the 3rd party dateutil library (if present)
to parse an ISO 8601 datetime string in *value*. If it cannot,
or the dateutil library is not present, it will raise a
ValueError.
"""
try:
return super().decode_datetime(value)
except ValueError:
try:
from dateutil.parser import isoparser
isop = isoparser()
if len(value) > 3 and value[-2] == "+" and value[-1].isdigit():
# This technically means that we accept slightly more
# formats than ISO 8601 strings, since under that
# specification, two digits after the '+' are required
# for an hour offset, but ODL doesn't have this
# requirement. If we find only one digit, we'll
# just assume it means an hour and insert a zero so
# that it can be parsed.
tokens = value.rpartition("+")
value = tokens[0] + "+0" + tokens[-1]
try:
return isop.parse_isodate(value)
except ValueError:
try:
return isop.parse_isotime(value)
except ValueError:
return isop.isoparse(value)
except ImportError:
warn(
"The dateutil library is not present, so more "
"exotic date and time formats beyond the PVL/ODL "
"set cannot be parsed.",
ImportWarning,
)
raise ValueError
def timezone_info_for_timezone(tzstr: str) -> datetime.tzinfo:
"""Returns a datetime.tzinfo subclass for a timezone string."""
offset_err = None
tzname_err = None
try:
isoparser = parser.isoparser()
return isoparser.parse_tzstr(tzstr)
except ValueError as e:
offset_err = e # Fall through
try:
return cast(datetime.tzinfo, zoneinfo.ZoneInfo(tzstr))
except ValueError as e:
tzname_err = e # Fall through
raise ValueError(
f'Cannot serialize timezone: {tzstr!r} ({offset_err!r}, {tzname_err!r}).'
)
def coordVars(self):
"""
Identify coordinate variables and type. Avoid dependence on udunits for now.
"""
coords = dict(lon=None,lat=None,time=None,lev=None, tunits=None, toff = None)
Vars = self.variables.keys()
for d in self.dimensions.keys():
if d in Vars: # potential coordinate variable
try:
units = self.variables[d].units.lower()
if 'degrees_north' in units: coords['lat'] = d
elif 'degrees_south' in units: coords['lat'] = d
elif 'degrees_east' in units: coords['lon'] = d
elif 'degrees_west' in units: coords['lon'] = d
elif 'pa' in units: coords['lev'] = d
elif 'mb' in units: coords['lev'] = d
elif 'meter' in units: coords['lev'] = d
elif 'level' in units: coords['lev'] = d
elif 'sigma_level' in units: coords['lev'] = d
elif 'seconds' in units: coords['time'] = d
elif 'minutes' in units: coords['time'] = d
elif 'hours' in units: coords['time'] = d
elif 'days' in units: coords['time'] = d
except:
pass
if coords['time'] != None:
try:
isoT = self.variables['time'].units.split('since ')[1]
tunt = self.variables['time'].units.split(' since')[0].lower()
if ':' not in isoT: isoT = isoT+':0:0'
coords['toff'] = isoparser(isoT)
if tunt == 'seconds': tunits = 1.
elif tunt == 'minutes': tunits = 60.
elif tunt == 'hours': tunits = 60.**2
elif tunt == 'days': tunits = 24 * 60.**2
coords['tunits'] = tunits
except:
self.variables['time'] = None
return coords
class TimeType(BaseType):
_TYPE = datetime.time
_DEFAULT = parser.isoparser().parse_isotime('08:00:00')
_FORMAT = '%H:%M:%S'
def __init__(self, *args, **kwargs):
super(TimeType, self).__init__(*args, **kwargs)
self.format = kwargs.get('format', self._FORMAT)
@field_exception
def validate(self, val):
super().validate(val)
if isinstance(val, six.string_types):
try:
val = parser.isoparser().parse_isotime(val)
except Exception:
val = parser.parse(val)
elif isinstance(val, self.type):
pass
else:
raise ValidationError(u'{}: {} is not string type or {} type'.format(self.name or 'value', val, self.type))
return val
def __init__(self, filename, Extra=None):
"""
Read select attributes from an ODS file.
"""
nc = Dataset(filename)
Vars = VARS
if Extra is not None:
Vars += Extra
self._getVars(nc, Vars)
self.nobs = len(self.lon)
# Create python time
# ------------------
tunits = nc.variables['time'].units
onemin = timedelta(minutes=1)
toff = isoparser(tunits.split(' since ')[1].replace(' ', 'T'))
t = array([toff + self.time[i] * onemin for i in range(self.nobs)])
self.time = t # array of python datetime objects
def test_iso_with_sep_raises(sep_act, valid_sep, exception):
parser = isoparser(sep=valid_sep)
isostr = '2012-04-25' + sep_act + '01:25:00'
with pytest.raises(exception):
parser.isoparse(isostr)
def test_parse_tzstr_fails(tzstr, exception):
with pytest.raises(exception):
isoparser().parse_tzstr(tzstr)
def test_parse_tzstr_zero_as_utc(tzstr, zero_as_utc):
tzi = isoparser().parse_tzstr(tzstr, zero_as_utc=zero_as_utc)
assert tzi == UTC
assert (type(tzi) == tz.tzutc) == zero_as_utc
def test_isodate_raises(isostr, exception):
with pytest.raises(exception): #pragma: no cover
isoparser().parse_isodate(isostr)
def test_isoparser_invalid_sep(sep):
with pytest.raises(ValueError):
isoparser(sep=sep)
def test_iso_with_sep_raises(sep_act, valid_sep, exception):
parser = isoparser(sep=valid_sep)
isostr = '2012-04-25' + sep_act + '01:25:00'
with pytest.raises(exception):
parser.isoparse(isostr)
return typ[value]
def pass_faux_enum(value, typ):
typ[value]
return value
if hasattr(datetime, "fromisoformat"):
convert_date = date.fromisoformat
convert_datetime = datetime.fromisoformat
convert_time = time.fromisoformat
else:
from dateutil.parser import isoparser
instance = isoparser(sep="T")
convert_date = instance.parse_isodate
convert_datetime = instance.isoparse
convert_time = instance.parse_isotime
del instance
def convert_timedelta_str(dur):
"Barebones support for storing a timedelta as an ISO8601 duration."
micro = ".{:06d}".format(dur.microseconds) if dur.microseconds else ""
return "P{:d}DT{:d}{}S".format(dur.days, dur.seconds, micro)
_iso8601_duration = re.compile(
r"^P(?!$)([-+]?\d+(?:[.,]\d+)?Y)?"
r"([-+]?\d+(?:[.,]\d+)?M)?"
def test_isoparser_invalid_sep(sep):
with pytest.raises(ValueError):
isoparser(sep=sep)
def test_isotime_raises_xfail(isostr, exception):
iparser = isoparser()
with pytest.raises(exception):
iparser.parse_isotime(isostr)
def test_isotime_midnight(isostr):
iparser = isoparser()
assert iparser.parse_isotime(isostr) == time(0, 0, 0, 0)
def test_isodate_raises(isostr, exception):
with pytest.raises(exception):
isoparser().parse_isodate(isostr)
def test_parse_tzstr_fails(tzstr, exception):
with pytest.raises(exception):
isoparser().parse_tzstr(tzstr)
def test_isotime_raises_xfail(isostr, exception):
iparser = isoparser() #pragma: no cover
with pytest.raises(exception): #pragma: no cover
iparser.parse_isotime(isostr) #pragma: no cover
def test_isodate_raises(isostr, exception):
with pytest.raises(exception):
isoparser().parse_isodate(isostr)
def test_isotime_midnight(isostr):
iparser = isoparser()
assert iparser.parse_isotime(isostr) == time(0, 0, 0, 0)
def test_isotime_raises_xfail(isostr, exception):
iparser = isoparser()
with pytest.raises(exception):
iparser.parse_isotime(isostr)
def test_parse_tzstr_zero_as_utc(tzstr, zero_as_utc):
tzi = isoparser().parse_tzstr(tzstr, zero_as_utc=zero_as_utc)
assert tzi == tz.tzutc()
assert (type(tzi) == tz.tzutc) == zero_as_utc