def range_time(min_date, max_date=datetime.datetime.utcnow()): time = datetimes( min_value=datetime.datetime(1960, 1, 1, 0, 0), max_value=datetime.datetime(datetime.MAXYEAR, 1, 1, 0, 0), ) time = time.filter(lambda x: min_date < x < max_date) return time_attr(time=time)
def Times(draw, max_value, min_value): time = one_of(datetimes(max_value=max_value, min_value=min_value), TimesLeapsecond) time = Time(draw(time)) return time
def jobs( draw, ids=uuids(), statuses=sampled_from(JobInterface.JobStatus), parameters=dictionaries(text(), text()), results=dictionaries(text(), text()), dates_submitted=datetimes(), registration_schemas=dictionaries(text(), text()), result_schemas=dictionaries(text(), text()) ) -> JobInterface: """ :param draw: A function that can take a strategy and draw a datum from it :param ids: A hypothesis strategy (statisticians should read "random variable"), that represents the set of all valid job IDs :param statuses: A hypothesis strategy that samples from the set of all allowed job statuses :param parameters: A hypothesis strategy that samples from all job parameters :param results: A hypothesis strategy that represents the possible results :param dates_submitted: A hypothesis strategy that represents the possible dates that can be submitted :param registration_schemas: The possible job registration schemas :param result_schemas: The possible job result schemas :return: A randomly-generated implementation of :class:`JobInterface` """ return Job( draw(ids), draw(statuses), draw(parameters), draw(results), draw(dates_submitted), draw(registration_schemas), draw(result_schemas) )
def test_overflow_in_simplify(): # we shouldn't trigger a pytz bug when we're simplifying minimal( datetimes( min_value=dt.datetime.max - dt.timedelta(days=3), timezones=timezones() ), lambda x: x.tzinfo != pytz.UTC, )
def test_bordering_on_a_leap_year(): x = minimal( datetimes( dt.datetime.min.replace(year=2003), dt.datetime.max.replace(year=2005) ), lambda x: x.month == 2 and x.day == 29, timeout_after=60, ) assert x.year == 2004
def license_json(): return st.fixed_dictionaries( { "lictype": st.one_of(st.none(), st.text()), "metadata": st.fixed_dictionaries({ "update_time": st.floats(), "update_user": st.one_of(st.none(), st.text()), "update_action": st.integers(), "creator": st.one_of(st.none(), st.text()), "create_time": st.floats(), "update_controller_action": st.one_of(st.none(), st.text()), "owner": st.one_of(st.none(), st.text())}), "notes": st.one_of(st.none(), st.text()), "product": st.one_of(st.none(), st.text()), "start": st.datetimes(), "end": st.datetimes(), "type": st.one_of(st.none(), st.text()) })
def panicing_certs_fixture(draw): now = draw(datetimes( min_value=datetime(1971, 1, 1), max_value=datetime(2030, 1, 1))) panic = timedelta(seconds=draw( s.integers(min_value=60, max_value=60 * 60 * 24))) certs = dict( draw( s.lists( panicing_cert(now, panic), min_size=1, unique_by=lambda i: i[0]))) return AcmeFixture(now=now, panic_interval=panic, certs=certs)
def time_attr(draw, time=datetimes( max_value=datetime.datetime(datetime.datetime.utcnow().year, 1, 1, 0, 0), min_value=datetime.datetime(1900, 1, 1, 0, 0) ), delta=timedelta()): """ Create an a.Time where it's always positive and doesn't have a massive time delta. """ t1 = draw(time) t2 = t1 + draw(delta) # We can't download data from the future... assume(t2 < datetime.datetime.utcnow()) return a.Time(t1, t2)
def goes_time(draw, time=datetimes( max_value=datetime.datetime(datetime.datetime.utcnow().year, 1, 1, 0, 0), min_value=datetime.datetime(1981, 1, 1, 0, 0)), delta=timedelta()): """ Create an a.Time where it's always positive and doesn't have a massive time delta. """ t1 = draw(time) t2 = t1 + draw(delta) # We can't download data from the future. assume(t2 < datetime.datetime.utcnow()) tr = TimeRange(t1, t2) # There is no GOES data for this date. assume(datetime.datetime(1983, 5, 1, 0, 0, 0) not in tr) assume((datetime.datetime(1983, 5, 1) + draw(delta)) not in tr) return a.Time(tr)
def datetimes(allow_naive=None, timezones=None, min_year=None, max_year=None): """Return a strategy for generating datetimes. .. deprecated:: 3.9.0 use :py:func:`hypothesis.strategies.datetimes` instead. allow_naive=True will cause the values to sometimes be naive. timezones is the set of permissible timezones. If set to an empty collection all datetimes will be naive. If set to None all timezones available via pytz will be used. All generated datetimes will be between min_year and max_year, inclusive. """ note_deprecation('Use hypothesis.strategies.datetimes, which supports ' 'full-precision bounds and has a simpler API.') min_dt = convert_year_bound(min_year, dt.datetime.min) max_dt = convert_year_bound(max_year, dt.datetime.max) tzs = tz_args_strat(allow_naive, timezones, 'datetimes') return st.datetimes(min_dt, max_dt, tzs)
def field_mappings(): global __default_field_mappings if __default_field_mappings is None: # Sized fields are handled in _get_strategy_for_field() # URL fields are not yet handled __default_field_mappings = { dm.SmallIntegerField: st.integers(-32768, 32767), dm.IntegerField: st.integers(-2147483648, 2147483647), dm.BigIntegerField: st.integers(-9223372036854775808, 9223372036854775807), dm.PositiveIntegerField: st.integers(0, 2147483647), dm.PositiveSmallIntegerField: st.integers(0, 32767), dm.BinaryField: st.binary(), dm.BooleanField: st.booleans(), dm.DateField: st.dates(), dm.DateTimeField: st.datetimes(timezones=get_tz_strat()), dm.DurationField: st.timedeltas(), dm.EmailField: emails(), dm.FloatField: st.floats(), dm.NullBooleanField: st.one_of(st.none(), st.booleans()), dm.TimeField: st.times(timezones=get_tz_strat()), dm.UUIDField: st.uuids(), } # SQLite does not support timezone-aware times, or timedeltas that # don't fit in six bytes of microseconds, so we override those db = getattr(django_settings, 'DATABASES', {}).get('default', {}) if db.get('ENGINE', '').endswith('.sqlite3'): # pragma: no branch sqlite_delta = timedelta(microseconds=2 ** 47 - 1) __default_field_mappings.update({ dm.TimeField: st.times(), dm.DurationField: st.timedeltas(-sqlite_delta, sqlite_delta), }) return __default_field_mappings
def test_timezones_arg_to_datetimes_must_be_search_strategy(): with pytest.raises(InvalidArgument): datetimes(timezones=pytz.all_timezones).validate() with pytest.raises(InvalidArgument): tz = [pytz.timezone(t) for t in pytz.all_timezones] datetimes(timezones=tz).validate()
def test_simplifies_towards_millenium(): d = minimal(datetimes()) assert d.year == 2000 assert d.month == d.day == 1 assert d.hour == d.minute == d.second == d.microsecond == 0
def tag_triple_for_football(draw, dts=st.datetimes(), bools=st.booleans()): return ("football", draw(dts), draw(bools))
def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate()
def test_datetimes_can_exclude_imaginary(kw): # Sanity check: fail unless those days contain an imaginary hour to filter out find_any(datetimes(**kw, allow_imaginary=True), lambda x: not datetime_exists(x)) # Assert that with allow_imaginary=False we only generate existing datetimes. assert_all_examples(datetimes(**kw, allow_imaginary=False), datetime_exists)
class TestToTimeIndexSeries: @given(st.lists(st.floats()), st.datetimes(), available_freqs()) def test_list_as_input( self, input_list: pd.Series, start: datetime, freq: pd.Timedelta, ): time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series(input_list) expected_time_series = pandas_series_with_period_index( input_list, start, freq=freq ) assert_series_equal(computed_time_series, expected_time_series) @given( arrays(shape=st.integers(0, 1000), dtype=float), st.datetimes(), available_freqs(), ) def test_array_as_input( self, input_array: np.ndarray, start: datetime, freq: pd.Timedelta, ): time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( input_array ) expected_time_series = pandas_series_with_period_index( input_array, start, freq=freq ) assert_series_equal(computed_time_series, expected_time_series) @given(series_with_period_index(), st.datetimes(), available_freqs()) def test_period_index_series_unchanged( self, period_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( period_index_series ) assert_series_equal(computed_time_series, period_index_series) @given(series_with_datetime_index(), st.datetimes(), available_freqs()) def test_datetime_index_series_unchanged( self, datetime_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( datetime_index_series ) assert_series_equal(computed_time_series, datetime_index_series) @given(series_with_timedelta_index(), st.datetimes(), available_freqs()) def test_timedelta_index_series_unchanged( self, timedelta_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( timedelta_index_series ) assert_series_equal(computed_time_series, timedelta_index_series) @given(st.tuples()) def test_wrong_input_type(self, wrong_input: Tuple): time_series_preparation = TimeSeriesPreparation() with pytest.raises(TypeError): time_series_preparation._to_time_index_series(wrong_input) @given(series_with_period_index(), st.datetimes(), available_freqs()) def test_period_index_dataframe_unchanged( self, period_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): period_index_dataframe = pd.DataFrame(period_index_series) time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( period_index_dataframe ) assert_series_equal(computed_time_series, period_index_series) @given(series_with_datetime_index(), st.datetimes(), available_freqs()) def test_datetime_index_dataframe_unchanged( self, datetime_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): datetime_index_dataframe = pd.DataFrame(datetime_index_series) time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( datetime_index_dataframe ) assert_series_equal(computed_time_series, datetime_index_series) @given(series_with_timedelta_index(), st.datetimes(), available_freqs()) def test_timedelta_index_dataframe_unchanged( self, timedelta_index_series: pd.Series, start: datetime, freq: pd.Timedelta, ): timedelta_index_dataframe = pd.DataFrame(timedelta_index_series) time_series_preparation = TimeSeriesPreparation(start=start, freq=freq) computed_time_series = time_series_preparation._to_time_index_series( timedelta_index_dataframe ) assert_series_equal(computed_time_series, timedelta_index_series)
def test_utc_is_minimal(): assert tz.UTC is minimal(timezones()) def test_can_generate_non_naive_time(): assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == tz.UTC def test_can_generate_non_naive_datetime(): assert minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == tz.UTC @given(datetimes(timezones=timezones())) def test_timezone_aware_datetimes_are_timezone_aware(dt): assert dt.tzinfo is not None @given(sampled_from(['min_value', 'max_value']), datetimes(timezones=timezones())) def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate() def test_timezones_arg_to_datetimes_must_be_search_strategy(): all_timezones = zoneinfo.get_zonefile_instance().zones with pytest.raises(InvalidArgument): datetimes(timezones=all_timezones).validate()
from hypothesis.errors import InvalidArgument from hypothesis.strategies._internal.datetime import zoneinfo from tests.common.debug import assert_no_examples, find_any, minimal def test_utc_is_minimal(): assert minimal(st.timezones()) is zoneinfo.ZoneInfo("UTC") def test_can_generate_non_utc(): find_any( st.datetimes( timezones=st.timezones()).filter(lambda d: d.tzinfo.key != "UTC")) @given(st.data(), st.datetimes(), st.datetimes()) def test_datetimes_stay_within_naive_bounds(data, lo, hi): if lo > hi: lo, hi = hi, lo out = data.draw(st.datetimes(lo, hi, timezones=st.timezones())) assert lo <= out.replace(tzinfo=None) <= hi @pytest.mark.parametrize("kwargs", [{"no_cache": 1}]) def test_timezones_argument_validation(kwargs): with pytest.raises(InvalidArgument): st.timezones(**kwargs).validate() @pytest.mark.parametrize( "kwargs",
t.reset() assert not t.is_expired() assert t.is_expired() @pytest.mark.smoke @freezegun.freeze_time(auto_tick_seconds=5) def test_reset_and_set(): t = Timeout(10000) assert not t.is_expired() t.reset(5000) assert t.is_expired() @given(timeout=st.integers(min_value=0) | st.datetimes(min_value=datetime.datetime.now(), max_value=datetime.datetime(2038, 1, 1))) @freezegun.freeze_time(auto_tick_seconds=1) def test_remaining_type(timeout): t = Timeout(timeout) assert isinstance(t.remaining(), int) @given(timeout=st.integers(min_value=0) | st.datetimes(min_value=datetime.datetime.now(), max_value=datetime.datetime(2038, 1, 1))) @freezegun.freeze_time(auto_tick_seconds=1) def test_elapsed_type(timeout): t = Timeout(timeout) assert isinstance(t.elapsed(), int)
def test_bordering_on_a_leap_year(): x = minimal(datetimes(dt.datetime.min.replace(year=2003), dt.datetime.max.replace(year=2005)), lambda x: x.month == 2 and x.day == 29, timeout_after=60) assert x.year == 2004
def datetime_strat(field): # MongoDB datetimes have only millisecond precision return strat.datetimes().map( lambda dt: dt.replace(microsecond=(dt.microsecond // 1000 * 1000)))
def complex_datetime_strat(field): return strat.datetimes(min_value=datetime.datetime(1900, 1, 1))
def _for_datetime(field): if getattr(django.conf.settings, "USE_TZ", False): return st.datetimes(timezones=timezones()) return st.datetimes()
def arrays(draw, type, size=None): if isinstance(type, st.SearchStrategy): ty = draw(type) elif isinstance(type, pa.DataType): ty = type else: raise TypeError('Type must be a pyarrow DataType') if isinstance(size, st.SearchStrategy): size = draw(size) elif size is None: size = draw(_default_array_sizes) elif not isinstance(size, int): raise TypeError('Size must be an integer') shape = (size, ) if pa.types.is_list(ty) or pa.types.is_large_list(ty): offsets = draw(npst.arrays(np.uint8(), shape=shape)).cumsum() // 20 offsets = np.insert(offsets, 0, 0, axis=0) # prepend with zero values = draw(arrays(ty.value_type, size=int(offsets.sum()))) if pa.types.is_large_list(ty): array_type = pa.LargeListArray else: array_type = pa.ListArray return array_type.from_arrays(offsets, values) if pa.types.is_struct(ty): h.assume(len(ty) > 0) fields, child_arrays = [], [] for field in ty: fields.append(field) child_arrays.append(draw(arrays(field.type, size=size))) return pa.StructArray.from_arrays(child_arrays, fields=fields) if (pa.types.is_boolean(ty) or pa.types.is_integer(ty) or pa.types.is_floating(ty)): values = npst.arrays(ty.to_pandas_dtype(), shape=(size, )) np_arr = draw(values) if pa.types.is_floating(ty): # Workaround ARROW-4952: no easy way to assert array equality # in a NaN-tolerant way. np_arr[np.isnan(np_arr)] = -42.0 return pa.array(np_arr, type=ty) if pa.types.is_null(ty): value = st.none() elif pa.types.is_time(ty): value = st.times() elif pa.types.is_date(ty): value = st.dates() elif pa.types.is_timestamp(ty): min_int64 = -(2**63) max_int64 = 2**63 - 1 min_datetime = datetime.datetime.fromtimestamp(min_int64 / 10**9) max_datetime = datetime.datetime.fromtimestamp(max_int64 / 10**9) try: offset_hours = int(ty.tz) tz = pytz.FixedOffset(offset_hours * 60) except ValueError: tz = pytz.timezone(ty.tz) value = st.datetimes(timezones=st.just(tz), min_value=min_datetime, max_value=max_datetime) elif pa.types.is_duration(ty): value = st.timedeltas() elif pa.types.is_binary(ty) or pa.types.is_large_binary(ty): value = st.binary() elif pa.types.is_string(ty) or pa.types.is_large_string(ty): value = st.text() elif pa.types.is_decimal(ty): # TODO(kszucs): properly limit the precision # value = st.decimals(places=type.scale, allow_infinity=False) h.reject() else: raise NotImplementedError(ty) values = st.lists(value, min_size=size, max_size=size) return pa.array(draw(values), type=ty)
def makedate(dt): """ The STARTDAT date format does not use seconds, but instead embed that information in microseconds, but python datetime does not support second wrap-around generate a STARTDAT array from a datetime. """ day = dt.day month = dt.month year = dt.year hour = dt.hour minute = dt.minute microsecond = dt.second * 1000000 + dt.microsecond return dt, [day, month, year, hour, minute, microsecond] @given(st.builds(makedate, st.datetimes())) def test_valid_startdates(startdates): expected, array = startdates kw = ('STARTDAT', array) s = summary.summary([kw]) assert s.startdate == expected def test_minimal_from_keywords(): s = summary.summary(minimal_keywords) s.check_integrity() assert s.nlist == 2 assert s.keywords == ['WOPR', 'WOPT'] assert s.wgnames == ['W1', 'W2'] assert s.units == ['SM3/DAY', 'SM3'] assert s.startdate == datetime.datetime(
class TestTransform: @given(st.lists(st.floats()), st.datetimes(), available_freqs(), st.text()) def test_list_as_input( self, input_list: pd.Series, start: datetime, freq: pd.Timedelta, output_name: str, ): time_series_preparation = TimeSeriesPreparation( start=start, freq=freq, output_name=output_name ) computed_time_series = time_series_preparation.transform(input_list) expected_series = pandas_series_with_period_index(input_list, start, freq=freq) expected_time_series = pd.DataFrame({output_name: expected_series}) assert_frame_equal(computed_time_series, expected_time_series) @given( arrays(shape=st.integers(0, 1000), dtype=float), st.datetimes(), available_freqs(), st.text(), ) def test_array_as_input( self, input_array: np.ndarray, start: datetime, freq: pd.Timedelta, output_name: str, ): time_series_preparation = TimeSeriesPreparation( start=start, freq=freq, output_name=output_name ) computed_time_series = time_series_preparation.transform(input_array) expected_series = pandas_series_with_period_index(input_array, start, freq=freq) expected_time_series = pd.DataFrame({output_name: expected_series}) assert_frame_equal(computed_time_series, expected_time_series) @given(series_with_period_index(), st.datetimes(), available_freqs(), st.text()) def test_period_index_as_input( self, period_index_series: pd.Series, start: datetime, freq: pd.Timedelta, output_name: str, ): time_series_preparation = TimeSeriesPreparation( start=start, freq=freq, output_name=output_name ) computed_time_series = time_series_preparation.transform(period_index_series) expected_time_series = pd.DataFrame({output_name: period_index_series}) assert_frame_equal(computed_time_series, expected_time_series) @given(series_with_datetime_index(), st.datetimes(), available_freqs(), st.text()) def test_datetime_index_as_input( self, datetime_index_series: pd.Series, start: datetime, freq: pd.Timedelta, output_name: str, ): time_series_preparation = TimeSeriesPreparation( start=start, freq=freq, output_name=output_name ) computed_time_series = time_series_preparation.transform(datetime_index_series) expected_series = datetime_index_series_to_period_index_series( datetime_index_series, freq=freq ) expected_time_series = pd.DataFrame({output_name: expected_series}) assert_frame_equal(computed_time_series, expected_time_series) @given(series_with_timedelta_index(), st.datetimes(), available_freqs(), st.text()) def test_timedelta_index_as_input( self, timedelta_index_series: pd.Series, start: datetime, freq: pd.Timedelta, output_name: str, ): time_series_preparation = TimeSeriesPreparation( start=start, freq=freq, output_name=output_name ) computed_time_series = time_series_preparation.transform(timedelta_index_series) expected_series = timedelta_index_series_to_period_index_series( timedelta_index_series, freq=freq ) expected_time_series = pd.DataFrame({output_name: expected_series}) assert_frame_equal(computed_time_series, expected_time_series)
def test_can_generate_non_utc(): find_any( st.datetimes( timezones=st.timezones()).filter(lambda d: d.tzinfo.key != "UTC"))
def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate()
st.datetimes(timezones=timezones() | st.none()) | st.dates() | st.times(timezones=timezones() | st.none()) | st.timedeltas() | st.booleans() | st.none() ) hashable_primitives = ( st.booleans() | st.integers() | st.floats(allow_nan=False) | st.text() | st.binary() | st.datetimes() | st.timedeltas() ) def hashable_containers(primitives): def extend(base): return st.one_of( st.frozensets(base, max_size=50), st.lists(base, max_size=50).map(tuple), ) return st.recursive(primitives, extend) def containers(primitives): def extend(base):
def test_datetimes_stay_within_naive_bounds(data, lo, hi): if lo > hi: lo, hi = hi, lo out = data.draw(datetimes(lo, hi, timezones=timezones())) assert lo <= out.replace(tzinfo=None) <= hi
from pandas.compat import is_platform_windows from pandas.compat.numpy import np_array_datetime64_compat import pandas as pd from pandas import DataFrame, DatetimeIndex, Index, MultiIndex, Series import pandas._testing as tm from pandas.core.indexes.datetimes import date_range import pandas.io.date_converters as conv # constant _DEFAULT_DATETIME = datetime(1, 1, 1) # Strategy for hypothesis if is_platform_windows(): date_strategy = st.datetimes(min_value=datetime(1900, 1, 1)) else: date_strategy = st.datetimes() def test_separator_date_conflict(all_parsers): # Regression test for gh-4678 # # Make sure thousands separator and # date parsing do not conflict. parser = all_parsers data = "06-02-2013;13:00;1-000.215" expected = DataFrame([[datetime(2013, 6, 2, 13, 0, 0), 1000.215]], columns=["Date", 2]) df = parser.read_csv(
def test_can_generate_non_naive_datetime(): assert ( minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC )
def test_utc_is_minimal(): assert pytz.UTC is minimal(timezones()) def test_can_generate_non_naive_time(): assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC def test_can_generate_non_naive_datetime(): assert (minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC) @given(datetimes(timezones=timezones())) def test_timezone_aware_datetimes_are_timezone_aware(dt): assert dt.tzinfo is not None @given(sampled_from(["min_value", "max_value"]), datetimes(timezones=timezones())) def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate() def test_underflow_in_simplify(): # we shouldn't trigger a pytz bug when we're simplifying minimal( datetimes(max_value=dt.datetime.min + dt.timedelta(days=3),
def test_utc_is_minimal(): assert pytz.UTC is minimal(timezones()) def test_can_generate_non_naive_time(): assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC def test_can_generate_non_naive_datetime(): assert ( minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC ) @given(datetimes(timezones=timezones())) def test_timezone_aware_datetimes_are_timezone_aware(dt): assert dt.tzinfo is not None @given(sampled_from(["min_value", "max_value"]), datetimes(timezones=timezones())) def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate() def test_underflow_in_simplify(): # we shouldn't trigger a pytz bug when we're simplifying minimal( datetimes( max_value=dt.datetime.min + dt.timedelta(days=3), timezones=timezones()
def test_timezones_arg_to_datetimes_must_be_search_strategy(): with pytest.raises(InvalidArgument): datetimes(timezones=pytz.all_timezones).validate() with pytest.raises(InvalidArgument): tz = [pytz.timezone(t) for t in pytz.all_timezones] datetimes(timezones=tz).validate()
assert minimal(timedeltas(max_value=dt.timedelta(days=-10))).days == -10 @given(timedeltas()) def test_single_timedelta(val): assert find_any(timedeltas(val, val)) is val def test_simplifies_towards_millenium(): d = minimal(datetimes()) assert d.year == 2000 assert d.month == d.day == 1 assert d.hour == d.minute == d.second == d.microsecond == 0 @given(datetimes()) def test_default_datetimes_are_naive(dt): assert dt.tzinfo is None def test_bordering_on_a_leap_year(): x = minimal( datetimes( dt.datetime.min.replace(year=2003), dt.datetime.max.replace(year=2005) ), lambda x: x.month == 2 and x.day == 29, timeout_after=60, ) assert x.year == 2004
@pytest.mark.remote_data @pytest.mark.parametrize( 'query', [(a.Time('2012/10/4', '2012/10/6') & a.Instrument('eve') & a.Level(0))]) def test_fido(query): qr = Fido.search(query) client = qr.get_response(0).client assert isinstance(qr, UnifiedResponse) assert isinstance(client, eve.EVEClient) response = Fido.fetch(qr) assert len(response) == qr._numfile @pytest.mark.remote_data @given(time_attr(time=datetimes( max_value=datetime.datetime(datetime.datetime.utcnow().year, 1, 1, 0, 0), min_value=datetime.datetime(2010, 1, 1, 0, 0), ))) @settings(max_examples=2, timeout=240) def test_levels(time): """ Test the correct handling of level 0 / 1. The default should be level 1 from VSO, level 0 comes from EVEClient. """ eve_a = a.Instrument('EVE') qr = Fido.search(time, eve_a) client = qr.get_response(0).client assert isinstance(client, VSOClient) qr = Fido.search(time, eve_a, a.Level(0)) client = qr.get_response(0).client assert isinstance(client, eve.EVEClient)
def tag_triples_pair(draw, dts=st.datetimes(), bools=st.booleans()): a = ("test_tag", draw(dts), draw(bools)) b = ("test_tag", draw(dts), draw(bools)) return (a, b)
cmp_python = cmp(python_value1, python_value2) cmp_db = cmp(db_value1, db_value2) return cmp_python == cmp_db @given(python_value1=st.text(min_size=0, max_size=511), python_value2=st.text(min_size=0, max_size=511)) def test_TextIndex_is_sortable(python_value1, python_value2): assert _test_index_is_sortable(TextIndex.K, python_value1, python_value2) @given(python_value1=st.integers(min_value=0, max_value=2**64-1), python_value2=st.integers(min_value=0, max_value=2**64-1)) @example(python_value1=1, python_value2=256) def test_NumericIndex_is_sortable(python_value1, python_value2): assert _test_index_is_sortable(NumericIndex.K, python_value1, python_value2) @given(python_value1=st.datetimes(min_value=datetime.fromtimestamp(0)), python_value2=st.datetimes(min_value=datetime.fromtimestamp(0))) def test_DatetimeIndex_is_sortable(python_value1, python_value2): assert _test_index_is_sortable(DatetimeIndex.K, python_value1, python_value2)
@pytest.mark.parametrize( "serializer,strategy", [(NumericSerializer, st.integers( min_value=0, max_value=2**64-1)), (TextSerializer, st.text( min_size=0, max_size=511)), (ObjectSerializer, st.dictionaries( st.text(), st.text())), (NullListSerializer, st.text( min_size=1, alphabet=ascii_letters + '.')), (DatetimeSerializer, st.datetimes( min_value=datetime.fromtimestamp(0)))]) @given(st.data()) def test_serializers_conversion(serializer, strategy, data): python_value = expected = data.draw(strategy) current = serializer.python_value( memoryview(serializer.db_value(python_value))) assert current == expected def test_nulllistserializer_invalid_values(): with pytest.raises(ValueError): NullListSerializer.db_value('') with pytest.raises(ValueError): NullListSerializer.db_value('test\0')
print(schema._declared_fields) output = schema.load(serialize_df(sample_df, orient="records")) assert_frame_equal(output, sample_df) @hypothesis.given(test_df=data_frames( columns=[ column("int", dtype=int), column("float", dtype=float), column("bool", dtype=bool), column("chars", elements=st.characters()), column( "datetime", elements=st.datetimes(min_value=pd.Timestamp.min, max_value=pd.Timestamp.max), dtype="datetime64[s]", ), ], # records serialization format does not record indices, so we always # set them to an integer index. index=(indexes(elements=st.integers( min_value=np.iinfo(np.int64).min, max_value=np.iinfo(np.int64).max, ))), )) def test_records_schema_hypothesis(test_df): if not len(test_df.index): # ignore empty datasets as dtype is impossible to infer from serialized return
YearEnd, YearBegin, BYearEnd, BYearBegin, ) # ---------------------------------------------------------------- # Helpers for generating random data with warnings.catch_warnings(): warnings.simplefilter('ignore') min_dt = pd.Timestamp(1900, 1, 1).to_pydatetime(), max_dt = pd.Timestamp(1900, 1, 1).to_pydatetime(), gen_date_range = st.builds( pd.date_range, start=st.datetimes( # TODO: Choose the min/max values more systematically min_value=pd.Timestamp(1900, 1, 1).to_pydatetime(), max_value=pd.Timestamp(2100, 1, 1).to_pydatetime() ), periods=st.integers(min_value=2, max_value=100), freq=st.sampled_from('Y Q M D H T s ms us ns'.split()), tz=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()), ) gen_random_datetime = st.datetimes( min_value=min_dt, max_value=max_dt, timezones=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()) ) # The strategy for each type is registered in conftest.py, as they don't carry # enough runtime information (e.g. type hints) to infer how to build them.
from hypothesis import given, assume from hypothesis import strategies as st from dateutil import tz from dateutil.parser import isoparse import pytest # Strategies TIME_ZONE_STRATEGY = st.sampled_from([None, tz.tzutc()] + [tz.gettz(zname) for zname in ('US/Eastern', 'US/Pacific', 'Australia/Sydney', 'Europe/London')]) ASCII_STRATEGY = st.characters(max_codepoint=127) @pytest.mark.isoparser @given(dt=st.datetimes(timezones=TIME_ZONE_STRATEGY), sep=ASCII_STRATEGY) def test_timespec_auto(dt, sep): if dt.tzinfo is not None: # Assume offset has no sub-second components assume(dt.utcoffset().total_seconds() % 60 == 0) sep = str(sep) # Python 2.7 requires bytes dtstr = dt.isoformat(sep=sep) dt_rt = isoparse(dtstr) assert dt_rt == dt
def get_datetime_strat(): if getattr(django_settings, 'USE_TZ', False): return st.datetimes(timezones=timezones()) return st.datetimes()
'register_type_strategy' % (empty or thing,)) return st.one_of(strategies) _global_type_lookup = { # Types with core Hypothesis strategies type(None): st.none(), bool: st.booleans(), int: st.integers(), float: st.floats(), complex: st.complex_numbers(), fractions.Fraction: st.fractions(), decimal.Decimal: st.decimals(), text_type: st.text(), bytes: st.binary(), datetime.datetime: st.datetimes(), datetime.date: st.dates(), datetime.time: st.times(), datetime.timedelta: st.timedeltas(), uuid.UUID: st.uuids(), tuple: st.builds(tuple), list: st.builds(list), set: st.builds(set), frozenset: st.builds(frozenset), dict: st.builds(dict), # Built-in types type: st.sampled_from([type(None), bool, int, str, list, set, dict]), type(Ellipsis): st.just(Ellipsis), type(NotImplemented): st.just(NotImplemented), bytearray: st.binary().map(bytearray), memoryview: st.binary().map(memoryview),
from math import inf, nan import pandas as pd import numpy as np import pytest from hypothesis import given from hypothesis.extra.pytz import timezones from hypothesis.strategies import datetimes, floats from pysoleng.solar_geom import calculate_hour_angle_degrees # Create time zone-aware datetimes for use in testing aware_datetimes = datetimes( min_value=pd.Timestamp.min + pd.DateOffset(2), max_value=pd.Timestamp.max - pd.DateOffset(2), timezones=timezones(), ) @pytest.mark.solar_geom @given( aware_datetimes, floats(min_value=0, max_value=360, allow_nan=False, allow_infinity=False), ) def test_calculate_hour_angle(dt, longitude): """Functional test to ensure the calculate_hour_angle() method runs properly given valid arguments.""" assert isinstance( calculate_hour_angle_degrees( local_standard_time=dt, longitude_degrees=longitude
YearEnd, ) # ---------------------------------------------------------------- # Helpers for generating random data with warnings.catch_warnings(): warnings.simplefilter("ignore") min_dt = Timestamp(1900, 1, 1).to_pydatetime() max_dt = Timestamp(1900, 1, 1).to_pydatetime() gen_date_range = st.builds( pd.date_range, start=st.datetimes( # TODO: Choose the min/max values more systematically min_value=Timestamp(1900, 1, 1).to_pydatetime(), max_value=Timestamp(2100, 1, 1).to_pydatetime(), ), periods=st.integers(min_value=2, max_value=100), freq=st.sampled_from("Y Q M D H T s ms us ns".split()), tz=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()), ) gen_random_datetime = st.datetimes( min_value=min_dt, max_value=max_dt, timezones=st.one_of(st.none(), dateutil_timezones(), pytz_timezones()), ) # The strategy for each type is registered in conftest.py, as they don't carry # enough runtime information (e.g. type hints) to infer how to build them.
return value return _strategy() def primitives(): return (st.integers() | st.floats(allow_nan=False) | st.text() | st.binary() | st.datetimes(timezones=timezones() | st.none()) | st.dates() | st.times(timezones=timezones() | st.none()) | st.timedeltas() | st.booleans() | st.none()) hashable_primitives = (st.booleans() | st.integers() | st.floats(allow_nan=False) | st.text() | st.binary() | st.datetimes() | st.timedeltas()) def identity(x): return x def hashables(): def extend(base): return base.flatmap(lambda strat: st.tuples( strat, st.sampled_from([ st.tuples, st.frozensets, ]))).map(lambda strat__extend: strat__extend[1](strat__extend[0])) return st.recursive(hashable_primitives, extend)
def primitives(): return (st.integers() | st.floats(allow_nan=False) | st.text() | st.binary() | st.datetimes(timezones=timezones() | st.none()) | st.dates() | st.times(timezones=timezones() | st.none()) | st.timedeltas() | st.booleans() | st.none())
def _for_datetime(field): if getattr(django.conf.settings, "USE_TZ", False): return st.datetimes(timezones=timezones()) return st.datetimes()
assert minimal(timedeltas(max_value=dt.timedelta(days=-10))).days == -10 @given(timedeltas()) def test_single_timedelta(val): assert find_any(timedeltas(val, val)) is val def test_simplifies_towards_millenium(): d = minimal(datetimes()) assert d.year == 2000 assert d.month == d.day == 1 assert d.hour == d.minute == d.second == d.microsecond == 0 @given(datetimes()) def test_default_datetimes_are_naive(dt): assert dt.tzinfo is None def test_bordering_on_a_leap_year(): x = minimal( datetimes(dt.datetime.min.replace(year=2003), dt.datetime.max.replace(year=2005)), lambda x: x.month == 2 and x.day == 29, timeout_after=60, ) assert x.year == 2004 def test_can_find_after_the_year_2000():
def arrays(draw, type, size=None): if isinstance(type, st.SearchStrategy): type = draw(type) elif not isinstance(type, pa.DataType): raise TypeError('Type must be a pyarrow DataType') if isinstance(size, st.SearchStrategy): size = draw(size) elif size is None: size = draw(_default_array_sizes) elif not isinstance(size, int): raise TypeError('Size must be an integer') shape = (size,) if pa.types.is_list(type): offsets = draw(npst.arrays(np.uint8(), shape=shape)).cumsum() // 20 offsets = np.insert(offsets, 0, 0, axis=0) # prepend with zero values = draw(arrays(type.value_type, size=int(offsets.sum()))) return pa.ListArray.from_arrays(offsets, values) if pa.types.is_struct(type): h.assume(len(type) > 0) names, child_arrays = [], [] for field in type: names.append(field.name) child_arrays.append(draw(arrays(field.type, size=size))) # fields' metadata are lost here, because from_arrays doesn't accept # a fields argumentum, only names return pa.StructArray.from_arrays(child_arrays, names=names) if (pa.types.is_boolean(type) or pa.types.is_integer(type) or pa.types.is_floating(type)): values = npst.arrays(type.to_pandas_dtype(), shape=(size,)) np_arr = draw(values) if pa.types.is_floating(type): # Workaround ARROW-4952: no easy way to assert array equality # in a NaN-tolerant way. np_arr[np.isnan(np_arr)] = -42.0 return pa.array(np_arr, type=type) if pa.types.is_null(type): value = st.none() elif pa.types.is_time(type): value = st.times() elif pa.types.is_date(type): value = st.dates() elif pa.types.is_timestamp(type): tz = pytz.timezone(type.tz) if type.tz is not None else None value = st.datetimes(timezones=st.just(tz)) elif pa.types.is_binary(type): value = st.binary() elif pa.types.is_string(type): value = st.text() elif pa.types.is_decimal(type): # TODO(kszucs): properly limit the precision # value = st.decimals(places=type.scale, allow_infinity=False) h.reject() else: raise NotImplementedError(type) values = st.lists(value, min_size=size, max_size=size) return pa.array(draw(values), type=type)
def test_simplifies_towards_millenium(): d = minimal(datetimes()) assert d.year == 2000 assert d.month == d.day == 1 assert d.hour == d.minute == d.second == d.microsecond == 0
from pandas.compat.numpy import np_array_datetime64_compat import pandas as pd from pandas import DataFrame, DatetimeIndex, Index, MultiIndex from pandas.core.indexes.datetimes import date_range import pandas.util.testing as tm import pandas.io.date_converters as conv import pandas.io.parsers as parsers # constant _DEFAULT_DATETIME = datetime(1, 1, 1) # Strategy for hypothesis if is_platform_windows(): date_strategy = st.datetimes(min_value=datetime(1900, 1, 1)) else: date_strategy = st.datetimes() def test_separator_date_conflict(all_parsers): # Regression test for gh-4678 # # Make sure thousands separator and # date parsing do not conflict. parser = all_parsers data = "06-02-2013;13:00;1-000.215" expected = DataFrame([[datetime(2013, 6, 2, 13, 0, 0), 1000.215]], columns=["Date", 2]) df = parser.read_csv(StringIO(data), sep=";", thousands="-",
def test_utc_is_minimal(): assert pytz.UTC is minimal(timezones()) def test_can_generate_non_naive_time(): assert minimal(times(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC def test_can_generate_non_naive_datetime(): assert ( minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == pytz.UTC ) @given(datetimes(timezones=timezones())) def test_timezone_aware_datetimes_are_timezone_aware(dt): assert dt.tzinfo is not None @given(sampled_from(["min_value", "max_value"]), datetimes(timezones=timezones())) def test_datetime_bounds_must_be_naive(name, val): with pytest.raises(InvalidArgument): datetimes(**{name: val}).validate() def test_underflow_in_simplify(): # we shouldn't trigger a pytz bug when we're simplifying minimal( datetimes( max_value=dt.datetime.min + dt.timedelta(days=3), timezones=timezones()
def test_can_generate_non_naive_datetime(): assert minimal(datetimes(timezones=timezones()), lambda d: d.tzinfo).tzinfo == tz.UTC
def test_can_trigger_error_in_draw_near_boundary(bound): assert_can_trigger_event( datetimes(**bound, timezones=timezones()), lambda event: "Failed to draw a datetime" in event, )
def test_timezones_arg_to_datetimes_must_be_search_strategy(): all_timezones = zoneinfo.get_zonefile_instance().zones with pytest.raises(InvalidArgument): datetimes(timezones=all_timezones).validate()
def test_uninitialized(): ct = CityTime(time=None) assert str(ct) == 'CityTime object not set yet.' def test_uninitialized__repr__(): CityTime().__repr__(), "CityTime object not set yet." def test_using_unset(): ct = CityTime() with raises(ValueError): ct.astimezone('utc') @given(datetimes(timezones=t_zones())) def test_set_t_zone(dt): ct = CityTime() ct.set(dt, str(dt.tzinfo)) assert ct.is_set() assert ct.timezone() == str(dt.tzinfo) @given(datetimes(timezones=t_zones())) def test_set_datetime(dt): ct = CityTime(dt, str(dt.tzinfo)) assert ct.is_set() assert ct.utc().tzinfo == pytz.timezone('UTC') assert ct.utc() == dt