Example #1
0
    def test_date_defined_as_date_object(self):
        dt = datetimeutils.to_datetime(datetime.date(2015, 12, 14))
        assert dt == datetime.datetime(2015, 12, 14)

        dt = datetimeutils.to_datetime(
            datetime.datetime(2015, 12, 14, 2, 1, 23))
        assert dt == datetime.datetime(2015, 12, 14, 2, 1, 23)
Example #2
0
    def replace_config_wildcards(cls, val):
        if isinstance(val, dict):
            for k in val:
                val[k] = cls.replace_config_wildcards(val[k])
        elif isinstance(val, list):
            val = [cls.replace_config_wildcards(v) for v in val]
        elif hasattr(val, 'lower'):  # i.e. it's a string
            if val:
                # first, fill in any datetime control codes or wildcards
                val = datetimeutils.fill_in_datetime_strings(val,
                                                             today=cls._TODAY)

                # then, see if the resulting string purely represents a datetime
                try:
                    val = datetimeutils.to_datetime(val, limit_range=True)
                except BlueSkyDatetimeValueError:
                    pass

                if hasattr(val, 'capitalize'):
                    # This gets rid of datetime parsing busters embedded
                    # in strings to prevent conversion to datetime object
                    val = val.replace('{datetime-parse-buster}', '')

                    if cls._RUN_ID:
                        val = val.replace('{run_id}', cls._RUN_ID)

                # TODO: any other replacements?

        return val
Example #3
0
    def today(self):
        if not self._processed_today:
            self._today = datetimeutils.fill_in_datetime_strings(self._today)
            self._today = datetimeutils.to_datetime(self._today)
            self._processed_today = True

        return self._today
Example #4
0
 def _parse(v, key):
     try:
         is_local = hasattr(v, 'endswith') and v.endswith('L')
         return (
             to_datetime(v.rstrip('L') if hasattr(v, 'rstrip') else v),
             is_local)
     except:
         raise self.FilterError(
             self.INVALID_TIME_START_OR_END_VAL.format(key))
Example #5
0
        def _filter(fire, active_area):
            if not isinstance(active_area, dict):
                self._fail_fire(fire, self.MISSING_FIRE_LOCATION_INFO_MSG)
            elif not active_area.get('start') or not active_area.get('end'):
                self._fail_fire(fire, self.MISSING_FIRE_LOCATION_INFO_MSG)

            utc_offset = datetime.timedelta(
                hours=parse_utc_offset(active_area.get('utc_offset') or 0))

            aa_s = to_datetime(active_area['start'])
            # check if e_is_local, since we're comparing aa_s against e
            if not e_is_local:
                aa_s = aa_s - utc_offset

            aa_e = to_datetime(active_area['end'])
            # same thing, but s_is_local
            if not s_is_local:
                aa_e = aa_e - utc_offset

            # note that this filters if aa's start/end matches cutoff
            # (e.g. if aa's start and filter's end are both 2019-01-01T00:00:00)
            return (s and aa_e <= s) or (e and aa_s >= e)
Example #6
0
def _get_accepted_forecasts_config():
    accepted_forecasts_config = Config().get('findmetdata',
                                             'accepted_forecasts')
    if accepted_forecasts_config:
        for k in ('init_times', 'met_file_name_pattern'):
            if not accepted_forecasts_config.get(k):
                raise BlueSkyConfigurationError(
                    "Config 'findmetdata' > "
                    "'accepted_forecasts' settings must define '{}'".format(k))

        accepted_forecasts_config['init_times'] = sorted([
            to_datetime(i, extra_formats=["%Y%m%d%H"])
            for i in accepted_forecasts_config.get('init_times', [])
        ])
    return accepted_forecasts_config
Example #7
0
    def test_date_defined_as_date_string(self):
        dt = datetimeutils.to_datetime("20151214")
        assert dt == datetime.datetime(2015, 12, 14)

        dt = datetimeutils.to_datetime("2015-12-14T10:02:01")
        assert dt == datetime.datetime(2015, 12, 14, 10, 2, 1)

        dt = datetimeutils.to_datetime('20160114')
        assert dt == datetime.datetime(2016, 1, 14)

        with raises(BlueSkyDatetimeValueError) as e_info:
            datetimeutils.to_datetime('20160114121100')
        assert e_info.value.args[
            0] == "Invalid datetime string value: 20160114121100"

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('20160114121100Z')
        assert e_info.value.args[
            0] == "Invalid datetime string value: 20160114121100Z"

        dt = datetimeutils.to_datetime('20160114T121100')
        assert dt == datetime.datetime(2016, 1, 14, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160114T121100Z')
        assert dt == datetime.datetime(2016, 1, 14, 12, 11, 00)

        dt = datetimeutils.to_datetime('20160114T12:11:00')
        assert dt == datetime.datetime(2016, 1, 14, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160114T12:11:00Z')
        assert dt == datetime.datetime(2016, 1, 14, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160114T12')
        assert dt == datetime.datetime(2016, 1, 14, 12)
        dt = datetimeutils.to_datetime('20160114T12Z')
        assert dt == datetime.datetime(2016, 1, 14, 12)

        dt = datetimeutils.to_datetime('20160113')
        assert dt == datetime.datetime(2016, 1, 13)

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('20160113121100')
        assert e_info.value.args[
            0] == "Invalid datetime string value: 20160113121100"

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('20160113121100Z')
        assert e_info.value.args[
            0] == "Invalid datetime string value: 20160113121100Z"

        dt = datetimeutils.to_datetime('20160113T121100')
        assert dt == datetime.datetime(2016, 1, 13, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160113T121100Z')
        assert dt == datetime.datetime(2016, 1, 13, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160113T12:11:00')
        assert dt == datetime.datetime(2016, 1, 13, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160113T12:11:00Z')
        assert dt == datetime.datetime(2016, 1, 13, 12, 11, 00)
        dt = datetimeutils.to_datetime('20160113T12')
        assert dt == datetime.datetime(2016, 1, 13, 12)
        dt = datetimeutils.to_datetime('20160113T12Z')
        assert dt == datetime.datetime(2016, 1, 13, 12)

        # TODO: test datetime='%Y-%m-%dT12:00:00', etc.

        # distant past and future values are allowed as long as
        # kwarg 'limit_range' is left as False
        dt = datetimeutils.to_datetime("1915-12-14T10:02:01")
        assert dt == datetime.datetime(1915, 12, 14, 10, 2, 1)
        dt = datetimeutils.to_datetime("2117-12-14T10:02:01")
        assert dt == datetime.datetime(2117, 12, 14, 10, 2, 1)
Example #8
0
    def test_date_defined_as_invalid_value(self):
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime(123)
        assert e_info.value.args[0] == "Invalid datetime string value: 123"

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('2016011412:11:00')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 2016011412:11:00'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('2016011412:11:00Z')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 2016011412:11:00Z'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('2016011312:11:00')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 2016011312:11:00'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('2016011312:11:00Z')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 2016011312:11:00Z'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('today')
        assert e_info.value.args[0] == 'Invalid datetime string value: today'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('yesterday')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: yesterday'

        # strftime control codes need to be replaced by call to
        # fill_in_datetime_strings, separately from  call to_datetime
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('%Y%m%d')
        assert e_info.value.args[0] == 'Invalid datetime string value: %Y%m%d'
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('%Y%m%d%H%M%S')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: %Y%m%d%H%M%S'

        # '{today}' and '{yesterday}' need to be replaced by call to
        # fill_in_datetime_strings, separately from  call to_datetime
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('{today}')
        assert e_info.value.args[0] == 'Invalid datetime string value: {today}'

        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('{yesterday}')
        assert e_info.value.args[
            0] == 'Invalid datetime string value: {yesterday}'

        # reload datetimeutils so that VALID_DATETIME_RANGE is
        # corrected relative to the frozen time, 2016-01-14
        imp.reload(datetimeutils)
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('1915-12-14T10:02:01',
                                           limit_range=True)
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 1915-12-14T10:02:01 (outside of valid range)'
        with raises(BlueSkyDatetimeValueError) as e_info:
            dt = datetimeutils.to_datetime('2117-12-14T10:02:01',
                                           limit_range=True)
        assert e_info.value.args[
            0] == 'Invalid datetime string value: 2117-12-14T10:02:01 (outside of valid range)'
Example #9
0
 def test_date_not_defined(self):
     assert datetimeutils.to_datetime(None) == None
Example #10
0
 def today(self, today):
     today = datetimeutils.fill_in_datetime_strings(today)
     today = datetimeutils.to_datetime(today)
     self._today = today
     Config().set_today(self._today)