title stringclasses 1 value | text stringlengths 30 426k | id stringlengths 27 30 |
|---|---|---|
asv_bench/benchmarks/ctors.py/SeriesDtypesConstructors/setup
class SeriesDtypesConstructors:
def setup(self):
N = 10**4
self.arr = np.random.randn(N)
self.arr_str = np.array(["foo", "bar", "baz"], dtype=object)
self.s = Series(
[Timestamp("20110101"), Timestamp("20120101"), Timestamp("20130101")]
* N
* 10
) | negative_train_query0_00498 | |
asv_bench/benchmarks/ctors.py/SeriesDtypesConstructors/time_index_from_array_string
class SeriesDtypesConstructors:
def time_index_from_array_string(self):
Index(self.arr_str) | negative_train_query0_00499 | |
asv_bench/benchmarks/ctors.py/SeriesDtypesConstructors/time_index_from_array_floats
class SeriesDtypesConstructors:
def time_index_from_array_floats(self):
Index(self.arr) | negative_train_query0_00500 | |
asv_bench/benchmarks/ctors.py/SeriesDtypesConstructors/time_dtindex_from_series
class SeriesDtypesConstructors:
def time_dtindex_from_series(self):
DatetimeIndex(self.s) | negative_train_query0_00501 | |
asv_bench/benchmarks/ctors.py/SeriesDtypesConstructors/time_dtindex_from_index_with_series
class SeriesDtypesConstructors:
def time_dtindex_from_index_with_series(self):
Index(self.s) | negative_train_query0_00502 | |
asv_bench/benchmarks/ctors.py/MultiIndexConstructor/setup
class MultiIndexConstructor:
def setup(self):
N = 10**4
self.iterables = [Index([f"i-{i}" for i in range(N)], dtype=object), range(20)] | negative_train_query0_00503 | |
asv_bench/benchmarks/ctors.py/MultiIndexConstructor/time_multiindex_from_iterables
class MultiIndexConstructor:
def time_multiindex_from_iterables(self):
MultiIndex.from_product(self.iterables) | negative_train_query0_00504 | |
asv_bench/benchmarks/ctors.py/DatetimeIndexConstructor/setup
class DatetimeIndexConstructor:
def setup(self):
N = 20_000
dti = date_range("1900-01-01", periods=N)
self.list_of_timestamps = dti.tolist()
self.list_of_dates = dti.date.tolist()
self.list_of_datetimes = dti.to_pydatetime().tolist()
self.list_of_str = dti.strftime("%Y-%m-%d").tolist() | negative_train_query0_00505 | |
asv_bench/benchmarks/ctors.py/DatetimeIndexConstructor/time_from_list_of_timestamps
class DatetimeIndexConstructor:
def time_from_list_of_timestamps(self):
DatetimeIndex(self.list_of_timestamps) | negative_train_query0_00506 | |
asv_bench/benchmarks/ctors.py/DatetimeIndexConstructor/time_from_list_of_dates
class DatetimeIndexConstructor:
def time_from_list_of_dates(self):
DatetimeIndex(self.list_of_dates) | negative_train_query0_00507 | |
asv_bench/benchmarks/ctors.py/DatetimeIndexConstructor/time_from_list_of_datetimes
class DatetimeIndexConstructor:
def time_from_list_of_datetimes(self):
DatetimeIndex(self.list_of_datetimes) | negative_train_query0_00508 | |
asv_bench/benchmarks/ctors.py/DatetimeIndexConstructor/time_from_list_of_str
class DatetimeIndexConstructor:
def time_from_list_of_str(self):
DatetimeIndex(self.list_of_str) | negative_train_query0_00509 | |
asv_bench/benchmarks/hash_functions.py/UniqueForLargePyObjectInts/setup
class UniqueForLargePyObjectInts:
def setup(self):
lst = [x << 32 for x in range(5000)]
self.arr = np.array(lst, dtype=np.object_) | negative_train_query0_00510 | |
asv_bench/benchmarks/hash_functions.py/UniqueForLargePyObjectInts/time_unique
class UniqueForLargePyObjectInts:
def time_unique(self):
pd.unique(self.arr) | negative_train_query0_00511 | |
asv_bench/benchmarks/hash_functions.py/Float64GroupIndex/setup
class Float64GroupIndex:
def setup(self):
self.df = pd.date_range(
start="1/1/2018", end="1/2/2018", periods=10**6
).to_frame()
self.group_index = np.round(self.df.index.astype(int) / 10**9) | negative_train_query0_00512 | |
asv_bench/benchmarks/hash_functions.py/Float64GroupIndex/time_groupby
class Float64GroupIndex:
def time_groupby(self):
self.df.groupby(self.group_index).last() | negative_train_query0_00513 | |
asv_bench/benchmarks/hash_functions.py/UniqueAndFactorizeArange/setup
class UniqueAndFactorizeArange:
def setup(self, exponent):
a = np.arange(10**4, dtype="float64")
self.a2 = (a + 10**exponent).repeat(100) | negative_train_query0_00514 | |
asv_bench/benchmarks/hash_functions.py/UniqueAndFactorizeArange/time_factorize
class UniqueAndFactorizeArange:
def time_factorize(self, exponent):
pd.factorize(self.a2) | negative_train_query0_00515 | |
asv_bench/benchmarks/hash_functions.py/UniqueAndFactorizeArange/time_unique
class UniqueAndFactorizeArange:
def time_unique(self, exponent):
pd.unique(self.a2) | negative_train_query0_00516 | |
asv_bench/benchmarks/hash_functions.py/Unique/setup
class Unique:
def setup(self, dtype):
self.ser = pd.Series(([1, pd.NA, 2] + list(range(100_000))) * 3, dtype=dtype)
self.ser_unique = pd.Series(list(range(300_000)) + [pd.NA], dtype=dtype) | negative_train_query0_00517 | |
asv_bench/benchmarks/hash_functions.py/Unique/time_unique_with_duplicates
class Unique:
def time_unique_with_duplicates(self, exponent):
pd.unique(self.ser) | negative_train_query0_00518 | |
asv_bench/benchmarks/hash_functions.py/Unique/time_unique
class Unique:
def time_unique(self, exponent):
pd.unique(self.ser_unique) | negative_train_query0_00519 | |
asv_bench/benchmarks/hash_functions.py/NumericSeriesIndexing/setup
class NumericSeriesIndexing:
def setup(self, dtype, N):
vals = np.array(list(range(55)) + [54] + list(range(55, N - 1)), dtype=dtype)
indices = pd.Index(vals)
self.data = pd.Series(np.arange(N), index=indices) | negative_train_query0_00520 | |
asv_bench/benchmarks/hash_functions.py/NumericSeriesIndexing/time_loc_slice
class NumericSeriesIndexing:
def time_loc_slice(self, index, N):
# trigger building of mapping
self.data.loc[:800] | negative_train_query0_00521 | |
asv_bench/benchmarks/hash_functions.py/NumericSeriesIndexingShuffled/setup
class NumericSeriesIndexingShuffled:
def setup(self, dtype, N):
vals = np.array(list(range(55)) + [54] + list(range(55, N - 1)), dtype=dtype)
np.random.shuffle(vals)
indices = pd.Index(vals)
self.data = pd.Series(np.arange(N), index=indices) | negative_train_query0_00522 | |
asv_bench/benchmarks/hash_functions.py/NumericSeriesIndexingShuffled/time_loc_slice
class NumericSeriesIndexingShuffled:
def time_loc_slice(self, index, N):
# trigger building of mapping
self.data.loc[:800] | negative_train_query0_00523 | |
asv_bench/benchmarks/algorithms.py/Factorize/setup
class Factorize:
def setup(self, unique, sort, dtype):
N = 10**5
if dtype in ["int64", "uint64", "Int64", "object"]:
data = pd.Index(np.arange(N), dtype=dtype)
elif dtype == "float64":
data = pd.Index(np.random.randn(N), dtype=dtype)
elif dtype == "boolean":
data = pd.array(np.random.randint(0, 2, N), dtype=dtype)
elif dtype == "datetime64[ns]":
data = pd.date_range("2011-01-01", freq="h", periods=N)
elif dtype == "datetime64[ns, tz]":
data = pd.date_range("2011-01-01", freq="h", periods=N, tz="Asia/Tokyo")
elif dtype == "object_str":
data = pd.Index([f"i-{i}" for i in range(N)], dtype=object)
elif dtype == "string[pyarrow]":
data = pd.array(
pd.Index([f"i-{i}" for i in range(N)], dtype=object),
dtype="string[pyarrow]",
)
else:
raise NotImplementedError
if not unique:
data = data.repeat(5)
self.data = data | negative_train_query0_00524 | |
asv_bench/benchmarks/algorithms.py/Factorize/time_factorize
class Factorize:
def time_factorize(self, unique, sort, dtype):
pd.factorize(self.data, sort=sort) | negative_train_query0_00525 | |
asv_bench/benchmarks/algorithms.py/Factorize/peakmem_factorize
class Factorize:
def peakmem_factorize(self, unique, sort, dtype):
pd.factorize(self.data, sort=sort) | negative_train_query0_00526 | |
asv_bench/benchmarks/algorithms.py/Duplicated/setup
class Duplicated:
def setup(self, unique, keep, dtype):
N = 10**5
if dtype in ["int64", "uint64"]:
data = pd.Index(np.arange(N), dtype=dtype)
elif dtype == "float64":
data = pd.Index(np.random.randn(N), dtype="float64")
elif dtype == "string":
data = pd.Index([f"i-{i}" for i in range(N)], dtype=object)
elif dtype == "datetime64[ns]":
data = pd.date_range("2011-01-01", freq="h", periods=N)
elif dtype == "datetime64[ns, tz]":
data = pd.date_range("2011-01-01", freq="h", periods=N, tz="Asia/Tokyo")
elif dtype in ["timestamp[ms][pyarrow]", "duration[s][pyarrow]"]:
data = pd.Index(np.arange(N), dtype=dtype)
else:
raise NotImplementedError
if not unique:
data = data.repeat(5)
self.idx = data
# cache is_unique
self.idx.is_unique | negative_train_query0_00527 | |
asv_bench/benchmarks/algorithms.py/Duplicated/time_duplicated
class Duplicated:
def time_duplicated(self, unique, keep, dtype):
self.idx.duplicated(keep=keep) | negative_train_query0_00528 | |
asv_bench/benchmarks/algorithms.py/DuplicatedMaskedArray/setup
class DuplicatedMaskedArray:
def setup(self, unique, keep, dtype):
N = 10**5
data = pd.Series(np.arange(N), dtype=dtype)
data[list(range(1, N, 100))] = pd.NA
if not unique:
data = data.repeat(5)
self.ser = data
# cache is_unique
self.ser.is_unique | negative_train_query0_00529 | |
asv_bench/benchmarks/algorithms.py/DuplicatedMaskedArray/time_duplicated
class DuplicatedMaskedArray:
def time_duplicated(self, unique, keep, dtype):
self.ser.duplicated(keep=keep) | negative_train_query0_00530 | |
asv_bench/benchmarks/algorithms.py/Hashing/setup_cache
class Hashing:
def setup_cache(self):
N = 10**5
df = pd.DataFrame(
{
"strings": pd.Series(
pd.Index([f"i-{i}" for i in range(10000)], dtype=object).take(
np.random.randint(0, 10000, size=N)
)
),
"floats": np.random.randn(N),
"ints": np.arange(N),
"dates": pd.date_range("20110101", freq="s", periods=N),
"timedeltas": pd.timedelta_range("1 day", freq="s", periods=N),
}
)
df["categories"] = df["strings"].astype("category")
df.iloc[10:20] = np.nan
return df | negative_train_query0_00531 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_frame
class Hashing:
def time_frame(self, df):
hashing.hash_pandas_object(df) | negative_train_query0_00532 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_int
class Hashing:
def time_series_int(self, df):
hashing.hash_pandas_object(df["ints"]) | negative_train_query0_00533 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_string
class Hashing:
def time_series_string(self, df):
hashing.hash_pandas_object(df["strings"]) | negative_train_query0_00534 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_float
class Hashing:
def time_series_float(self, df):
hashing.hash_pandas_object(df["floats"]) | negative_train_query0_00535 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_categorical
class Hashing:
def time_series_categorical(self, df):
hashing.hash_pandas_object(df["categories"]) | negative_train_query0_00536 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_timedeltas
class Hashing:
def time_series_timedeltas(self, df):
hashing.hash_pandas_object(df["timedeltas"]) | negative_train_query0_00537 | |
asv_bench/benchmarks/algorithms.py/Hashing/time_series_dates
class Hashing:
def time_series_dates(self, df):
hashing.hash_pandas_object(df["dates"]) | negative_train_query0_00538 | |
asv_bench/benchmarks/algorithms.py/Quantile/setup
class Quantile:
def setup(self, quantile, interpolation, dtype):
N = 10**5
if dtype in ["int64", "uint64"]:
data = np.arange(N, dtype=dtype)
elif dtype == "float64":
data = np.random.randn(N)
else:
raise NotImplementedError
self.ser = pd.Series(data.repeat(5)) | negative_train_query0_00539 | |
asv_bench/benchmarks/algorithms.py/Quantile/time_quantile
class Quantile:
def time_quantile(self, quantile, interpolation, dtype):
self.ser.quantile(quantile, interpolation=interpolation) | negative_train_query0_00540 | |
asv_bench/benchmarks/algorithms.py/SortIntegerArray/setup
class SortIntegerArray:
def setup(self, N):
data = np.arange(N, dtype=float)
data[40] = np.nan
self.array = pd.array(data, dtype="Int64") | negative_train_query0_00541 | |
asv_bench/benchmarks/algorithms.py/SortIntegerArray/time_argsort
class SortIntegerArray:
def time_argsort(self, N):
self.array.argsort() | negative_train_query0_00542 | |
asv_bench/benchmarks/libs.py/ScalarListLike/time_is_list_like
class ScalarListLike:
def time_is_list_like(self, param):
is_list_like(param) | negative_train_query0_00543 | |
asv_bench/benchmarks/libs.py/ScalarListLike/time_is_scalar
class ScalarListLike:
def time_is_scalar(self, param):
is_scalar(param) | negative_train_query0_00544 | |
asv_bench/benchmarks/libs.py/FastZip/setup
class FastZip:
def setup(self):
N = 10000
K = 10
key1 = Index([f"i-{i}" for i in range(N)], dtype=object).values.repeat(K)
key2 = Index([f"i-{i}" for i in range(N)], dtype=object).values.repeat(K)
col_array = np.vstack([key1, key2, np.random.randn(N * K)])
col_array2 = col_array.copy()
col_array2[:, :10000] = np.nan
self.col_array_list = list(col_array) | negative_train_query0_00545 | |
asv_bench/benchmarks/libs.py/FastZip/time_lib_fast_zip
class FastZip:
def time_lib_fast_zip(self):
lib.fast_zip(self.col_array_list) | negative_train_query0_00546 | |
asv_bench/benchmarks/libs.py/InferDtype/time_infer_dtype_skipna
class InferDtype:
def time_infer_dtype_skipna(self, dtype):
infer_dtype(self.data_dict[dtype], skipna=True) | negative_train_query0_00547 | |
asv_bench/benchmarks/libs.py/InferDtype/time_infer_dtype
class InferDtype:
def time_infer_dtype(self, dtype):
infer_dtype(self.data_dict[dtype], skipna=False) | negative_train_query0_00548 | |
asv_bench/benchmarks/libs.py/CacheReadonly/setup
class CacheReadonly:
def setup(self):
class Foo:
@cache_readonly
def prop(self):
return 5
self.obj = Foo() | negative_train_query0_00549 | |
asv_bench/benchmarks/libs.py/CacheReadonly/setup/Foo/prop
class CacheReadonly:
def prop(self):
return 5 | negative_train_query0_00550 | |
asv_bench/benchmarks/libs.py/CacheReadonly/time_cache_readonly
class CacheReadonly:
def time_cache_readonly(self):
self.obj.prop | negative_train_query0_00551 | |
asv_bench/benchmarks/finalize.py/Finalize/setup
class Finalize:
def setup(self, param):
N = 1000
obj = param(dtype=float)
for i in range(N):
obj.attrs[i] = i
self.obj = obj | negative_train_query0_00552 | |
asv_bench/benchmarks/finalize.py/Finalize/time_finalize_micro
class Finalize:
def time_finalize_micro(self, param):
self.obj.__finalize__(self.obj, method="__finalize__") | negative_train_query0_00553 | |
asv_bench/benchmarks/inference.py/ToNumeric/setup
class ToNumeric:
def setup(self):
N = 10000
self.float = Series(np.random.randn(N))
self.numstr = self.float.astype("str")
self.str = Series(Index([f"i-{i}" for i in range(N)], dtype=object)) | negative_train_query0_00554 | |
asv_bench/benchmarks/inference.py/ToNumeric/time_from_float
class ToNumeric:
def time_from_float(self):
to_numeric(self.float, errors="coerce") | negative_train_query0_00555 | |
asv_bench/benchmarks/inference.py/ToNumeric/time_from_numeric_str
class ToNumeric:
def time_from_numeric_str(self):
to_numeric(self.numstr, errors="coerce") | negative_train_query0_00556 | |
asv_bench/benchmarks/inference.py/ToNumeric/time_from_str
class ToNumeric:
def time_from_str(self):
to_numeric(self.str, errors="coerce") | negative_train_query0_00557 | |
asv_bench/benchmarks/inference.py/ToNumericDowncast/setup
class ToNumericDowncast:
def setup(self, dtype, downcast):
self.data = self.data_dict[dtype] | negative_train_query0_00558 | |
asv_bench/benchmarks/inference.py/ToNumericDowncast/time_downcast
class ToNumericDowncast:
def time_downcast(self, dtype, downcast):
to_numeric(self.data, downcast=downcast) | negative_train_query0_00559 | |
asv_bench/benchmarks/inference.py/MaybeConvertNumeric/setup_cache
class MaybeConvertNumeric:
def setup_cache(self):
N = 10**6
arr = np.repeat([2**63], N) + np.arange(N).astype("uint64")
data = arr.astype(object)
data[1::2] = arr[1::2].astype(str)
data[-1] = -1
return data | negative_train_query0_00560 | |
asv_bench/benchmarks/inference.py/MaybeConvertNumeric/time_convert
class MaybeConvertNumeric:
def time_convert(self, data):
lib.maybe_convert_numeric(data, set(), coerce_numeric=False) | negative_train_query0_00561 | |
asv_bench/benchmarks/inference.py/MaybeConvertObjects/setup
class MaybeConvertObjects:
def setup(self):
N = 10**5
data = list(range(N))
data[0] = NaT
data = np.array(data)
self.data = data | negative_train_query0_00562 | |
asv_bench/benchmarks/inference.py/MaybeConvertObjects/time_maybe_convert_objects
class MaybeConvertObjects:
def time_maybe_convert_objects(self):
lib.maybe_convert_objects(self.data) | negative_train_query0_00563 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/setup
class ToDatetimeFromIntsFloats:
def setup(self):
self.ts_sec = Series(range(1521080307, 1521685107), dtype="int64")
self.ts_sec_uint = Series(range(1521080307, 1521685107), dtype="uint64")
self.ts_sec_float = self.ts_sec.astype("float64")
self.ts_nanosec = 1_000_000 * self.ts_sec
self.ts_nanosec_uint = 1_000_000 * self.ts_sec_uint
self.ts_nanosec_float = self.ts_nanosec.astype("float64") | negative_train_query0_00564 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_nanosec_int64
class ToDatetimeFromIntsFloats:
def time_nanosec_int64(self):
to_datetime(self.ts_nanosec, unit="ns") | negative_train_query0_00565 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_nanosec_uint64
class ToDatetimeFromIntsFloats:
def time_nanosec_uint64(self):
to_datetime(self.ts_nanosec_uint, unit="ns") | negative_train_query0_00566 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_nanosec_float64
class ToDatetimeFromIntsFloats:
def time_nanosec_float64(self):
to_datetime(self.ts_nanosec_float, unit="ns") | negative_train_query0_00567 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_sec_uint64
class ToDatetimeFromIntsFloats:
def time_sec_uint64(self):
to_datetime(self.ts_sec_uint, unit="s") | negative_train_query0_00568 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_sec_int64
class ToDatetimeFromIntsFloats:
def time_sec_int64(self):
to_datetime(self.ts_sec, unit="s") | negative_train_query0_00569 | |
asv_bench/benchmarks/inference.py/ToDatetimeFromIntsFloats/time_sec_float64
class ToDatetimeFromIntsFloats:
def time_sec_float64(self):
to_datetime(self.ts_sec_float, unit="s") | negative_train_query0_00570 | |
asv_bench/benchmarks/inference.py/ToDatetimeYYYYMMDD/setup
class ToDatetimeYYYYMMDD:
def setup(self):
rng = date_range(start="1/1/2000", periods=10000, freq="D")
self.stringsD = Series(rng.strftime("%Y%m%d")) | negative_train_query0_00571 | |
asv_bench/benchmarks/inference.py/ToDatetimeYYYYMMDD/time_format_YYYYMMDD
class ToDatetimeYYYYMMDD:
def time_format_YYYYMMDD(self):
to_datetime(self.stringsD, format="%Y%m%d") | negative_train_query0_00572 | |
asv_bench/benchmarks/inference.py/ToDatetimeCacheSmallCount/setup
class ToDatetimeCacheSmallCount:
def setup(self, cache, count):
rng = date_range(start="1/1/1971", periods=count)
self.unique_date_strings = rng.strftime("%Y-%m-%d").tolist() | negative_train_query0_00573 | |
asv_bench/benchmarks/inference.py/ToDatetimeCacheSmallCount/time_unique_date_strings
class ToDatetimeCacheSmallCount:
def time_unique_date_strings(self, cache, count):
to_datetime(self.unique_date_strings, cache=cache) | negative_train_query0_00574 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/setup
class ToDatetimeISO8601:
def setup(self):
rng = date_range(start="1/1/2000", periods=20000, freq="h")
self.strings = rng.strftime("%Y-%m-%d %H:%M:%S").tolist()
self.strings_nosep = rng.strftime("%Y%m%d %H:%M:%S").tolist()
self.strings_tz_space = [
x.strftime("%Y-%m-%d %H:%M:%S") + " -0800" for x in rng
]
self.strings_zero_tz = [x.strftime("%Y-%m-%d %H:%M:%S") + "Z" for x in rng] | negative_train_query0_00575 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601
class ToDatetimeISO8601:
def time_iso8601(self):
to_datetime(self.strings) | negative_train_query0_00576 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601_nosep
class ToDatetimeISO8601:
def time_iso8601_nosep(self):
to_datetime(self.strings_nosep) | negative_train_query0_00577 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601_format
class ToDatetimeISO8601:
def time_iso8601_format(self):
to_datetime(self.strings, format="%Y-%m-%d %H:%M:%S") | negative_train_query0_00578 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601_format_no_sep
class ToDatetimeISO8601:
def time_iso8601_format_no_sep(self):
to_datetime(self.strings_nosep, format="%Y%m%d %H:%M:%S") | negative_train_query0_00579 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601_tz_spaceformat
class ToDatetimeISO8601:
def time_iso8601_tz_spaceformat(self):
to_datetime(self.strings_tz_space) | negative_train_query0_00580 | |
asv_bench/benchmarks/inference.py/ToDatetimeISO8601/time_iso8601_infer_zero_tz_fromat
class ToDatetimeISO8601:
def time_iso8601_infer_zero_tz_fromat(self):
# GH 41047
to_datetime(self.strings_zero_tz) | negative_train_query0_00581 | |
asv_bench/benchmarks/inference.py/ToDatetimeNONISO8601/setup
class ToDatetimeNONISO8601:
def setup(self):
N = 10000
half = N // 2
ts_string_1 = "March 1, 2018 12:00:00+0400"
ts_string_2 = "March 1, 2018 12:00:00+0500"
self.same_offset = [ts_string_1] * N
self.diff_offset = [ts_string_1] * half + [ts_string_2] * half | negative_train_query0_00582 | |
asv_bench/benchmarks/inference.py/ToDatetimeNONISO8601/time_same_offset
class ToDatetimeNONISO8601:
def time_same_offset(self):
to_datetime(self.same_offset) | negative_train_query0_00583 | |
asv_bench/benchmarks/inference.py/ToDatetimeNONISO8601/time_different_offset
class ToDatetimeNONISO8601:
def time_different_offset(self):
to_datetime(self.diff_offset, utc=True) | negative_train_query0_00584 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormatQuarters/setup
class ToDatetimeFormatQuarters:
def setup(self):
self.s = Series(["2Q2005", "2Q05", "2005Q1", "05Q1"] * 10000) | negative_train_query0_00585 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormatQuarters/time_infer_quarter
class ToDatetimeFormatQuarters:
def time_infer_quarter(self):
to_datetime(self.s) | negative_train_query0_00586 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/setup
class ToDatetimeFormat:
def setup(self):
N = 100000
self.s = Series(["19MAY11", "19MAY11:00:00:00"] * N)
self.s2 = self.s.str.replace(":\\S+$", "", regex=True)
self.same_offset = ["10/11/2018 00:00:00.045-07:00"] * N
self.diff_offset = [
f"10/11/2018 00:00:00.045-0{offset}:00" for offset in range(10)
] * (N // 10) | negative_train_query0_00587 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/time_exact
class ToDatetimeFormat:
def time_exact(self):
to_datetime(self.s2, format="%d%b%y") | negative_train_query0_00588 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/time_no_exact
class ToDatetimeFormat:
def time_no_exact(self):
to_datetime(self.s, format="%d%b%y", exact=False) | negative_train_query0_00589 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/time_same_offset
class ToDatetimeFormat:
def time_same_offset(self):
to_datetime(self.same_offset, format="%m/%d/%Y %H:%M:%S.%f%z") | negative_train_query0_00590 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/time_same_offset_to_utc
class ToDatetimeFormat:
def time_same_offset_to_utc(self):
to_datetime(self.same_offset, format="%m/%d/%Y %H:%M:%S.%f%z", utc=True) | negative_train_query0_00591 | |
asv_bench/benchmarks/inference.py/ToDatetimeFormat/time_different_offset_to_utc
class ToDatetimeFormat:
def time_different_offset_to_utc(self):
to_datetime(self.diff_offset, format="%m/%d/%Y %H:%M:%S.%f%z", utc=True) | negative_train_query0_00592 | |
asv_bench/benchmarks/inference.py/ToDatetimeCache/setup
class ToDatetimeCache:
def setup(self, cache):
N = 10000
self.unique_numeric_seconds = list(range(N))
self.dup_numeric_seconds = [1000] * N
self.dup_string_dates = ["2000-02-11"] * N
self.dup_string_with_tz = ["2000-02-11 15:00:00-0800"] * N | negative_train_query0_00593 | |
asv_bench/benchmarks/inference.py/ToDatetimeCache/time_unique_seconds_and_unit
class ToDatetimeCache:
def time_unique_seconds_and_unit(self, cache):
to_datetime(self.unique_numeric_seconds, unit="s", cache=cache) | negative_train_query0_00594 | |
asv_bench/benchmarks/inference.py/ToDatetimeCache/time_dup_seconds_and_unit
class ToDatetimeCache:
def time_dup_seconds_and_unit(self, cache):
to_datetime(self.dup_numeric_seconds, unit="s", cache=cache) | negative_train_query0_00595 | |
asv_bench/benchmarks/inference.py/ToDatetimeCache/time_dup_string_dates
class ToDatetimeCache:
def time_dup_string_dates(self, cache):
to_datetime(self.dup_string_dates, cache=cache) | negative_train_query0_00596 | |
asv_bench/benchmarks/inference.py/ToDatetimeCache/time_dup_string_dates_and_format
class ToDatetimeCache:
def time_dup_string_dates_and_format(self, cache):
to_datetime(self.dup_string_dates, format="%Y-%m-%d", cache=cache) | negative_train_query0_00597 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.