Datasets:

nebius
/

SWE-bench-extra

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 6.38k rows

instance_id stringlengths 10 57	patch stringlengths 261 37.7k	repo stringlengths 7 53	base_commit stringlengths 40 40	test_patch stringlengths 212 2.22M	problem_statement stringlengths 23 37.7k	environment_setup_commit stringlengths 40 40	FAIL_TO_PASS listlengths 1 4.94k	PASS_TO_PASS listlengths 0 7.82k	meta dict	created_at stringlengths 25 25	license stringclasses 8 values	__index_level_0__ int64 0 6.41k
sdementen__piecash-182	diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 1d965e0..3a45556 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -1,6 +1,11 @@ What's new ========== +devel +~~~~~ + +- fix tzlocal>=2.3 issue with change of tz type returned by tzlocal.get_localzone() (fix #180) + Version 1.1.7 (2021-04-04) ~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/piecash/sa_extra.py b/piecash/sa_extra.py index 8b8a8c5..49f148f 100644 --- a/piecash/sa_extra.py +++ b/piecash/sa_extra.py @@ -69,7 +69,7 @@ class DeclarativeBase(object): return str(self) -tz = tzlocal.get_localzone() +tz = pytz.timezone(str(tzlocal.get_localzone())) utc = pytz.utc @@ -158,8 +158,8 @@ class _DateAsDateTime(types.TypeDecorator): def process_result_value(self, value, dialect): if value is not None: - r = utc.localize(value).astimezone(tz).date() - return r + r = utc.localize(value).astimezone(tz) + return r.date() class _Date(types.TypeDecorator):	sdementen/piecash	5621c1d22f747f42eae53b10b1adce06d0a34cb8	diff --git a/tests/test_factories.py b/tests/test_factories.py index 6cf2bbd..e13dd12 100644 --- a/tests/test_factories.py +++ b/tests/test_factories.py @@ -5,6 +5,7 @@ from datetime import datetime from decimal import Decimal import pytest +import pytz import tzlocal from piecash import GnucashException, Commodity @@ -127,13 +128,13 @@ class TestFactoriesTransactions(object): assert sp2.account == book_basic.accounts(name="asset") assert sp1.value == -sp2.value assert sp1.quantity == sp1.value - assert tr.enter_date == tzlocal.get_localzone().localize( + assert tr.enter_date == pytz.timezone(str(tzlocal.get_localzone())).localize( today.replace(microsecond=0) ) - assert tr.post_date == tzlocal.get_localzone().localize(today).date() + assert tr.post_date == pytz.timezone(str(tzlocal.get_localzone())).localize(today).date() def test_single_transaction_tz(self, book_basic): - today = tzlocal.get_localzone().localize(datetime.today()) + today = pytz.timezone(str(tzlocal.get_localzone())).localize(datetime.today()) tr = factories.single_transaction( today.date(), today, @@ -148,7 +149,7 @@ class TestFactoriesTransactions(object): assert tr.enter_date == today.replace(microsecond=0) def test_single_transaction_rollback(self, book_basic): - today = tzlocal.get_localzone().localize(datetime.today()) + today = pytz.timezone(str(tzlocal.get_localzone())).localize(datetime.today()) factories.single_transaction( today.date(), today,	TZLocal update to 3.0 breaks piecash 2.1 works fine. Throws this exception: ``` File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/gnucash_reports/wrapper.py", line 241, in get_balance_on_date ).order_by(piecash.Price.date.desc()).limit(1).one_or_none() File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/orm/query.py", line 3459, in one_or_none ret = list(self) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/orm/query.py", line 3535, in __iter__ return self._execute_and_instances(context) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/orm/query.py", line 3560, in _execute_and_instances result = conn.execute(querycontext.statement, self._params) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/base.py", line 1011, in execute return meth(self, multiparams, params) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/sql/elements.py", line 298, in _execute_on_connection return connection._execute_clauseelement(self, multiparams, params) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/base.py", line 1130, in _execute_clauseelement distilled_params, File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/base.py", line 1207, in _execute_context e, util.text_type(statement), parameters, None, None File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/base.py", line 1511, in _handle_dbapi_exception sqlalchemy_exception, with_traceback=exc_info[2], from_=e File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/util/compat.py", line 182, in raise_ raise exception File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/base.py", line 1204, in _execute_context context = constructor(dialect, self, conn, *args) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/engine/default.py", line 854, in _init_compiled param.append(processors[key](compiled_params[key])) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/sqlalchemy/sql/type_api.py", line 1232, in process return process_param(value, dialect) File "/usr/local/data/laminar/run/accounts_update/1055/accounts/env/lib/python3.7/site-packages/piecash/sa_extra.py", line 140, in process_bind_param result = tz.localize(datetime.datetime.combine(value, datetime.time(0, 0, 0))) \ sqlalchemy.exc.StatementError: (builtins.AttributeError) 'backports.zoneinfo.ZoneInfo' object has no attribute 'localize' [SQL: SELECT prices.value_num AS prices_value_num, prices.value_denom AS prices_value_denom, prices.guid AS prices_guid, prices.commodity_guid AS prices_commodity_guid, prices.currency_guid AS prices_currency_guid, prices.date AS prices_date, prices.source AS prices_source, prices.type AS prices_type FROM prices WHERE %s = prices.commodity_guid AND %s = prices.currency_guid AND prices.date <= %s ORDER BY prices.date DESC LIMIT %s] ```	5621c1d22f747f42eae53b10b1adce06d0a34cb8	[ "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction[None]", "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]" ]	[ "tests/test_factories.py::TestFactoriesCommodities::test_create_stock_accounts_simple[None]", "tests/test_factories.py::TestFactoriesCommodities::test_create_stock_accounts_simple[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]", "tests/test_factories.py::TestFactoriesCommodities::test_create_stock_accounts_incomeaccounts[None]", "tests/test_factories.py::TestFactoriesCommodities::test_create_stock_accounts_incomeaccounts[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]", "tests/test_factories.py::TestFactoriesCommodities::test_create_currency_from_ISO[None]", "tests/test_factories.py::TestFactoriesCommodities::test_create_currency_from_ISO[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]", "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction_tz[None]", "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction_tz[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]", "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction_rollback[None]", "tests/test_factories.py::TestFactoriesTransactions::test_single_transaction_rollback[sqlite:////root/data/temp_dir/tmpy4n44f3x/sdementen__piecash__0.0/tests/foozbar.sqlite]" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2021-08-18 15:45:23+00:00	mit	5,435
sdepy__sdepy-21	diff --git a/sdepy/integration.py b/sdepy/integration.py index 60aa665..6557a3e 100644 --- a/sdepy/integration.py +++ b/sdepy/integration.py @@ -714,7 +714,7 @@ class integrator(paths_generator): x = xw[0] # compute A, dZ and make them available as attributes A, dZ = self.A(s, x), self.dZ(s, ds) - xw[1][...] = x + sum(A[id]dZ[id] for id in A.keys()) + xw[1][...] = x + sum(A.get(id, 0)dZ[id] for id in A.keys()) if self.getinfo: iv.update(last_t=s, last_dt=ds, @@ -1186,13 +1186,29 @@ class SDE: # algorithm of the integrator class # ----------------------------------- + def _check_sde_values(self, A): + if not isinstance(A, dict): + raise TypeError( + 'invalid {} return values: a dict, not a {} object expected' + .format(self.sde, type(A)) + ) + if not set(A.keys()).issubset(self.sources): + raise KeyError( + 'invalid {} return values: {} entries expected (one per ' + 'stochasticity source), not {}' + .format(self.sde, set(self.sources), set(A.keys())) + ) + def A(self, t, x): """See documentation integrator.A""" sde_args_eval = { k: (z(t) if callable(z) else z) for (k, z) in self._get_args(self._sde_args_keys).items() } - return self.sde(t, x, sde_args_eval) + # get and check sde values + A_ = self.sde(t, x, sde_args_eval) + self._check_sde_values(A_) + return A_ def dZ(self, t, dt): """See documentation of integrator.dZ""" @@ -1642,6 +1658,20 @@ class SDEs(SDE): # algorithm of the integrator class # ----------------------------------- + def _check_sde_values(self, As): + if not isinstance(As, (list, tuple)): + raise TypeError( + 'invalid {} return values: a list or tuple of {} dict ' + '(one per equation) expected, not a {} object' + .format(self.sde, self.q, type(As)) + ) + if len(As) != self.q: + raise ValueError( + 'invalid {} return values: {} equations expected, ' + 'not {}'.format(self.sde, self.q, len(As))) + for a in As: + super()._check_sde_values(a) + def A(self, t, X): """See documentation of integrator.A""" sde_args_eval = { @@ -1653,12 +1683,13 @@ class SDEs(SDE): # of arrays (one per equation) xs = self.unpack(X) - # get sde values, as a list of dicts (one per equation) + # get and check sde values As = self.sde(t, xs, *sde_args_eval) + self._check_sde_values(As) A_ids = set() for a in As: - A_ids.update(a) - A = {id: self.pack(tuple(a[id] for a in As)) + A_ids.update(a.keys()) + A = {id: self.pack(tuple(a.get(id, 0) for a in As)) for id in A_ids} return A @@ -1739,7 +1770,6 @@ class SDEs(SDE): Parameters ---------- - t : float Time point at which the SDE should be evaluated. x, y, ... : arrays @@ -1751,9 +1781,8 @@ class SDEs(SDE): Returns ------- - - sde_terms : list of dict of arrays - A list of dictionaries, one per equation. + sde_terms : list or tuple of dict of arrays + A list or tuple of dictionaries, one per equation. See documentation of ``SDE.sde``. Notes	sdepy/sdepy	6396bfdb9e690afcc6c549bc4a0bd8f0263307ff	diff --git a/sdepy/tests/test_integrator.py b/sdepy/tests/test_integrator.py index a06788e..47bf979 100644 --- a/sdepy/tests/test_integrator.py +++ b/sdepy/tests/test_integrator.py @@ -386,3 +386,62 @@ def test_SDE(): xs2 = integrate(f)(x0=(1.,)4, dw=tw, paths=11, steps=30)(t) for u, v in zip(xs1, xs2): assert_allclose(xs1, xs2, rtol=eps(u.dtype)) + + # 4 equations with terms partially omitted + # (formerly a cause of error) + # ---------------------------------------- + @integrate + def f_process(t, x=0, y=0, z=0, w=0): + return ({'dt': 1, 'dw': 1}, {'dt': 1}, {'dw': 1}, {}) + xs = f_process(x0=(1,)4, paths=11, steps=30)(t) + + # SDE class from integrate + # ------------------------ + @integrate(q=1, sources={'dw', 'dt'}) + def f_process(t, x): + return {'dt': 1, 'dw': 1} + assert_(issubclass(f_process, SDE)) + assert_(issubclass(f_process, SDEs)) # FIXME: should be SDE subclass only + + @integrate + def f_process(t, x): + return {'dt': 1, 'dw': 1} + assert_ (issubclass(f_process, SDE)) + assert_(not issubclass(f_process, SDEs)) # this is ok + + # test errors + # ----------- + + # SDE: ok + class f_process(SDE, integrator): + def sde(self, t, x): + return {'dt': 1, 'dw': 1} + x = f_process(x0=1, paths=11, steps=30)(t) + + # SDE: wrong type + f_process.sde = lambda self, t, x: x + assert_raises(TypeError, f_process(x0=1, paths=11, steps=30), t) + + # SDE: wrong sde entry + f_process.sde = lambda self, t, x: {'dt': 1, 'dzzz': 1} + assert_raises(KeyError, f_process(x0=1, paths=11, steps=30), t) + + # SDEs: ok + @integrate(q=2, sources=('dt', 'dw')) + def f_process(t, x, y): + return {'dt': 1, 'dw': 1}, {'dt': 1} + assert f_process.q == 2 + x, y = f_process(x0=(1,)2, paths=11, steps=30)(t) + + # SDEs: wrong type + f_process.sde = lambda self, t, x, y: {'dt': 1, 'dw': 1} + assert f_process.q == 2 + assert_raises(TypeError, f_process(x0=(1,)2, paths=11, steps=30), t) + + # SDEs: wrong number of equations + f_process.sde = lambda self, t, x, y: ({'dt': 1, 'dw': 1},) + assert_raises(ValueError, f_process(x0=(1,)2, paths=11, steps=30), t) + + # SDEs: wrong sde entry + f_process.sde = lambda self, t, x, y: ({'dt': 1}, {'dzzz': 1}) + assert_raises(KeyError, f_process(x0=(1,)2, paths=11, steps=30), t)	Improve checks on 'sde()' method for user defined 'SDE' or 'SDEs' subclasses An improper setup of user defined ``SDE`` or ``SDEs`` subclasses (e.g. ``sde()`` method returning an number of equation terms inconsistent with its arguments, or same method inherited without adaptations from ``SDE`` to ``SDEs`` subclasses) results in ungraceful failures upon integration, with opaque tracebacks.	6396bfdb9e690afcc6c549bc4a0bd8f0263307ff	[ "sdepy/tests/test_integrator.py::test_SDE" ]	[ "sdepy/tests/test_integrator.py::test_generator_t", "sdepy/tests/test_integrator.py::test_generator_steps", "sdepy/tests/test_integrator.py::test_generator_depth" ]	{ "failed_lite_validators": [ "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-04-24 11:49:38+00:00	bsd-3-clause	5,436
sdispater__pendulum-174	diff --git a/pendulum/pendulum.py b/pendulum/pendulum.py index cbbf94a..6cca7f6 100644 --- a/pendulum/pendulum.py +++ b/pendulum/pendulum.py @@ -1980,16 +1980,10 @@ class Pendulum(Date, datetime.datetime): return(self, ) def _getstate(self, protocol=3): - tz = self.timezone_name - - # Fix for fixed timezones not being properly unpickled - if isinstance(self.tz, FixedTimezone): - tz = self.offset_hours - return ( self.year, self.month, self.day, self.hour, self.minute, self.second, self.microsecond, - tz, + self.tzinfo, self.fold ) diff --git a/pendulum/tz/timezone.py b/pendulum/tz/timezone.py index cb520de..416b352 100644 --- a/pendulum/tz/timezone.py +++ b/pendulum/tz/timezone.py @@ -512,7 +512,7 @@ class FixedTimezone(Timezone): return (dt + self._tzinfo.adjusted_offset).replace(tzinfo=self._tzinfo) def __getinitargs__(self): - return self._offset + return (self._offset, ) class _UTC(FixedTimezone):	sdispater/pendulum	5a596b0ab75960a8e86700cbe0f9ae6ec4fe1442	diff --git a/tests/pendulum_tests/test_behavior.py b/tests/pendulum_tests/test_behavior.py index 12a1285..76d90ed 100644 --- a/tests/pendulum_tests/test_behavior.py +++ b/tests/pendulum_tests/test_behavior.py @@ -6,6 +6,7 @@ from copy import deepcopy from datetime import datetime, date, time, timedelta from pendulum import Pendulum, timezone from pendulum.tz.timezone import Timezone +from pendulum.tz.loader import Loader from .. import AbstractTestCase @@ -101,6 +102,14 @@ class BehaviorTest(AbstractTestCase): self.assertEqual(dt1, dt2) + def test_pickle_with_empty_tzinfo_name(self): + empty_timezone = Timezone('', *Loader.load('Europe/Paris')) + dt1 = Pendulum(2016, 8, 27, 12, 34, 56, 123456, empty_timezone) + s = pickle.dumps(dt1) + dt2 = pickle.loads(s) + + self.assertEqual(dt1, dt2) + def test_proper_dst(self): dt = pendulum.create(1941, 7, 1, tz='Europe/Amsterdam')	Timezone is empty on Windows 10 bash shell, causing error while unpickling Pendulum objects Hello. This is maybe related to #161, but I'm not sure. When I run this using the Windows 10 bash shell: ```python import pendulum import pendulum.version import pickle import sys print("Python version:", sys.version) print("Pendulum version:", pendulum.version.VERSION) now = pendulum.now() print(now, now.timezone) pickled = pickle.dumps(now) pickle.loads(pickled) ``` It raises an error (but it works fine with W10 Python installation): ``` Python version: 3.6.3 (default, Oct 4 2017, 02:55:45) [GCC 5.4.0 20160609] Pendulum version: 1.3.2 2017-12-11T20:31:49.750107+01:00 <Timezone []> Traceback (most recent call last): File "test.py", line 12, in <module> pickle.loads(pickled) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pendulum/pendulum.py", line 155, in __init__ self._tz = self._safe_create_datetime_zone(tzinfo) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pendulum/pendulum.py", line 82, in _safe_create_datetime_zone return cls._timezone(obj) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pendulum/pendulum.py", line 107, in _timezone return Timezone.load(zone) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pendulum/tz/timezone.py", line 90, in load utc_transition_times) = Loader.load(name) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pendulum/tz/loader.py", line 33, in load with tz_file(name) as f: File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pytzdata/__init__.py", line 32, in tz_file filepath = tz_path(name) File "/mnt/c/Users/delgan/Desktop/project/env/lib/python3.6/site-packages/pytzdata/__init__.py", line 62, in tz_path raise ValueError('Invalid timezone') ValueError: Invalid timezone ``` As you can see, the timezone is empty, which causes an exception equivalent to `pendulum.now(tz='')`. Yet, the `now()` worked fine because the time contains `+01:00`. Do you have any idea where the bug might come from?	5a596b0ab75960a8e86700cbe0f9ae6ec4fe1442	[ "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_pickle_with_empty_tzinfo_name" ]	[ "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_astimezone", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_combine", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_ctime", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_date", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_deepcopy", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_deepcopy_datetime", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_dst", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_fromordinal", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_fromtimestamp", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_hash", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_isocalendar", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_isoformat", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_isoweekday", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_pickle", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_pickle_timezone", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_pickle_with_integer_tzinfo", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_proper_dst", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_time", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_timetuple", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_timetz", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_toordinal", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_tzname", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_utcfromtimestamp", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_utcoffset", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_utctimetuple", "tests/pendulum_tests/test_behavior.py::BehaviorTest::test_weekday" ]	{ "failed_lite_validators": [ "has_issue_reference", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2018-01-26 00:08:01+00:00	mit	5,437
sdispater__pendulum-540	diff --git a/pendulum/locales/cs/__init__.py b/pendulum/locales/cs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/pendulum/locales/cs/custom.py b/pendulum/locales/cs/custom.py new file mode 100644 index 0000000..5f66b69 --- /dev/null +++ b/pendulum/locales/cs/custom.py @@ -0,0 +1,23 @@ +""" +cs custom locale file. +""" + +translations = { + "units": {"few_second": "pár vteřin"}, + # Relative time + "ago": "{} zpět", + "from_now": "za {}", + "after": "{0} po", + "before": "{0} zpět", + # Ordinals + "ordinal": {"one": ".", "two": ".", "few": ".", "other": "."}, + # Date formats + "date_formats": { + "LTS": "h:mm:ss", + "LT": "h:mm", + "L": "DD. M. YYYY", + "LL": "D. MMMM, YYYY", + "LLL": "D. MMMM, YYYY h:mm", + "LLLL": "dddd, D. MMMM, YYYY h:mm", + }, +} diff --git a/pendulum/locales/cs/locale.py b/pendulum/locales/cs/locale.py new file mode 100644 index 0000000..2c51c78 --- /dev/null +++ b/pendulum/locales/cs/locale.py @@ -0,0 +1,266 @@ +from .custom import translations as custom_translations + + +""" +cs locale file. + +It has been generated automatically and must not be modified directly. +""" + + +locale = { + "plural": lambda n: "few" + if ((n == n and (n >= 2 and n <= 4)) and (0 == 0 and (0 == 0))) + else "many" + if (not (0 == 0 and (0 == 0))) + else "one" + if ((n == n and (n == 1)) and (0 == 0 and (0 == 0))) + else "other", + "ordinal": lambda n: "other", + "translations": { + "days": { + "abbreviated": { + 0: "ne", + 1: "po", + 2: "út", + 3: "st", + 4: "čt", + 5: "pá", + 6: "so", + }, + "narrow": { + 0: "N", + 1: "P", + 2: "Ú", + 3: "S", + 4: "Č", + 5: "P", + 6: "S", + }, + "short": { + 0: "ne", + 1: "po", + 2: "út", + 3: "st", + 4: "čt", + 5: "pá", + 6: "so", + }, + "wide": { + 0: "neděle", + 1: "pondělí", + 2: "úterý", + 3: "středa", + 4: "čtvrtek", + 5: "pátek", + 6: "sobota", + }, + }, + "months": { + "abbreviated": { + 1: "led", + 2: "úno", + 3: "bře", + 4: "dub", + 5: "kvě", + 6: "čvn", + 7: "čvc", + 8: "srp", + 9: "zář", + 10: "říj", + 11: "lis", + 12: "pro", + }, + "narrow": { + 1: "1", + 2: "2", + 3: "3", + 4: "4", + 5: "5", + 6: "6", + 7: "7", + 8: "8", + 9: "9", + 10: "10", + 11: "11", + 12: "12", + }, + "wide": { + 1: "ledna", + 2: "února", + 3: "března", + 4: "dubna", + 5: "května", + 6: "června", + 7: "července", + 8: "srpna", + 9: "září", + 10: "října", + 11: "listopadu", + 12: "prosince", + }, + }, + "units": { + "year": { + "one": "{0} rok", + "few": "{0} roky", + "many": "{0} roku", + "other": "{0} let", + }, + "month": { + "one": "{0} měsíc", + "few": "{0} měsíce", + "many": "{0} měsíce", + "other": "{0} měsíců", + }, + "week": { + "one": "{0} týden", + "few": "{0} týdny", + "many": "{0} týdne", + "other": "{0} týdnů", + }, + "day": { + "one": "{0} den", + "few": "{0} dny", + "many": "{0} dne", + "other": "{0} dní", + }, + "hour": { + "one": "{0} hodina", + "few": "{0} hodiny", + "many": "{0} hodiny", + "other": "{0} hodin", + }, + "minute": { + "one": "{0} minuta", + "few": "{0} minuty", + "many": "{0} minuty", + "other": "{0} minut", + }, + "second": { + "one": "{0} sekunda", + "few": "{0} sekundy", + "many": "{0} sekundy", + "other": "{0} sekund", + }, + "microsecond": { + "one": "{0} mikrosekunda", + "few": "{0} mikrosekundy", + "many": "{0} mikrosekundy", + "other": "{0} mikrosekund", + }, + }, + "relative": { + "year": { + "future": { + "other": "za {0} let", + "one": "za {0} rok", + "few": "za {0} roky", + "many": "za {0} roku", + }, + "past": { + "other": "před {0} lety", + "one": "před {0} rokem", + "few": "před {0} lety", + "many": "před {0} roku", + }, + }, + "month": { + "future": { + "other": "za {0} měsíců", + "one": "za {0} měsíc", + "few": "za {0} měsíce", + "many": "za {0} měsíce", + }, + "past": { + "other": "před {0} měsíci", + "one": "před {0} měsícem", + "few": "před {0} měsíci", + "many": "před {0} měsíce", + }, + }, + "week": { + "future": { + "other": "za {0} týdnů", + "one": "za {0} týden", + "few": "za {0} týdny", + "many": "za {0} týdne", + }, + "past": { + "other": "před {0} týdny", + "one": "před {0} týdnem", + "few": "před {0} týdny", + "many": "před {0} týdne", + }, + }, + "day": { + "future": { + "other": "za {0} dní", + "one": "za {0} den", + "few": "za {0} dny", + "many": "za {0} dne", + }, + "past": { + "other": "před {0} dny", + "one": "před {0} dnem", + "few": "před {0} dny", + "many": "před {0} dne", + }, + }, + "hour": { + "future": { + "other": "za {0} hodin", + "one": "za {0} hodinu", + "few": "za {0} hodiny", + "many": "za {0} hodiny", + }, + "past": { + "other": "před {0} hodinami", + "one": "před {0} hodinou", + "few": "před {0} hodinami", + "many": "před {0} hodiny", + }, + }, + "minute": { + "future": { + "other": "za {0} minut", + "one": "za {0} minutu", + "few": "za {0} minuty", + "many": "za {0} minuty", + }, + "past": { + "other": "před {0} minutami", + "one": "před {0} minutou", + "few": "před {0} minutami", + "many": "před {0} minuty", + }, + }, + "second": { + "future": { + "other": "za {0} sekund", + "one": "za {0} sekundu", + "few": "za {0} sekundy", + "many": "za {0} sekundy", + }, + "past": { + "other": "před {0} sekundami", + "one": "před {0} sekundou", + "few": "před {0} sekundami", + "many": "před {0} sekundy", + }, + }, + }, + "day_periods": { + "midnight": "půlnoc", + "am": "dop.", + "noon": "poledne", + "pm": "odp.", + "morning1": "ráno", + "morning2": "dopoledne", + "afternoon1": "odpoledne", + "evening1": "večer", + "night1": "v noci", + }, + }, + "custom": custom_translations, +}	sdispater/pendulum	0ba5cc17644ec46eba1bfd54a5c1488d3479f6d7	diff --git a/tests/localization/test_cs.py b/tests/localization/test_cs.py new file mode 100644 index 0000000..f1c6b94 --- /dev/null +++ b/tests/localization/test_cs.py @@ -0,0 +1,108 @@ +import pendulum + + +locale = "cs" + + +def test_diff_for_humans(): + with pendulum.test(pendulum.datetime(2016, 8, 29)): + diff_for_humans() + + +def diff_for_humans(): + d = pendulum.now().subtract(seconds=1) + assert d.diff_for_humans(locale=locale) == "pár vteřin zpět" + + d = pendulum.now().subtract(seconds=2) + assert d.diff_for_humans(locale=locale) == "pár vteřin zpět" + + d = pendulum.now().subtract(seconds=20) + assert d.diff_for_humans(locale=locale) == "před 20 sekundami" + + d = pendulum.now().subtract(minutes=1) + assert d.diff_for_humans(locale=locale) == "před 1 minutou" + + d = pendulum.now().subtract(minutes=2) + assert d.diff_for_humans(locale=locale) == "před 2 minutami" + + d = pendulum.now().subtract(minutes=5) + assert d.diff_for_humans(locale=locale) == "před 5 minutami" + + d = pendulum.now().subtract(hours=1) + assert d.diff_for_humans(locale=locale) == "před 1 hodinou" + + d = pendulum.now().subtract(hours=2) + assert d.diff_for_humans(locale=locale) == "před 2 hodinami" + + d = pendulum.now().subtract(hours=5) + assert d.diff_for_humans(locale=locale) == "před 5 hodinami" + + d = pendulum.now().subtract(days=1) + assert d.diff_for_humans(locale=locale) == "před 1 dnem" + + d = pendulum.now().subtract(days=2) + assert d.diff_for_humans(locale=locale) == "před 2 dny" + + d = pendulum.now().subtract(weeks=1) + assert d.diff_for_humans(locale=locale) == "před 1 týdnem" + + d = pendulum.now().subtract(weeks=2) + assert d.diff_for_humans(locale=locale) == "před 2 týdny" + + d = pendulum.now().subtract(months=1) + assert d.diff_for_humans(locale=locale) == "před 1 měsícem" + + d = pendulum.now().subtract(months=2) + assert d.diff_for_humans(locale=locale) == "před 2 měsíci" + + d = pendulum.now().subtract(months=5) + assert d.diff_for_humans(locale=locale) == "před 5 měsíci" + + d = pendulum.now().subtract(years=1) + assert d.diff_for_humans(locale=locale) == "před 1 rokem" + + d = pendulum.now().subtract(years=2) + assert d.diff_for_humans(locale=locale) == "před 2 lety" + + d = pendulum.now().subtract(years=5) + assert d.diff_for_humans(locale=locale) == "před 5 lety" + + d = pendulum.now().add(seconds=1) + assert d.diff_for_humans(locale=locale) == "za pár vteřin" + + d = pendulum.now().add(seconds=1) + d2 = pendulum.now() + assert d.diff_for_humans(d2, locale=locale) == "pár vteřin po" + assert d2.diff_for_humans(d, locale=locale) == "pár vteřin zpět" + + assert d.diff_for_humans(d2, True, locale=locale) == "pár vteřin" + assert d2.diff_for_humans(d.add(seconds=1), True, locale=locale) == "pár vteřin" + + d = pendulum.now().add(seconds=20) + d2 = pendulum.now() + assert d.diff_for_humans(d2, locale=locale) == "20 sekund po" + assert d2.diff_for_humans(d, locale=locale) == "20 sekund zpět" + + d = pendulum.now().add(seconds=10) + d2 = pendulum.now() + assert d.diff_for_humans(d2, True, locale=locale) == "pár vteřin" + assert d2.diff_for_humans(d.add(seconds=1), True, locale=locale) == "11 sekund" + + +def test_format(): + d = pendulum.datetime(2016, 8, 29, 7, 3, 6, 123456) + assert d.format("dddd", locale=locale) == "pondělí" + assert d.format("ddd", locale=locale) == "po" + assert d.format("MMMM", locale=locale) == "srpna" + assert d.format("MMM", locale=locale) == "srp" + assert d.format("A", locale=locale) == "dop." + assert d.format("Qo", locale=locale) == "3." + assert d.format("Mo", locale=locale) == "8." + assert d.format("Do", locale=locale) == "29." + + assert d.format("LT", locale=locale) == "7:03" + assert d.format("LTS", locale=locale) == "7:03:06" + assert d.format("L", locale=locale) == "29. 8. 2016" + assert d.format("LL", locale=locale) == "29. srpna, 2016" + assert d.format("LLL", locale=locale) == "29. srpna, 2016 7:03" + assert d.format("LLLL", locale=locale) == "pondělí, 29. srpna, 2016 7:03"	Missing Czech [cs] locale - [x] I have searched the [issues](https://github.com/sdispater/pendulum/issues) of this repo and believe that this is not a duplicate. - [x] I have searched the [documentation](https://pendulum.eustace.io/docs/) and believe that my question is not covered. ## Feature Request Missing localization for Czech language. I will take care of the code and open PR.	0ba5cc17644ec46eba1bfd54a5c1488d3479f6d7	[ "tests/localization/test_cs.py::test_diff_for_humans", "tests/localization/test_cs.py::test_format" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_added_files" ], "has_test_patch": true, "is_lite": false }	2021-03-30 11:05:43+00:00	mit	5,438
sdispater__pendulum-593	diff --git a/pendulum/duration.py b/pendulum/duration.py index 45df13d..47a6a38 100644 --- a/pendulum/duration.py +++ b/pendulum/duration.py @@ -23,6 +23,10 @@ def _divide_and_round(a, b): # Based on the reference implementation for divmod_near # in Objects/longobject.c. q, r = divmod(a, b) + + if isinstance(q, float): + q = int(q) + # round up if either r / b > 0.5, or r / b == 0.5 and q is odd. # The expression r / b > 0.5 is equivalent to 2 * r > b if b is # positive, 2 * r < b if b negative.	sdispater/pendulum	8012a7e8600c2348f1978eebb22fdd2535a8cca9	diff --git a/tests/duration/test_arithmetic.py b/tests/duration/test_arithmetic.py index fad38b6..0f3283a 100644 --- a/tests/duration/test_arithmetic.py +++ b/tests/duration/test_arithmetic.py @@ -38,12 +38,24 @@ def test_divide(): assert isinstance(mul, pendulum.Duration) assert_duration(mul, 0, 0, 0, 1, 0, 0, 17, 761111) + it = pendulum.duration(days=2, seconds=35, microseconds=522222) + mul = it / 1.1 + + assert isinstance(mul, pendulum.Duration) + assert_duration(mul, 0, 0, 0, 1, 19, 38, 43, 202020) + it = pendulum.duration(years=2, months=4, days=2, seconds=35, microseconds=522222) mul = it / 2 assert isinstance(mul, pendulum.Duration) assert_duration(mul, 1, 2, 0, 1, 0, 0, 17, 761111) + it = pendulum.duration(years=2, months=4, days=2, seconds=35, microseconds=522222) + mul = it / 2.0 + + assert isinstance(mul, pendulum.Duration) + assert_duration(mul, 1, 2, 0, 1, 0, 0, 17, 761111) + def test_floor_divide(): it = pendulum.duration(days=2, seconds=34, microseconds=522222)	Error dividing duration by float <!-- Hi there! Thank you for discovering and submitting an issue. Before you submit this; let's make sure of a few things. Please make sure the following boxes are ticked if they are correct. If not, please try and fulfill these first. --> <!-- Checked checkbox should look like this: [x] --> - [x] I am on the [latest](https://github.com/sdispater/pendulum/releases/latest) Pendulum version. - [x] I have searched the [issues](https://github.com/sdispater/pendulum/issues) of this repo and believe that this is not a duplicate. <!-- Once those are done, if you're able to fill in the following list with your information, it'd be very helpful to whoever handles the issue. --> - OS version and name: Windows 10, version 20H2 - Pendulum version: 2.1.2 ## Issue <!-- Now feel free to write your issue, but please be descriptive! Thanks again 🙌 ❤️ --> In pendulum: ```python import pendulum d = pendulum.duration(hours=4, minutes=5) d / 1.1 ``` It gives the following error: ```python Traceback (most recent call last): File "<stdin>", line 1, in <module> File "C:\Python\lib\site-packages\pendulum\duration.py", line 396, in __truediv__ months=_divide_and_round(self._months, other), File "C:\Python\lib\site-packages\pendulum\duration.py", line 66, in __new__ raise ValueError("Float year and months are not supported") ValueError: Float year and months are not supported ``` Using datetime.timedelta: ```python from datetime import timedelta t = timedelta(seconds=43600+560) t / 1.1 # datetime.timedelta(seconds=13363, microseconds=636364) ``` It doesn't raise any error. Both objects represent the same amount of time: ```python from datetime import timedelta import pendulum d = pendulum.duration(hours=4, minutes=5) t = timedelta(seconds=43600+560) assert d.as_timedelta() == t ```	8012a7e8600c2348f1978eebb22fdd2535a8cca9	[ "tests/duration/test_arithmetic.py::test_divide" ]	[ "tests/duration/test_arithmetic.py::test_multiply", "tests/duration/test_arithmetic.py::test_floor_divide" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2021-12-21 19:41:50+00:00	mit	5,439
sdispater__pendulum-726	diff --git a/pendulum/interval.py b/pendulum/interval.py index 0c77305..2721494 100644 --- a/pendulum/interval.py +++ b/pendulum/interval.py @@ -448,3 +448,6 @@ class Interval(Duration): ) else: return self.as_duration() == other + + def __ne__(self, other: object) -> bool: + return not self.__eq__(other)	sdispater/pendulum	377dc2f808ac2bcf77ec5a4b87004b3a425aa0aa	diff --git a/tests/interval/test_behavior.py b/tests/interval/test_behavior.py index b5e057a..29636bd 100644 --- a/tests/interval/test_behavior.py +++ b/tests/interval/test_behavior.py @@ -52,3 +52,16 @@ def test_equality_to_timedelta(): period = dt2 - dt1 assert period == timedelta(days=2) + + +def test_inequality(): + dt1 = pendulum.datetime(2016, 11, 18) + dt2 = pendulum.datetime(2016, 11, 20) + dt3 = pendulum.datetime(2016, 11, 22) + + period1 = dt2 - dt1 + period2 = dt3 - dt2 + period3 = dt3 - dt1 + + assert period1 != period2 + assert period1 != period3	Period inequality does not work as expected - [x] I am on the [latest](https://github.com/sdispater/pendulum/releases/latest) Pendulum version. - [x] I have searched the [issues](https://github.com/sdispater/pendulum/issues) of this repo and believe that this is not a duplicate. - OS version and name: WSL2 on Win10, Ubuntu-20.04, Python 3.9.13 - Pendulum version: 2.1.2 ## Issue Only equality (`_eq` method) is defined for `Period`. However, when testing for inequality, the results are not consistent with $A \neq B \Leftrightarrow \neg (A = B)$. ```py >>> # Initialization >>> import pendulum >>> dt0 = pendulum.datetime(2000,1,1, 0) >>> dt1 = pendulum.datetime(2000,1,1, 1) >>> dt2 = pendulum.datetime(2000,1,1, 2) >>> p1 = dt1 - dt0 >>> p2 = dt2 - dt1 >>> p1 == p1, p2 == p2 (True, True) >>> # ^ This is expected and correct >>> p1 == p2, p2 == p1 (False, False) >>> # ^ This is also expected and correct >>> p1 != p2, p2 != p1 (False, False) >>> # ^ This is unexpected and incorrect, should be (True, True) ``` I believe the same issue applies to the new `Interval`.	377dc2f808ac2bcf77ec5a4b87004b3a425aa0aa	[ "tests/interval/test_behavior.py::test_inequality" ]	[ "tests/interval/test_behavior.py::test_pickle", "tests/interval/test_behavior.py::test_comparison_to_timedelta", "tests/interval/test_behavior.py::test_equality_to_timedelta" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2023-08-06 20:32:22+00:00	mit	5,440
sdispater__pendulum-99	diff --git a/pendulum/exceptions.py b/pendulum/exceptions.py index 2695c6d..b777018 100644 --- a/pendulum/exceptions.py +++ b/pendulum/exceptions.py @@ -1,5 +1,7 @@ # -- coding: utf-8 -- +from .parsing.exceptions import ParserError + class PendulumException(BaseException): diff --git a/pendulum/formatting/difference_formatter.py b/pendulum/formatting/difference_formatter.py index 771f756..e3457e3 100644 --- a/pendulum/formatting/difference_formatter.py +++ b/pendulum/formatting/difference_formatter.py @@ -63,9 +63,9 @@ class DifferenceFormatter(object): if diff.remaining_days > 3: count += 1 - elif diff.days > 0: + elif diff.remaining_days > 0: unit = 'day' - count = diff.days + count = diff.remaining_days elif diff.hours > 0: unit = 'hour' count = diff.hours diff --git a/pendulum/period.py b/pendulum/period.py index 2966c68..82b0abb 100644 --- a/pendulum/period.py +++ b/pendulum/period.py @@ -99,6 +99,14 @@ class Period(WordableIntervalMixin, BaseInterval): def remaining_days(self): return abs(self._delta['days']) % 7 * self._sign(self._days) + @property + def hours(self): + return self._delta['hours'] + + @property + def minutes(self): + return self._delta['minutes'] + @property def start(self): return self._start	sdispater/pendulum	c2a0a5987f3171cd5e9defd71afbe4ab77cfbe7b	diff --git a/tests/date_tests/test_diff.py b/tests/date_tests/test_diff.py index 1ba9a5a..a84b1f1 100644 --- a/tests/date_tests/test_diff.py +++ b/tests/date_tests/test_diff.py @@ -284,6 +284,17 @@ class DiffTest(AbstractTestCase): self.assertEqual('1 year', Date.today().diff_for_humans(Date.today().subtract(years=1), True)) self.assertEqual('1 year', Date.today().diff_for_humans(Date.today().add(years=1), True)) + def test_diff_accuracy(self): + # DST + today = Pendulum.create(2017, 3, 7, tz='America/Toronto') + + with self.wrap_with_test_now(today): + diff = today.add(days=6).diff(today, abs=True) + self.assertEqual(5, diff.days) + self.assertEqual(6, diff.remaining_days) + self.assertEqual(0, diff.hours) + self.assertEqual('6 days', diff.in_words()) + def test_diff_for_humans_accuracy(self): today = Pendulum.today() @@ -297,6 +308,11 @@ class DiffTest(AbstractTestCase): self.assertEqual('2 weeks', today.add(days=14).diff_for_humans(absolute=True)) self.assertEqual('2 weeks', today.add(days=13).diff_for_humans(absolute=True)) + # DST + today = Pendulum.create(2017, 3, 7, tz='America/Toronto') + with self.wrap_with_test_now(today): + self.assertEqual('6 days', today.add(days=6).diff_for_humans(absolute=True)) + def test_subtraction(self): d = Date(2016, 7, 5) future_dt = date(2016, 7, 6) diff --git a/tests/pendulum_tests/test_diff.py b/tests/pendulum_tests/test_diff.py index a633a32..c0f2e6d 100644 --- a/tests/pendulum_tests/test_diff.py +++ b/tests/pendulum_tests/test_diff.py @@ -573,6 +573,11 @@ class DiffTest(AbstractTestCase): self.assertEqual('1 year', now.add(years=1, months=3).diff_for_humans(absolute=True)) self.assertEqual('2 years', now.add(years=1, months=8).diff_for_humans(absolute=True)) + # DST + now = Pendulum.create(2017, 3, 7, tz='America/Toronto') + with self.wrap_with_test_now(now): + self.assertEqual('6 days', now.add(days=6).diff_for_humans(absolute=True)) + def test_seconds_since_midnight(self): d = Pendulum.create(2016, 7, 5, 12, 32, 25, 0) self.assertEqual(25 + 32 * 60 + 12 * 3600, d.seconds_since_midnight())	Expose ParserError exception to top level imports Currently if you want to catch the `ParserError` when calling `pendulum.parse('string')`, you have to catch it with: ``` try: pendulum.parse('string') except pendulum.parsing.exceptions.ParserError: pass ``` unless you've explicitly imported that part of the module in. There is already a `pendulum.exceptions`, so is there any reason why the `ParserError` couldn't be put into that same module or imported into the base init? I can make the PR for it, I just wanted to get clarity around whether this was by design or if it was something that wasn't a use case. I don't want to catch `ValueError`, mostly because that's not the exception being thrown.	c2a0a5987f3171cd5e9defd71afbe4ab77cfbe7b	[ "tests/date_tests/test_diff.py::DiffTest::test_diff_accuracy", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_accuracy", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_accuracy" ]	[ "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_days", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_months", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_weeks", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_years", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_day", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_days", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_day", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_days", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_months", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_weeks", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_years", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_months", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_weeks", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_years", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_day", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_days", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_day", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_days", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_months", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_weeks", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_years", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_months", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_month", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_week", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_weeks", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_year", "tests/date_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_years", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_days_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_days_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_days_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_days_vs_default_now", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_months_ensure_is_truncated", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_months_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_months_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_months_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_months_vs_default_now", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekdays_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekdays_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekdays_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weeks_ensure_is_truncated", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weeks_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weeks_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weeks_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_weeks_vs_default_now", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_years_ensure_is_truncated", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_years_negative_no_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_years_negative_with_sign", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_years_positive", "tests/date_tests/test_diff.py::DiffTest::test_diff_in_years_vs_default_now", "tests/date_tests/test_diff.py::DiffTest::test_subtraction", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_days", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_hours", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_minutes", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_months", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_seconds", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_weeks", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_absolute_years", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_days", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_days", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_hours", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_minutes", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_months", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_second", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_seconds", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_weeks", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_future_years", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_hours", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_minutes", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_months", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_future_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_nearly_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_second", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_second_with_timezone", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_seconds", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_weeks", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_now_and_years", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_days", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_days", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_hours", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_minutes", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_months", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_second", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_seconds", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_weeks", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_future_years", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_hours", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_minutes", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_months", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_future_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_hour", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_minute", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_month", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_nearly_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_second", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_seconds", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_week", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_weeks", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_year", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_for_humans_other_and_years", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_days_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_days_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_days_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_days_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_days_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_hours_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_hours_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_hours_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_hours_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_hours_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_positive_big", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_minutes_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_months_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_months_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_months_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_months_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_months_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_positive_big", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_seconds_with_timezones", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekdays_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekdays_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekdays_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weekend_days_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weeks_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weeks_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weeks_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weeks_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_weeks_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_years_ensure_is_truncated", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_years_negative_no_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_years_negative_with_sign", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_years_positive", "tests/pendulum_tests/test_diff.py::DiffTest::test_diff_in_years_vs_default_now", "tests/pendulum_tests/test_diff.py::DiffTest::test_seconds_since_midnight", "tests/pendulum_tests/test_diff.py::DiffTest::test_seconds_until_end_of_day", "tests/pendulum_tests/test_diff.py::DiffTest::test_subtraction" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2017-03-07 04:56:46+00:00	mit	5,441
sdss__clu-88	diff --git a/CHANGELOG.md b/CHANGELOG.md index a58e639..1535cef 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## Next version + +### ✨ Improved + +* [#77](https://github.com/sdss/clu/issues/77) Child commands will never emit ``:`` or ``f`` messages that may be confused as the parent being done. + + ## 1.1.2 - May 31, 2021 ### 🔧 Fixed diff --git a/python/clu/actor.py b/python/clu/actor.py index 8c80281..8a29502 100644 --- a/python/clu/actor.py +++ b/python/clu/actor.py @@ -424,7 +424,7 @@ class JSONActor(ClickParser, TCPBaseActor): async def multiline(command: Command, on: bool): """Set multiline mode for the transport.""" - transport: CustomTransportType = getattr(command, "transport", None) + transport = getattr(command, "transport", None) if not transport: return command.fail("The command has no transport.") diff --git a/python/clu/command.py b/python/clu/command.py index a10688b..686a1c1 100644 --- a/python/clu/command.py +++ b/python/clu/command.py @@ -265,6 +265,14 @@ class BaseCommand( command = self if not self.parent else self.parent + # If the parent has a command, do not output : or f since it would + # confuse the stream and potentially Tron. + if self.parent: + if message_code == ":": + message_code = "i" + elif message_code == "f": + message_code = "e" + self.actor.write( message_code, message=message,	sdss/clu	c61db5fce3dcf5b7700f78217ff9057f4e3697af	diff --git a/tests/test_command.py b/tests/test_command.py index a920549..6d37678 100644 --- a/tests/test_command.py +++ b/tests/test_command.py @@ -86,6 +86,30 @@ def test_child_command_write(command): ) +def test_child_command_finished(command): + + child = Command(command_string="new-command", parent=command) + + child.finish(text="Finished") + command.actor.write.assert_called_with( + "i", message={}, text="Finished", command=command, broadcast=False, {} + ) + + assert child.status.did_succeed + + +def test_child_command_failed(command): + + child = Command(command_string="new-command", parent=command) + + child.fail(error="Failed") + command.actor.write.assert_called_with( + "e", message={}, error="Failed", command=command, broadcast=False, {} + ) + + assert child.status.did_fail + + def test_write_str(command): command.write("i", "hello")	Avoid child commands to finish parent Child commands should not finish or fail the parent command, I think. Instead `finish` can probably be output as `info` and `fail` as `error`. Also, not set the command running again if it already is.	c61db5fce3dcf5b7700f78217ff9057f4e3697af	[ "tests/test_command.py::test_child_command_finished", "tests/test_command.py::test_child_command_failed" ]	[ "tests/test_command.py::test_command", "tests/test_command.py::test_set_status", "tests/test_command.py::test_set_done_command", "tests/test_command.py::test_set_status_fails", "tests/test_command.py::test_set_status_int", "tests/test_command.py::test_set_status_str", "tests/test_command.py::test_set_status_str_fails", "tests/test_command.py::test_child_command", "tests/test_command.py::test_child_command_write", "tests/test_command.py::test_write_str", "tests/test_command.py::test_write_dict", "tests/test_command.py::test_write_bad_message", "tests/test_command.py::test_write_no_actor", "tests/test_command.py::test_wait_for_status", "tests/test_command.py::test_status_callback" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2021-06-03 02:20:37+00:00	bsd-3-clause	5,442
sdss__sdss_access-17	diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 9632a9f..8636412 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -6,6 +6,13 @@ Change Log This document records the main changes to the sdss_access code. +1.0.1 (unreleased) +------------------ + +- Bug Fix :issue:`16` - HttpAccess used in public mode checks for netrc file +- Combines separate `set_auth` methods in `BaseAccess` and `HttpAccess` into a single `set_auth` available as `AuthMixin` +- `Auth.set_netrc` now raises an `AccessError` on failure to find a value netrc file. + 1.0.0 (2020-05-07) ------------------ diff --git a/python/sdss_access/sync/__init__.py b/python/sdss_access/sync/__init__.py index ddf2c1f..7519b10 100644 --- a/python/sdss_access/sync/__init__.py +++ b/python/sdss_access/sync/__init__.py @@ -1,4 +1,4 @@ -from .auth import Auth +from .auth import Auth, AuthMixin from .cli import Cli from .stream import Stream from .http import HttpAccess diff --git a/python/sdss_access/sync/auth.py b/python/sdss_access/sync/auth.py index deb281c..91dfbbe 100644 --- a/python/sdss_access/sync/auth.py +++ b/python/sdss_access/sync/auth.py @@ -1,15 +1,19 @@ from __future__ import absolute_import, division, print_function, unicode_literals from six.moves import input from sdss_access import is_posix +from sdss_access.path import AccessError from os.path import join from os import environ class Auth(object): + ''' class for setting up SAS authenticaton for SDSS users ''' def __init__(self, netloc=None, public=False, verbose=False): self.public = public self.verbose = verbose + self.username = None + self.password = None self.set_netloc(netloc=netloc) self.set_netrc() @@ -24,52 +28,109 @@ class Auth(object): Windows: recommending _netrc following https://stackoverflow.com/questions/6031214/git-how-to-use-netrc-file-on-windows-to-save-user-and-password """ + # set blank netrc + self.netrc = None + + # if public do nothing + if self.public: + return + + # try to get the netrc file try: from netrc import netrc except Exception as e: netrc = None if self.verbose: - print("SDSS_ACCESS> AUTH NETRC: %r" % e) + print("SDSS_ACCESS> AUTH NETRC: {0}".format(e)) + if netrc: - file = join(environ['HOME'], "_netrc") if not is_posix else None + netfile = join(environ['HOME'], "_netrc") if not is_posix else None try: - self.netrc = netrc(file) if not self.public else None - except Exception as e: - print("SDSS_ACCESS> Error %r" % e) - else: - self.netrc = None + self.netrc = netrc(netfile) + except FileNotFoundError as e: + raise AccessError("No netrc file found. Please create one. {0}".format(e)) def set_netloc(self, netloc=None): + ''' sets the url domain location ''' self.netloc = netloc - def set_username(self, username=None, inquire=False): + def set_username(self, username=None, inquire=None): + ''' sets the authentication username + + Parameters: + username: str + The username for SDSS SAS access + inquire: bool + If True, prompts for input of username. + ''' self.username = input("user [sdss]: ") or "sdss" if inquire else username - def set_password(self, password=None, inquire=False): + def set_password(self, password=None, inquire=None): + ''' sets the authentication password + + Parameters: + password: str + The password for SDSS SAS access + inquire: bool + If True, prompts for input of password. + ''' try: from getpass import getpass self.password = getpass("password: ") if inquire else password except Exception as e: if self.verbose: - print("SDSS_ACCESS> AUTH PASSWORD: %r" % e) + print("SDSS_ACCESS> AUTH PASSWORD: {0}".format(e)) self.password = None def ready(self): return self.username and self.password def load(self): + ''' Sets the username and password from the local netrc file ''' if self.netloc and self.netrc: authenticators = self.netrc.authenticators(self.netloc) if authenticators and len(authenticators) == 3: self.set_username(authenticators[0]) self.set_password(authenticators[2]) if self.verbose: - print("authentication for netloc=%r set for username=%r " % (self.netloc, self.username)) + print("authentication for netloc={0} set for username={1}".format(self.netloc, self.username)) else: if self.verbose: - print("cannot find %r in ~/.netrc" % self.netloc) + print("cannot find {0} in ~/.netrc".format(self.netloc)) self.set_username() self.set_password() else: self.set_username() self.set_password() + + +class AuthMixin(object): + ''' Mixin class to provide authentication method to other classes ''' + + def set_auth(self, username=None, password=None, inquire=True): + ''' Set the authentication + + Parameters: + username: str + The username for SDSS SAS access + password: str + The password for SDSS SAS access + inquire: bool + If True, prompts for input of username/password. + ''' + self.auth = Auth(public=self.public, netloc=self.netloc, verbose=self.verbose) + self.auth.set_username(username) + self.auth.set_password(password) + + # if public then exit + if self.public: + return + + # try to load the username and password + if not self.auth.ready(): + self.auth.load() + + # if still not ready then prompt for username and password + if not self.auth.ready(): + self.auth.set_username(inquire=inquire) + self.auth.set_password(inquire=inquire) diff --git a/python/sdss_access/sync/baseaccess.py b/python/sdss_access/sync/baseaccess.py index f6f2878..06a7553 100644 --- a/python/sdss_access/sync/baseaccess.py +++ b/python/sdss_access/sync/baseaccess.py @@ -5,12 +5,12 @@ import abc import six from os.path import join, sep from sdss_access import SDSSPath -from sdss_access.sync.auth import Auth +from sdss_access.sync.auth import Auth, AuthMixin from sdss_access.sync.stream import Stream from sdss_access import is_posix, AccessError -class BaseAccess(six.with_metaclass(abc.ABCMeta, SDSSPath)): +class BaseAccess(six.with_metaclass(abc.ABCMeta, AuthMixin, SDSSPath)): """Class for providing Rsync or Curl access to SDSS SAS Paths """ remote_scheme = None @@ -116,18 +116,6 @@ class BaseAccess(six.with_metaclass(abc.ABCMeta, SDSSPath)): stream = Stream(stream_count=self.stream_count, verbose=self.verbose) return stream - def set_auth(self, username=None, password=None, inquire=True): - ''' set the authentication for accessing data ''' - self.auth = Auth(public=self.public, netloc=self.netloc, verbose=self.verbose) - self.auth.set_username(username) - self.auth.set_password(password) - if not self.public: - if not self.auth.ready(): - self.auth.load() - if not self.auth.ready(): - self.auth.set_username(inquire=inquire) - self.auth.set_password(inquire=inquire) - def reset(self): ''' Reset all streams ''' diff --git a/python/sdss_access/sync/http.py b/python/sdss_access/sync/http.py index 5b3300a..3637607 100644 --- a/python/sdss_access/sync/http.py +++ b/python/sdss_access/sync/http.py @@ -12,26 +12,19 @@ except: from os import makedirs from os.path import isfile, exists, dirname from sdss_access import SDSSPath -from sdss_access.sync.auth import Auth +from sdss_access.sync.auth import Auth, AuthMixin -class HttpAccess(SDSSPath): +class HttpAccess(AuthMixin, SDSSPath): """Class for providing HTTP access via urllib.request (python3) or urllib2 (python2) to SDSS SAS Paths """ - def __init__(self, verbose=False, public=False, release=None, label='sdss_http'): + def __init__(self, verbose=None, public=None, release=None, label='sdss_http'): super(HttpAccess, self).__init__(public=public, release=release, verbose=verbose) self.verbose = verbose self.label = label self._remote = False - def set_auth(self, username=None, password=None): - self.auth = Auth(netloc=self.netloc, verbose=self.verbose) - self.auth.set_username(username) - self.auth.set_password(password) - if not self.auth.ready(): - self.auth.load() - def remote(self, remote_base=None, username=None, password=None): """ Configures remote access	sdss/sdss_access	f949ec106d25bc504f40753812d2c4c8e7fbf9ee	diff --git a/tests/conftest.py b/tests/conftest.py index 8d90a5e..a08ccca 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -232,3 +232,10 @@ def gzcompress(filename): shutil.copyfileobj(f_in, f_out) os.remove(filename) yield + + [email protected]() +def monkeyhome(monkeypatch, tmp_path): + ''' monkeypatch the HOME directory ''' + path = (tmp_path / 'tmp').mkdir() + monkeypatch.setenv("HOME", str(path)) diff --git a/tests/sync/test_auth.py b/tests/sync/test_auth.py index a4375d9..4a301fb 100644 --- a/tests/sync/test_auth.py +++ b/tests/sync/test_auth.py @@ -9,18 +9,103 @@ from __future__ import print_function, division, absolute_import +import importlib +import six.moves import pytest -from sdss_access.sync.auth import Auth +import sdss_access +from sdss_access.sync.auth import Auth, AuthMixin +from sdss_access.path import AccessError [email protected] -def test_set_username_interactively(): - """If authentication via `.netrc` file fails, then test for interactive prompt. +class TestAuth(object): - The interactive prompt raises an IOError (merged into OSError in Python 3.3), which this test - expects. - """ - with pytest.raises((IOError, OSError)): - auth = Auth(netloc='data.sdss.org', public=False) + def test_nonetrc_fails(self, monkeyhome): + ''' test raise error when no netrc present ''' + with pytest.raises(AccessError) as cm: + Auth() + assert 'No netrc file found. Please create one.' in str(cm.value) + + def test_nonetrc_public_pass(self, monkeyhome): + ''' test public access does not fail when no netrc ''' + auth = Auth(public=True) + assert auth.public is True + assert auth.ready() is None + assert auth.netrc is None + + @pytest.mark.parametrize('netloc', [('data.sdss.org'), ('dtn01.sdss.org')]) + def test_setnetloc(self, netloc): + ''' test setting a url domain location ''' + auth = Auth(public=True, netloc=netloc) + assert auth.netloc == netloc + + def test_auth_goodnetrc(self): + ''' test for a netrc loaded ''' + auth = Auth() + assert auth.netrc is not None + assert 'data.sdss.org' in auth.netrc.hosts.keys() + + @pytest.mark.parametrize('public', [(True), (False)]) + def test_auth_defaultuser(self, public): + ''' test auth load default user ''' + auth = Auth(netloc='data.sdss.org', public=public) + auth.load() + if public: + assert auth.username is None + else: + assert auth.username == auth.netrc.authenticators('data.sdss.org')[0] + + def test_auth_setuserpass(self): + ''' test set userpass ''' + auth = Auth(netloc='data.sdss.org') + assert auth.username is None + assert auth.password is None + auth.set_username('testuser') + auth.set_password('testpass') + assert auth.username == 'testuser' + assert auth.password == 'testpass' + + @pytest.mark.parametrize('prompt, exp', [('blah', 'blah'), (None, 'sdss')]) + def test_user_inquire(self, monkeypatch, prompt, exp): + ''' test username input prompt ''' + # mock the six.moves.input + def mockinput(value): + return prompt + + monkeypatch.setattr(six.moves, 'input', mockinput) + # reload the auth module + importlib.reload(sdss_access.sync.auth) + from sdss_access.sync.auth import Auth + + # run the test + auth = Auth() auth.set_username(inquire=True) + assert auth.username == exp + + +class TmpAccess(AuthMixin, object): + def __init__(self, public=None, netloc=None, verbose=None): + self.public = public + self.netloc = netloc + self.verbose = verbose + + +class TestAuthMixin(object): + + def test_set_auth(self): + ''' test the set_auth method ''' + ta = TmpAccess(netloc='data.sdss.org') + ta.set_auth() + assert ta.netloc == 'data.sdss.org' + assert ta.auth is not None + assert ta.auth.netloc == 'data.sdss.org' + assert ta.auth.username == 'sdss' + + def test_set_auth_public(self): + ''' test the public option ''' + ta = TmpAccess(netloc='data.sdss.org', public=True) + ta.set_auth() + assert ta.auth is not None + assert ta.auth.public is True + assert ta.auth.username is None + diff --git a/tests/sync/test_http.py b/tests/sync/test_http.py index 6e2798f..7818048 100644 --- a/tests/sync/test_http.py +++ b/tests/sync/test_http.py @@ -14,7 +14,7 @@ from __future__ import print_function, division, absolute_import import os import pytest -from sdss_access import tree +from sdss_access import tree, AccessError from sdss_access.sync import HttpAccess @@ -57,3 +57,18 @@ class TestHttp(object): mangaid='1-42007', remote=True) assert os.path.exists(full) + + def test_nonetrc_fails(self, monkeyhome): + ''' test raise error when no netrc present ''' + with pytest.raises(AccessError) as cm: + http = HttpAccess() + http.remote() + assert 'No netrc file found. Please create one.' in str(cm.value) + + def test_nonetrc_public_pass(self, monkeyhome): + ''' test public access does not fail when no netrc ''' + http = HttpAccess(release='DR14') + http.remote() + assert http.public is True + assert http.auth.username is None + assert http.auth.ready() is None	HttpAccess cannot download public file, but RsyncAccess can Description I can access public data products using `sdss_access.RsyncAccess`, but the same products cannot be downloaded using `sdss_access.HttpAccess`. Expected behaviour I don't think any authorization should be required (or even checked) for accessing public data products. Steps to recreate ````python from sdss_access import RsyncAccess, HttpAccess kwds = dict( public=True, release="DR16", verbose=True ) apstar_kwds = dict( apred="r12", apstar="stars", telescope="apo25m", field="000+14", prefix="ap", obj="2M16544175-2148453", ) # Works: rsync = RsyncAccess(kwds) rsync.remote() rsync.add("apStar", apstar_kwds) rsync.set_stream() rsync.commit() # Fails: http = HttpAccess(kwds) http.remote() http.get("apStar", apstar_kwds) ```` The stack trace reads: ````python --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-4-1abe27f23dc9> in <module> 21 # Fails: 22 http = HttpAccess(kwds) ---> 23 http.remote() 24 http.get("apStar", apstar_kwds) ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/http.py in remote(self, remote_base, username, password) 49 self.remote_base = remote_base 50 self._remote = True ---> 51 self.set_auth(username=username, password=password) 52 if self.auth.ready(): 53 passman = HTTPPasswordMgrWithDefaultRealm() ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/http.py in set_auth(self, username, password) 31 self.auth.set_password(password) 32 if not self.auth.ready(): ---> 33 self.auth.load() 34 35 def remote(self, remote_base=None, username=None, password=None): ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/auth.py in load(self) 59 60 def load(self): ---> 61 if self.netloc and self.netrc: 62 authenticators = self.netrc.authenticators(self.netloc) 63 if authenticators and len(authenticators) == 3: AttributeError: 'Auth' object has no attribute 'netrc' ```` Additional context The [documentation for `sdss_access.sync.auth.Auth.set_netrc`](https://sdss-access.readthedocs.io/en/latest/api.html?highlight=netrc#sdss_access.sync.auth.Auth.set_netrc) says to add a line to my `~/.netrc` file. I did that (using the correct password) and then a new exception occurs due to permissions. Admittedly the documentation for `set_netrc` does tell me to set the permissions correctly, but I would expect no authorization is required -- at all -- for public data. ````python SDSS_ACCESS> Error NetrcParseError('~/.netrc access too permissive: access permissions must restrict access to only the owner') --------------------------------------------------------------------------- AttributeError Traceback (most recent call last) ~/anaconda3/envs/astra/lib/python3.7/io.py in <module> 21 # Fails: 22 http = HttpAccess(kwds) ---> 23 http.remote() 24 http.get("apStar", apstar_kwds) ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/http.py in remote(self, remote_base, username, password) 49 self.remote_base = remote_base 50 self._remote = True ---> 51 self.set_auth(username=username, password=password) 52 if self.auth.ready(): 53 passman = HTTPPasswordMgrWithDefaultRealm() ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/http.py in set_auth(self, username, password) 31 self.auth.set_password(password) 32 if not self.auth.ready(): ---> 33 self.auth.load() 34 35 def remote(self, remote_base=None, username=None, password=None): ~/anaconda3/envs/astra/lib/python3.7/site-packages/sdss_access/sync/auth.py in load(self) 59 60 def load(self): ---> 61 if self.netloc and self.netrc: 62 authenticators = self.netrc.authenticators(self.netloc) 63 if authenticators and len(authenticators) == 3: AttributeError: 'Auth' object has no attribute 'netrc' ```` I am using the the [bleeding edge](https://github.com/sdss/sdss_access/commit/f949ec106d25bc504f40753812d2c4c8e7fbf9ee) version of `sdss_access`.	f949ec106d25bc504f40753812d2c4c8e7fbf9ee	[ "tests/sync/test_auth.py::TestAuth::test_nonetrc_fails", "tests/sync/test_auth.py::TestAuth::test_nonetrc_public_pass", "tests/sync/test_auth.py::TestAuth::test_setnetloc[data.sdss.org]", "tests/sync/test_auth.py::TestAuth::test_setnetloc[dtn01.sdss.org]", "tests/sync/test_auth.py::TestAuth::test_auth_defaultuser[True]", "tests/sync/test_auth.py::TestAuthMixin::test_set_auth_public", "tests/sync/test_http.py::TestHttp::test_http[datapath0-DR15]", "tests/sync/test_http.py::TestHttp::test_svn_exist", "tests/sync/test_http.py::TestHttp::test_svn_get", "tests/sync/test_http.py::TestHttp::test_nonetrc_fails", "tests/sync/test_http.py::TestHttp::test_nonetrc_public_pass" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-05-28 14:51:27+00:00	bsd-3-clause	5,443
sdss__sdss_access-20	diff --git a/python/sdss_access/path/path.py b/python/sdss_access/path/path.py index 542c9ec..b94538e 100644 --- a/python/sdss_access/path/path.py +++ b/python/sdss_access/path/path.py @@ -63,7 +63,7 @@ class BasePath(object): "mirror": "data.mirror.sdss.org", 'svn': 'svn.sdss.org'} def __init__(self, release=None, public=False, mirror=False, verbose=False, force_modules=None): - self.release = release or 'sdsswork' + self.release = release or os.getenv('TREE_VER', 'sdsswork') self.public = 'dr' in self.release.lower() or public self.mirror = mirror self.verbose = verbose @@ -685,7 +685,8 @@ class BasePath(object): for c in alternates if re.search(self._comp_regex, c)])) if suffixes: assert len(suffixes) == 1, 'should only be one suffix per file template ' - template = template + suffixes[0] + if not template.endswith(suffixes[0]): + template = template + suffixes[0] return template	sdss/sdss_access	a4894ffad2c56940605aecc7f89639d8810488b3	diff --git a/tests/conftest.py b/tests/conftest.py index a08ccca..30fd0f6 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -9,6 +9,7 @@ # @Last Modified time: 2019-08-07 12:30:00 from __future__ import print_function, division, absolute_import +import glob import gzip import os import pytest @@ -134,6 +135,7 @@ def radd(rsync, expdata): ''' fixture to add a path to an rsync object ''' rsync.add(expdata['name'], *expdata['params']) yield rsync + rsync.reset() @pytest.fixture(scope='session') @@ -141,6 +143,7 @@ def rstream(radd): ''' fixture to set the stream for an parametrized rsync object ''' radd.set_stream() yield radd + radd.reset() @pytest.fixture(scope='session') @@ -195,7 +198,6 @@ def monkeysas(tmpdir, monkeypatch, path): path.replant_tree() - @pytest.fixture() def copydata(tmpdir, request): ''' fixture to copy a file into a temporary directory ''' @@ -210,6 +212,21 @@ def copydata(tmpdir, request): yield destpath [email protected]() +def copymulti(tmpdir, request): + ''' Fixture to copy multiple files into a temporary directory ''' + srcpath = os.path.join(os.getenv("SAS_BASE_DIR"), request.param) + files = glob.glob(srcpath) + if not files: + pytest.skip('Files do not exist, cannot copy') + for item in files: + loc = item.split(os.getenv("SAS_BASE_DIR") + '/')[-1] + sasdir = tmpdir / 'sas' + destpath = sasdir / loc + os.makedirs(os.path.dirname(destpath), exist_ok=True) + shutil.copy(item, destpath) + + @contextlib.contextmanager def gzuncompress(filename): ''' Context manager than gunzips a file temporarily. ''' diff --git a/tests/data/paths.yaml b/tests/data/paths.yaml index bfda7d5..dcd9e95 100644 --- a/tests/data/paths.yaml +++ b/tests/data/paths.yaml @@ -8,4 +8,7 @@ paths: work: mangawork params: {drpver: v2_4_3, plate: 8485, ifu: 1901, wave: LOG} location: manga/spectro/redux/v2_4_3/8485/stack/manga-8485-1901-LOGCUBE.fits.gz - + - name: spec-lite + work: ebosswork + params: {run2d: v5_10_0, plateid: 3606, mjd: 55182, fiberid: 537} + location: eboss/spectro/redux/v5_10_0/spectra/lite/3606/spec-3606-55182-0537.fits diff --git a/tests/path/test_path.py b/tests/path/test_path.py index 91036d2..2852b53 100644 --- a/tests/path/test_path.py +++ b/tests/path/test_path.py @@ -152,9 +152,11 @@ class TestPath(object): def test_uncompress(self, copydata, monkeysas, path): ''' test to find unzipped files with zipped path templates ''' assert path.templates['mangacube'].endswith('.gz') + assert path.templates['mangacube'].count('.gz') == 1 with gzuncompress(copydata) as f: full = path.full('mangacube', drpver='v2_4_3', plate=8485, ifu=1901, wave='LOG') assert not full.endswith('.gz') + assert full.count('.gz') == 0 assert full.endswith('.fits') @pytest.mark.parametrize('copydata', @@ -163,16 +165,31 @@ class TestPath(object): def test_compress(self, copydata, monkeysas, path): ''' test to find zipped files with non-zipped path templates ''' assert not path.templates['mangaimage'].endswith('.gz') + assert path.templates['mangaimage'].count('.gz') == 0 with gzcompress(copydata) as f: full = path.full('mangaimage', drpver='v2_5_3', plate=8485, ifu=1901) assert not full.endswith('.png') assert full.endswith('.gz') + assert full.count('.gz') == 1 def test_uncompress_nofileexists(self, monkeysas, path): ''' test if no file exists, full returns original template path ''' assert path.templates['mangacube'].endswith('.gz') - full = path.full('mangacube', drpver='v2_4_3', plate=8485, ifu=1901, wave='LOG') + full = path.full('mangacube', drpver='v2_4_3', plate=8888, ifu=12345, wave='LOG') assert full.endswith('.gz') + assert full.count('.gz') == 1 + + @pytest.mark.parametrize('copymulti', + [('mangawork/manga/spectro/redux/v2_4_3/8485/stack/manga-8485--LOGCUBE.fits.gz')], + indirect=True, ids=['data']) + @pytest.mark.parametrize('plate, ifu', [(8888, ''), (8888, 12345), + (8485, 1901), (8485, '')], + ids=['nodata-wild', 'nodata', 'glob', 'glob-wild']) + def test_compression_wildcards(self, copymulti, monkeysas, path, plate, ifu): + assert path.templates['mangacube'].endswith('.gz') + full = path.full('mangacube', drpver='v2_4_3', plate=plate, ifu=ifu, wave='LOG') + assert full.endswith('.gz') + assert full.count('.gz') == 1 @pytest.mark.parametrize('mirror', [(True), (False)]) def test_netloc(self, mirror): @@ -247,6 +264,24 @@ class TestPath(object): ff = path.full('mangapreimg', designid=8405, designgrp='D0084XX', mangaid='1-42007', force_module=True) assert 'mangapreim/trunk/data' in ff + @pytest.mark.parametrize('tree_ver', [('sdsswork'), ('dr15'), ('sdss5'), ('mpl8')]) + def test_release_from_module(self, monkeypatch, tree_ver): + monkeypatch.setenv('TREE_VER', tree_ver) + path = Path() + assert path.release == tree_ver + + def test_sdss5_paths(self, monkeypatch): + path = Path(release='sdss5') + assert 'rsFields' in path.templates + f1 = path.full('rsFields', plan='001', observatory='APO') + + monkeypatch.setenv('TREE_VER', 'sdss5') + path = Path() + assert 'rsFields' in path.templates + f2 = path.full('rsFields', plan='001', observatory='APO') + + assert f1 == f2 + @pytest.fixture() def monkeyoos(monkeypatch): diff --git a/tests/sync/test_http.py b/tests/sync/test_http.py index 7818048..bf267ef 100644 --- a/tests/sync/test_http.py +++ b/tests/sync/test_http.py @@ -72,3 +72,13 @@ class TestHttp(object): assert http.public is True assert http.auth.username is None assert http.auth.ready() is None + + @pytest.mark.parametrize('tree_ver, exp', [('sdsswork', 'work'), ('dr15', 'dr15'), + ('dr13', 'dr13'), ('mpl8', 'work')]) + def test_release_from_module(self, monkeypatch, tree_ver, exp, datapath): + monkeypatch.setenv('TREE_VER', tree_ver) + http = HttpAccess() + full = http.full(datapath['name'], datapath['params']) + assert http.release == tree_ver + assert exp in full + diff --git a/tests/sync/test_rsync.py b/tests/sync/test_rsync.py index eda53d9..d41afd4 100644 --- a/tests/sync/test_rsync.py +++ b/tests/sync/test_rsync.py @@ -12,6 +12,7 @@ from __future__ import print_function, division, absolute_import import os import pytest from sdss_access import Access, AccessError +from sdss_access.sync import RsyncAccess class TestRsync(object): @@ -44,6 +45,17 @@ class TestRsync(object): assert os.path.exists(path) is True assert os.path.isfile(path) is True + @pytest.mark.parametrize('tree_ver, exp', [('sdsswork', 'work'), ('dr15', 'dr15'), + ('dr13', 'dr13'), ('mpl8', 'work')]) + def test_release_from_module(self, monkeypatch, tree_ver, exp, datapath): + monkeypatch.setenv('TREE_VER', tree_ver) + rsync = RsyncAccess() + rsync.remote() + rsync.add(datapath['name'], datapath['params']) + loc = rsync.initial_stream.task[0]['location'] + assert rsync.release == tree_ver + assert exp in loc + class TestRsyncFails(object):	make sdss_access work with loaded module files enable `sdss_access` to use non-sdsswork modules. When a user performs `module load tree/dr15` and runs `Path()` without a release, `sdss_access` should recognize that it's a DR15 release from the loaded module file.	a4894ffad2c56940605aecc7f89639d8810488b3	[ "tests/path/test_path.py::TestPath::test_release_from_module[dr15]", "tests/path/test_path.py::TestPath::test_release_from_module[sdss5]", "tests/path/test_path.py::TestPath::test_release_from_module[mpl8]", "tests/sync/test_http.py::TestHttp::test_release_from_module[datapath1-dr15-dr15]", "tests/sync/test_http.py::TestHttp::test_release_from_module[datapath1-dr13-dr13]", "tests/sync/test_rsync.py::TestRsync::test_release_from_module[datapath1-dr15-dr15]", "tests/sync/test_rsync.py::TestRsync::test_release_from_module[datapath1-dr13-dr13]", "tests/sync/test_http.py::TestHttp::test_release_from_module[datapath0-dr15-dr15]", "tests/sync/test_http.py::TestHttp::test_release_from_module[datapath0-dr13-dr13]", "tests/sync/test_rsync.py::TestRsync::test_release_from_module[datapath0-dr15-dr15]", "tests/sync/test_rsync.py::TestRsync::test_release_from_module[datapath0-dr13-dr13]" ]	[ "tests/path/test_path.py::TestPath::test_extract_source", "tests/path/test_path.py::TestPath::test_netloc[True]", "tests/path/test_path.py::TestPath::test_netloc[False]", "tests/path/test_path.py::TestPath::test_svn_urls[True]", "tests/path/test_path.py::TestPath::test_svn_url_tag", "tests/path/test_path.py::TestPath::test_release_from_module[sdsswork]", "tests/path/test_path.py::TestPath::test_sdss5_paths", "tests/sync/test_http.py::TestHttp::test_http[datapath0-DR15]", "tests/sync/test_rsync.py::TestRsync::test_rsync[DR15-datapath0]", "tests/sync/test_rsync.py::TestStream::test_initial_stream[DR15-datapath0]", "tests/sync/test_rsync.py::TestRsync::test_rsync[DR15-datapath1]", "tests/sync/test_http.py::TestHttp::test_svn_exist", "tests/sync/test_http.py::TestHttp::test_svn_get", "tests/sync/test_http.py::TestHttp::test_nonetrc_fails", "tests/sync/test_http.py::TestHttp::test_nonetrc_public_pass" ]	{ "failed_lite_validators": [ "has_short_problem_statement" ], "has_test_patch": true, "is_lite": false }	2020-05-29 20:02:00+00:00	bsd-3-clause	5,444
sdss__sdsstools-14	diff --git a/CHANGELOG.md b/CHANGELOG.md index 03b5541..63e6960 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ## [Next version](https://github.com/sdss/sdsstools/compare/0.2.1...HEAD) +- Feature [#7](https://github.com/sdss/sdsstools/issues/7): add support for a tag `!extends` in YAML files when read with `read_yaml_file`. - Bug [#8](https://github.com/sdss/sdsstools/issues/8): log `StreamHandler` to `stderr` when the record level is `ERROR` or greater. - Support [#11](https://github.com/sdss/sdsstools/issues/11): replaced `colored_formatter` with a propper `Formatter` and added tests for logging. - Support [#12](https://github.com/sdss/sdsstools/issues/12): move `color_print` to `sdsstools._vendor`. diff --git a/README.md b/README.md index 1f7e05f..9647d13 100644 --- a/README.md +++ b/README.md @@ -70,6 +70,36 @@ In addition to the (recommended) location `~/.config/sdss/<NAME>.yaml`, `get_con `sdsstools.configuration` includes two other tools, `merge_config`, that allows to merge dictionaries recursively, and `read_yaml_file`, to read a YAML file. +### Extending a YAML file + +`read_yaml_file` provides a non-standard feature that allows you to extend one YAML file with another. To achieve this you need to add the tag `!extends <base-file>` at the top of the file that you want to extend. For example, if you have a file `base.yaml` + +```yaml +cat1: + key1: value2 + +cat2: + key2: 1 +``` + +that you want to use as a template for `extendable.yaml` + +```yaml +#!extends base.yaml + +cat1: + key1: value1 +``` + +you can use `read_yaml_file` to parse the result + +```python +>>> read_yaml_file('extendable.yaml') +{'cat1': {'key1': 'value2'}, 'cat2': {'key2': 1}} +``` + +The path to the base file must be absolute, or relative to the location of the file to be extended. + ## Metadata sdsscore provides tools to locate and parse metadata files (`pyproject.toml`, `setup.cfg`, `setup.py`). `get_metadata_files` locates the path of the metadata file relative to a given `path`. `get_package_version` tries to find the version of the package by looking for a version string in the metadata file or in the egg/wheel metadata file, if the package has been installed. To use it diff --git a/src/sdsstools/configuration.py b/src/sdsstools/configuration.py index cd8fd40..3782a94 100644 --- a/src/sdsstools/configuration.py +++ b/src/sdsstools/configuration.py @@ -43,15 +43,34 @@ yaml.add_implicit_resolver('!env', env_matcher) yaml.add_constructor('!env', env_constructor) -def read_yaml_file(path): +def read_yaml_file(path, use_extends=True, loader=yaml.FullLoader): """Read a YAML file and returns a dictionary.""" if isinstance(path, (str, pathlib.Path)): - with open(path, 'r') as fp: - config = yaml.load(fp, Loader=yaml.FullLoader) + fp = open(path, 'r') else: - # Assume it's an stream - config = yaml.load(path, Loader=yaml.FullLoader) + fp = path + + fp.seek(0) + config = yaml.load(fp, Loader=loader) + + if use_extends: + fp.seek(0) + while True: + line = fp.readline() + if line.strip().startswith('#!extends'): + base_file = line.strip().split()[1] + if not os.path.isabs(base_file) and hasattr(fp, 'buffer'): + base_file = os.path.join(os.path.dirname(path), base_file) + if not os.path.exists(base_file): + raise FileExistsError(f'cannot find !extends file {base_file}.') + return merge_config(read_yaml_file(base_file), + read_yaml_file(path, use_extends=False)) + elif line.strip().startswith('#') or line.strip() == '': + continue + else: + fp.seek(0) + break return config	sdss/sdsstools	c75fa6dd59ccd5c4bd58fd7c2a82765389d31eab	diff --git a/test/test_configuration.py b/test/test_configuration.py index 31a0788..d84ab84 100644 --- a/test/test_configuration.py +++ b/test/test_configuration.py @@ -7,18 +7,38 @@ # @License: BSD 3-clause (http://www.opensource.org/licenses/BSD-3-Clause) import inspect +import io import os import unittest.mock import pytest from sdsstools import Configuration, get_config -from sdsstools.configuration import DEFAULT_PATHS +from sdsstools.configuration import DEFAULT_PATHS, read_yaml_file BASE_CONFIG_FILE = os.path.join(os.path.dirname(__file__), 'etc/test.yml') +BASE = """ +cat1: + key1: base_value + +cat2: + key2: 1 +""" + +EXTENDABLE = """ +# + +#!extends {base_path} + +cat1: + # test + key1: value1 +""" + + @pytest.fixture(autouse=True) def cleanup(): @@ -64,6 +84,15 @@ def set_envvar(): del os.environ['A_TEST_VARIABLE'] [email protected] +def extendable(tmp_path): + + base_path = tmp_path / 'base.yaml' + base_path.write_text(BASE) + + yield io.StringIO(EXTENDABLE.format(base_path=str(base_path))), base_path + + def test_configuration(config_file): config = Configuration() @@ -155,3 +184,47 @@ def test_get_config_bad_module(mock_func): config = get_config('test') assert config == {} + + +def test_extends(extendable): + + stream, __ = extendable + data = read_yaml_file(stream) + + assert data['cat1']['key1'] == 'base_value' + assert 'cat2' in data + + +def test_extends_file_not_found(extendable): + + stream, base_path = extendable + base_path.unlink() + + with pytest.raises(FileExistsError): + read_yaml_file(stream) + + +def test_dont_extend(extendable): + + stream, __ = extendable + data = read_yaml_file(stream, use_extends=False) + + assert data['cat1']['key1'] == 'value1' + assert 'cat2' not in data + + +def test_extends_from_file(tmp_path): + + base_path = tmp_path / 'subdir' / 'base.yaml' + (tmp_path / 'subdir').mkdir() + base_path.touch() + base_path.write_text(BASE) + + extendable_path = tmp_path / 'extendable.yaml' + extendable_relative = EXTENDABLE.format(base_path='subdir/base.yaml') + extendable_path.write_text(extendable_relative) + + data = read_yaml_file(extendable_path) + + assert data['cat1']['key1'] == 'base_value' + assert 'cat2' in data	Add !extends constructor Add a PyYAML constructor to base a YAML file on another. For example ```yaml # file: a.yml a: 1 b: c: 3 d: 4 ``` ```yaml # file: b.yaml !extends a.yml b: c: 42 ``` would be parsed into `{a: 1, b: {c: 42, d: 4}}`. This would be useful for example for APO/LCO configuration files in which on can be made the template and the other can just extend and modify it.	c75fa6dd59ccd5c4bd58fd7c2a82765389d31eab	[ "test/test_configuration.py::test_extends", "test/test_configuration.py::test_extends_file_not_found", "test/test_configuration.py::test_dont_extend", "test/test_configuration.py::test_extends_from_file" ]	[ "test/test_configuration.py::test_configuration", "test/test_configuration.py::test_configuration_user", "test/test_configuration.py::test_configuration_envvar", "test/test_configuration.py::test_configuration_envvar_defaults", "test/test_configuration.py::test_configurations_bad_value", "test/test_configuration.py::test_get_config_etc", "test/test_configuration.py::test_get_config_etc_with_user", "test/test_configuration.py::test_get_config_etc_with_user_str", "test/test_configuration.py::test_get_config_default_path", "test/test_configuration.py::test_get_config_envvar_path", "test/test_configuration.py::test_get_config_no_update", "test/test_configuration.py::test_get_config_bad_module" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2020-08-02 01:27:27+00:00	bsd-3-clause	5,445
sdss__sdsstools-27	diff --git a/CHANGELOG.md b/CHANGELOG.md index 8fb9b18..86a6720 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## [0.4.8](https://github.com/sdss/sdsstools/compare/0.4.7...HEAD) + +- Feature [#26]: allow rollover of file logger on `start_file_logger`. + + ## [0.4.7](https://github.com/sdss/sdsstools/compare/0.4.6...0.4.7) - 2021-02-12 - Bug [#24]: update dependencies so that `importlib_metadata` is installed for Python<=3.7 (it was Python<3.7). diff --git a/src/sdsstools/logger.py b/src/sdsstools/logger.py index 5808389..0867a42 100644 --- a/src/sdsstools/logger.py +++ b/src/sdsstools/logger.py @@ -7,6 +7,7 @@ # @License: BSD 3-clause (http://www.opensource.org/licenses/BSD-3-Clause) import copy +import datetime import logging import os import re @@ -199,22 +200,29 @@ class SDSSLogger(logging.Logger): shutil.copyfile(self.log_filename, os.path.expanduser(path)) def start_file_logger(self, path, log_level=logging.DEBUG, - mode='a', rotating=True): + mode='a', rotating=True, rollover=False): """Start file logging.""" log_file_path = os.path.expanduser(path) logdir = os.path.dirname(log_file_path) + SUFFIX = '%Y-%m-%d_%H:%M:%S' + try: if not os.path.exists(logdir): os.makedirs(logdir) + if os.path.exists(log_file_path) and rotating and rollover: + now = datetime.datetime.utcnow() + dst = str(log_file_path) + '.' + now.strftime(SUFFIX) + shutil.move(str(log_file_path), dst) + if rotating: self.fh = TimedRotatingFileHandler(str(log_file_path), when='midnight', utc=True) - self.fh.suffix = '%Y-%m-%d_%H:%M:%S' + self.fh.suffix = SUFFIX else: self.fh = logging.FileHandler(str(log_file_path), mode=mode)	sdss/sdsstools	2845932bef2f593507269e47164c1d1f45c27c3b	diff --git a/test/test_logger.py b/test/test_logger.py index eca0dc6..ffa16ab 100644 --- a/test/test_logger.py +++ b/test/test_logger.py @@ -170,3 +170,18 @@ async def test_asyncio_exception_handler(logger, caplog, event_loop): assert caplog.record_tuples[0][1] == logging.ERROR assert 'An error in a task.' in caplog.record_tuples[0][2] + + +def test_logger_rotating_rollover(tmp_path): + + log_file = tmp_path / 'logs' / 'test_log.log' + + logger1 = get_logger(str(uuid.uuid4())) + logger1.start_file_logger(log_file) + + assert len(list((tmp_path / 'logs').glob(''))) == 1 + + logger2 = get_logger(str(uuid.uuid4())) + logger2.start_file_logger(log_file, rollover=True) + + assert len(list((tmp_path / 'logs').glob(''))) == 2	Allow rotate log when starting file logger When the file logger starts, if `rotating=True`, the new log is appended. In some cases one may want the new log to start a new file and the previous log to be rolled over. <!-- Edit the body of your new issue then click the ✓ "Create Issue" button in the top right of the editor. The first line will be the issue title. Assignees and Labels follow after a blank line. Leave an empty line before beginning the body of the issue. -->	2845932bef2f593507269e47164c1d1f45c27c3b	[ "test/test_logger.py::test_logger_rotating_rollover" ]	[ "test/test_logger.py::test_logger", "test/test_logger.py::test_set_level", "test/test_logger.py::test_warning_raised", "test/test_logger.py::test_warning", "test/test_logger.py::test_exception_formatting", "test/test_logger.py::test_catch_exception", "test/test_logger.py::test_save_log", "test/test_logger.py::test_get_logger_twice", "test/test_logger.py::test_bad_fh_path", "test/test_logger.py::test_fh_no_rotating", "test/test_logger.py::test_log_non_standard_level", "test/test_logger.py::test_asyncio_exception_handler" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2021-02-13 08:48:12+00:00	bsd-3-clause	5,446
sdss__tree-51	diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 5f964f9..add00c6 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -6,6 +6,11 @@ Change Log This document records the main changes to the tree code. +3.1.5 (unreleased) +------------------ +- Added new config for IPL-2 +- Make ``sdsstool`` and ``sdss_access`` module dependencies optional in ``setup_tree`` + 3.1.4 (2022-11-29) ------------------ - Adding new config for IPL-1 diff --git a/bin/setup_tree.py b/bin/setup_tree.py index c4d8bc5..aae7152 100755 --- a/bin/setup_tree.py +++ b/bin/setup_tree.py @@ -225,7 +225,7 @@ def check_sas_base_dir(root=None): os.environ['SAS_BASE_DIR'] = sasbasedir -def write_header(term='bash', tree_dir=None, name=None): +def write_header(term='bash', tree_dir=None, name=None, add_mod_deps=False): ''' Write proper file header in a given shell format Parameters: @@ -246,6 +246,15 @@ def write_header(term='bash', tree_dir=None, name=None): base = 'export' if term == 'bash' else 'setenv' sep = '=' if term == 'bash' else ' ' + # add the optional depdendecies + deps = """ +module load sdsstools +prereq sdsstools +module load sdss_access +prereq sdss_access + """ if add_mod_deps else "" + + if term != 'modules': hdr = """# Set up tree/{0} for {1} {2} TREE_DIR{4}{3} @@ -264,10 +273,7 @@ set product tree set version {1} conflict $product -module load sdsstools -prereq sdsstools -module load sdss_access -prereq sdss_access +{2} module-whatis "Sets up $product/$version in your environment" @@ -277,7 +283,7 @@ setenv [string toupper $product]_VER $version prepend-path PATH $PRODUCT_DIR/bin prepend-path PYTHONPATH $PRODUCT_DIR/python - """.format(product_dir, name) + """.format(product_dir, name, deps) return hdr.strip() @@ -288,7 +294,8 @@ def write_version(name): return modules_version -def write_file(environ, term='bash', out_dir=None, tree_dir=None, default=None): +def write_file(environ, term='bash', out_dir=None, tree_dir=None, + default=None, add_mod_deps=None): ''' Write a tree environment file Loops over the tree environ and writes them out to a bash, tsch, or @@ -310,7 +317,7 @@ def write_file(environ, term='bash', out_dir=None, tree_dir=None, default=None): # get the proper name, header and file extension name = environ['default']['name'] - header = write_header(term=term, name=name, tree_dir=tree_dir) + header = write_header(term=term, name=name, tree_dir=tree_dir, add_mod_deps=add_mod_deps) exts = {'bash': '.sh', 'tsch': '.csh', 'modules': '.module'} ext = exts[term] @@ -498,7 +505,8 @@ def get_parser(): help='Custom output path to copy environment files') parser.add_argument('-f', '--force', action='store_true', dest='force', help='Force overwrite of existing modulefiles', default=False) - + parser.add_argument('-a', '--add-module-deps', action='store_true', dest='add_mod_deps', + help='Add the sdsstools and sdss-access module prereq dependencies', default=False) return parser @@ -548,7 +556,7 @@ def main(opts): continue create_env(tree.environ, mirror=opts.mirror) else: - write_file(tree.environ, term='modules', out_dir=etcdir, tree_dir=opts.treedir, default=opts.default) + write_file(tree.environ, term='modules', out_dir=etcdir, tree_dir=opts.treedir, default=opts.default, add_mod_deps=opts.add_mod_deps) write_file(tree.environ, term='bash', out_dir=etcdir, tree_dir=opts.treedir) write_file(tree.environ, term='tsch', out_dir=etcdir, tree_dir=opts.treedir) diff --git a/docs/sphinx/config.rst b/docs/sphinx/config.rst index 943dd46..90d828b 100644 --- a/docs/sphinx/config.rst +++ b/docs/sphinx/config.rst @@ -24,6 +24,7 @@ configurations are the following: * :ref:`DR8 <dr8>` * :ref:`sdss5 <sdss5>` - the latest working configuration for SDSS-V * :ref:`ipl1 <ipl1>` - the IPL-1 configuration for SDSS-V +* :ref:`ipl2 <ipl2>` - the IPL-2 configuration for SDSS-V .. _tree_evolve: diff --git a/docs/sphinx/tree_envs.rst b/docs/sphinx/tree_envs.rst index 1affa04..a6c1412 100644 --- a/docs/sphinx/tree_envs.rst +++ b/docs/sphinx/tree_envs.rst @@ -172,4 +172,16 @@ This is the configuration for IPL-1 .. datamodel:: tree.tree:Tree :prog: ipl-1 :title: ipl-1 + :remove-sasbase: + +.. _ipl2: + +IPL-2 +----- + +This is the configuration for IPL-2 + +.. datamodel:: tree.tree:Tree + :prog: ipl-2 + :title: ipl-2 :remove-sasbase: \ No newline at end of file diff --git a/setup.cfg b/setup.cfg index d2815f1..56581ef 100644 --- a/setup.cfg +++ b/setup.cfg @@ -72,13 +72,14 @@ dev = wheel>=0.33.6 docs = - Sphinx>=2.1.0 + Sphinx>=3.0.0 sphinx_bootstrap_theme>=0.4.12 recommonmark>=0.6 sphinx-argparse>=0.2.5 sphinx-issues>=1.2.0 importlib_metadata>=1.6.0 jinja2<3.1 + six>=1.14 [isort] line_length = 100	sdss/tree	130c12e63ada6efca9234fffc94eb38f9a802656	diff --git a/tests/test_setup.py b/tests/test_setup.py index bfa1033..ba0402f 100644 --- a/tests/test_setup.py +++ b/tests/test_setup.py @@ -129,6 +129,30 @@ def test_create_files(tree, config): assert os.path.exists(os.path.join(moduledir, config)) +def test_no_mod_deps(tree): + """ test that the module deps are not in module file """ + etcdir = os.path.join(os.getenv('TREE_DIR'), 'etc') + stdout = run_cmd(args=[]) + files = glob.glob(os.path.join(etcdir, 'dr18.module')) + assert os.path.exists(os.path.join(etcdir, 'dr18.module')) + with open(files[0], 'r') as f: + data = f.read() + assert "module load sdsstools" not in data + assert "prereq sdss_access" not in data + + +def test_add_mod_deps(tree): + """ test that the module deps are not in module file """ + etcdir = os.path.join(os.getenv('TREE_DIR'), 'etc') + stdout = run_cmd(args=['-a']) + files = glob.glob(os.path.join(etcdir, 'dr18.module')) + assert os.path.exists(os.path.join(etcdir, 'dr18.module')) + with open(files[0], 'r') as f: + data = f.read() + assert "module load sdsstools" in data + assert "prereq sdss_access" in data + + @pytest.fixture() def resetmod(monkeypatch): mdir = os.environ.get('MODULES_DIR')	make module dependencies optional Hi @havok2063 I ran some tests installing the SDSS software framework via pip install sdss-access which then installs sdss-tree, and sdsstools (without modules). I then ran setup_tree.py by following https://sdss-tree.readthedocs.io/en/latest/tree_setup.html#creating-environment-symlinks. This worked great, except the resulting modulefiles include module load dependencies for sdsstools and sdss_access, which is broken since those dependencies were pip installed and do not have modulefiles, and if they did the pythonpath would over-ride the pip installed paths, so this usecase is broken. Can we remove the module file dependencies so that tree does not look for module files for sdss_access or sdsstools or do you have another way to fix this? Thanks, Joel	130c12e63ada6efca9234fffc94eb38f9a802656	[ "tests/test_setup.py::test_no_mod_deps", "tests/test_setup.py::test_add_mod_deps" ]	[ "tests/test_setup.py::test_intemp", "tests/test_setup.py::test_envlinks[mangahi]", "tests/test_setup.py::test_envlinks[redux]", "tests/test_setup.py::test_env_only[mangahi]", "tests/test_setup.py::test_env_only[redux]", "tests/test_setup.py::test_env_mirror[False-SDSS-IV", "tests/test_setup.py::test_env_mirror[True-SDSS-IV", "tests/test_setup.py::test_create_files[dr15]", "tests/test_setup.py::test_create_files[dr14]", "tests/test_setup.py::test_create_files[sdsswork]", "tests/test_setup.py::test_create_files[sdss5]", "tests/test_setup.py::test_emptymodulepath[copy1]", "tests/test_setup.py::test_emptymodulepath[copy2]", "tests/test_setup.py::test_emptymodulepath[copyall]" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-03-01 19:12:28+00:00	bsd-3-clause	5,447
sealor__junkie-4	diff --git a/junkie/core_context.py b/junkie/core_context.py index 46baafd..6001fc1 100644 --- a/junkie/core_context.py +++ b/junkie/core_context.py @@ -1,5 +1,6 @@ import inspect import logging +from collections import OrderedDict from contextlib import contextmanager, ExitStack from typing import Union, Set, List, Dict, Callable, Tuple @@ -68,8 +69,7 @@ class CoreContext: yield self._call(constructor, stack, constructor.__name__) def _call(self, factory_func: Callable, stack: ExitStack, instance_name: str): - arg_instances = [] - arg_names = [] + args = OrderedDict() for name, annotation in inspect.signature(factory_func).parameters.items(): if name in self._instances: @@ -78,14 +78,16 @@ class CoreContext: elif name in self._factories: arg = self._call(self._factories[name], stack, name) + elif annotation.default is not inspect.Parameter.empty: + continue + else: raise Exception("Not found: " + name) - arg_instances.append(arg) - arg_names.append(name) + args[name] = arg - self.logger.debug("%s = %s(%s)", instance_name, factory_func.__name__, arg_names) - instance = factory_func(arg_instances) + self.logger.debug("%s = %s(%s)", instance_name, factory_func.__name__, list(args.keys())) + instance = factory_func(*args) if hasattr(instance, "__enter__"): self.logger.debug("%s.__enter__()", instance_name)	sealor/junkie	cae457a5131bb1c7cea020687076daa1edc7d13a	diff --git a/test/core_context_test.py b/test/core_context_test.py index 9c134ca..696be01 100644 --- a/test/core_context_test.py +++ b/test/core_context_test.py @@ -87,6 +87,36 @@ class CoreContextTest(unittest.TestCase): self.assertNotEqual(instance1, instance2) + def test_default_argument_usage(self): + class MyClassWithDefaultArguments: + def __init__(self, argument: str, default_argument: int = 10, default_argument2: str = None): + self.argument = argument + self.default_argument = default_argument + self.default_argument2 = default_argument2 or "Hello" + + core_context = CoreContext() + core_context.add_instances({"argument": "value"}) + + with core_context.build_instance_by_type(MyClassWithDefaultArguments) as instance: + self.assertEqual("value", instance.argument) + self.assertEqual(10, instance.default_argument) + self.assertEqual("Hello", instance.default_argument2) + + def test_partial_default_arguments_usage(self): + class MyClassWithDefaultArguments: + def __init__(self, argument: str, default_argument: int = 10, default_argument2: str = None): + self.argument = argument + self.default_argument = default_argument + self.default_argument2 = default_argument2 or "Hello" + + core_context = CoreContext() + core_context.add_instances({"argument": "value", "default_argument2": "set from context"}) + + with core_context.build_instance_by_type(MyClassWithDefaultArguments) as instance: + self.assertEqual("value", instance.argument) + self.assertEqual(10, instance.default_argument) + self.assertEqual("set from context", instance.default_argument2) + def test_context_manager_enter_and_exit(self): class Class: def __init__(self, message_service, database_context):	Support default arguments How to reproduce: ``` from junkie import Context class Foo: def __init__(self, bar=None): self.bar = bar context = Context({ "foo": Foo }) with context.build(Foo) as foo: pass ``` Current behaviour: `Exception: Not found: bar` Expected behaviour: Since `bar` has a default value, one would expect using that default value if not found in the context.	cae457a5131bb1c7cea020687076daa1edc7d13a	[ "test/core_context_test.py::CoreContextTest::test_default_argument_usage", "test/core_context_test.py::CoreContextTest::test_partial_default_arguments_usage" ]	[ "test/core_context_test.py::CoreContextTest::test_build_instance_by_dict_with_list_in_right_order", "test/core_context_test.py::CoreContextTest::test_build_instance_by_name", "test/core_context_test.py::CoreContextTest::test_build_instance_by_names", "test/core_context_test.py::CoreContextTest::test_build_instance_by_type", "test/core_context_test.py::CoreContextTest::test_context_manager_enter_and_exit", "test/core_context_test.py::CoreContextTest::test_factory_using_other_factory", "test/core_context_test.py::CoreContextTest::test_logging", "test/core_context_test.py::CoreContextTest::test_simple_factory", "test/core_context_test.py::CoreContextTest::test_simple_instance" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2020-03-26 11:57:49+00:00	mit	5,448
sec-edgar__sec-edgar-118	diff --git a/docs/source/whatsnew/v0.1.7.rst b/docs/source/whatsnew/v0.1.7.rst new file mode 100644 index 0000000..0826855 --- /dev/null +++ b/docs/source/whatsnew/v0.1.7.rst @@ -0,0 +1,12 @@ +v0.1.7 +------ + +Highlights +~~~~~~~~~~ + +* Fixes `DailyFilings` bug to properly fetch daily filings. + +Contributors +~~~~~~~~~~~~ + +- jonzd \ No newline at end of file diff --git a/secedgar/__init__.py b/secedgar/__init__.py index 2fb2513..124e462 100644 --- a/secedgar/__init__.py +++ b/secedgar/__init__.py @@ -1,1 +1,1 @@ -__version__ = '0.1.6' +__version__ = '0.1.7' diff --git a/secedgar/filings/daily.py b/secedgar/filings/daily.py index efafbd4..b11d124 100644 --- a/secedgar/filings/daily.py +++ b/secedgar/filings/daily.py @@ -47,8 +47,13 @@ class DailyFilings(AbstractFiling): @property def path(self): - """str: Path added to client base.""" - return "Archives/edgar/daily-index/{year}/QTR{num}".format( + """str: Path added to client base. + + .. note:: + The trailing slash at the end of the path is important. + Omitting will raise EDGARQueryError. + """ + return "Archives/edgar/daily-index/{year}/QTR{num}/".format( year=self._date.year, num=self.quarter) @property @@ -72,6 +77,22 @@ class DailyFilings(AbstractFiling): self._quarterly_directory = self.client.get_response(self.path, self.params, kwargs) return self._quarterly_directory + def _get_idx_formatted_date(self): + """Format date for idx file. + + EDGAR changed its master.idx file format twice. In 1995 QTR 1 and in 1998 QTR 2. + The format went from MMDDYY to YYMMDD to YYYYMMDD. + + Returns: + date (str): Correctly formatted date for master.idx file. + """ + if self._date.year < 1995: + return self._date.strftime("%m%d%y") + elif self._date < datetime.datetime(1998, 3, 31): + return self._date.strftime("%y%m%d") + else: + return self._date.strftime("%Y%m%d") + def _get_master_idx_file(self, update_cache=False, kwargs): """Get master file with all filings from given date. @@ -81,19 +102,20 @@ class DailyFilings(AbstractFiling): kwargs: Keyword arguments to pass to `client.get_response`. Returns: - text (str): Idx file as string. + text (str): Idx file text. Raises: EDGARQueryError: If no file of the form master.<DATE>.idx is found. """ if self._master_idx_file is None or update_cache: - formatted_date = datetime.datetime.strftime("%y%m%d", self._date) + formatted_date = self._get_idx_formatted_date() formatted_file_name = "master.{date}.idx".format(date=formatted_date) if formatted_file_name in self._get_quarterly_directory().text: master_idx_url = "{path}/master.{date}.idx".format( path=self.path, date=formatted_date) - self._master_idx_file = self.client.get_response(master_idx_url, kwargs).text + self._master_idx_file = self.client.get_response( + master_idx_url, self.params, kwargs).text else: raise EDGARQueryError("""File master.{date}.idx not found. There may be no filings for this day.""".format( diff --git a/secedgar/utils/cik_map.py b/secedgar/utils/cik_map.py index 40822f5..03b6cd4 100644 --- a/secedgar/utils/cik_map.py +++ b/secedgar/utils/cik_map.py @@ -14,7 +14,7 @@ def get_cik_map(key="ticker"): Returns: Dictionary with either ticker or company name as keys, depending on - ``key`` argument, and corresponding CIK as values. + ``key`` argument, and corresponding CIK as values. .. versionadded:: 0.1.6 """	sec-edgar/sec-edgar	4e1f9597946d4cedceabc1ea3c5526dc17e46e91	diff --git a/secedgar/tests/client/test_network_client.py b/secedgar/tests/client/test_network_client.py index ae4c5a0..ce6bd1d 100644 --- a/secedgar/tests/client/test_network_client.py +++ b/secedgar/tests/client/test_network_client.py @@ -8,7 +8,7 @@ from secedgar.tests.utils import datapath @pytest.fixture def client(): - return NetworkClient() + return NetworkClient(pause=0.01) class MockNoCIKFoundBadResponse: diff --git a/secedgar/tests/filings/test_daily.py b/secedgar/tests/filings/test_daily.py index 13da078..05a9a85 100644 --- a/secedgar/tests/filings/test_daily.py +++ b/secedgar/tests/filings/test_daily.py @@ -113,14 +113,32 @@ class TestDaily: ) def test_path_property(self, year, month, day, quarter): daily_filing = DailyFilings(datetime(year, month, day)) - assert daily_filing.path == "Archives/edgar/daily-index/{year}/QTR{quarter}".format( + assert daily_filing.path == "Archives/edgar/daily-index/{year}/QTR{quarter}/".format( year=year, quarter=quarter) def test_no_params(self): + """Params should always be empty.""" daily_filing = DailyFilings(datetime(2020, 1, 1)) - # params should always be empty assert not daily_filing.params + @pytest.mark.parametrize( + "date_tuple,formatted", + [ + ((1994, 1, 2), "010294"), + ((1994, 12, 31), "123194"), + ((1995, 1, 1), "950101"), + ((1995, 1, 2), "950102"), + ((1998, 1, 1), "980101"), + ((1998, 1, 2), "980102"), + ((1998, 3, 31), "19980331"), + ((1998, 4, 1), "19980401"), + ((1999, 1, 1), "19990101"), + ] + ) + def test_master_idx_date_format(self, date_tuple, formatted): + daily_filing = DailyFilings(datetime(*date_tuple)) + assert daily_filing._get_idx_formatted_date() == formatted + @pytest.mark.parametrize( "subdir,file", [	DailyFilings not working Using the DailyFilings function to get a day's filings does not work, Line 92 of daily.py has a problem with datetime.strftime. TypeError: descriptor 'strftime' requires a 'datetime.date' object but received a 'str' When I changed datetime.datetime.strftime to formatted_date = self._date.strftime("%y%m%d"), network_client.py gives a client-side error. Thanks!	4e1f9597946d4cedceabc1ea3c5526dc17e46e91	[ "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2018-1-1-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2017-5-1-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2016-6-30-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2015-7-1-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2014-9-30-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2013-10-1-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2012-11-20-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2011-12-31-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple0-010294]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple1-123194]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple2-950101]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple3-950102]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple4-980101]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple5-980102]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple6-19980331]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple7-19980401]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple8-19990101]" ]	[ "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_raises_error", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_good_response_single_filing_type_passes", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_good_response_multiple_cik_results_passes", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_good_response_single_filing_passes", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_codes[203]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_codes[400]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_codes[401]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_codes[500]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_response_codes[501]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_retry_count_setter[0.5-expectation0]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_retry_count_setter[2-expectation1]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_retry_count_setter[-1-expectation2]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_pause_setter[2-expectation0]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_pause_setter[-0.5-expectation1]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_pause_setter[-1-expectation2]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_count_setter[0.5-expectation0]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_count_setter[1-expectation1]", "secedgar/tests/client/test_network_client.py::TestNetworkClient::test_client_bad_count_setter[0-expectation2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date0-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date1-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date2-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date3-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date4-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date5-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date6-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date7-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[1.0]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[12]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[12/31/2018]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[http://www.sec.gov/Archives/edgar/data/1000228/0001209191-18-064398.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046093.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046095.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046101.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046102.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_quarterly_directory", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[HENRY", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[ROYAL", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[NOVAVAX", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[BROOKFIELD", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[PERUSAHAAN", "secedgar/tests/filings/test_daily.py::TestDaily::test_no_params", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[HENRY", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[ROYAL", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[NOVAVAX", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[BROOKFIELD", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[BANK" ]	{ "failed_lite_validators": [ "has_added_files", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-06-27 15:18:05+00:00	apache-2.0	5,449
sec-edgar__sec-edgar-131	diff --git a/docs/source/whatsnew/v0.2.1.rst b/docs/source/whatsnew/v0.2.1.rst new file mode 100644 index 0000000..766d80f --- /dev/null +++ b/docs/source/whatsnew/v0.2.1.rst @@ -0,0 +1,13 @@ +v0.2.1 +------ + +Highlights +~~~~~~~~~~ + +* Fixes bug where ``Filing`` does not work when ``count`` is not specified (thanks to formvoltron!) + +Contributors +~~~~~~~~~~~~ + +- jackmoody11 +- formvoltron \ No newline at end of file diff --git a/secedgar/filings/filing.py b/secedgar/filings/filing.py index edf13a8..3af48af 100644 --- a/secedgar/filings/filing.py +++ b/secedgar/filings/filing.py @@ -80,6 +80,8 @@ class Filing(AbstractFiling): if val is not None: self._start_date = val self._params['datea'] = sanitize_date(val) + else: + self._start_date = None @property def end_date(self): @@ -111,7 +113,7 @@ class Filing(AbstractFiling): @count.setter def count(self, val): if val is None: - pass + self._count = None elif not isinstance(val, int): raise TypeError("Count must be positive integer or None.") elif val < 1: @@ -182,7 +184,7 @@ class Filing(AbstractFiling): txt_urls = [link[:link.rfind("-")].strip() + ".txt" for link in links] - if len(txt_urls) < self.count: + if isinstance(self.count, int) and len(txt_urls) < self.count: warnings.warn("Only {num} of {count} filings were found for {cik}.".format( num=len(txt_urls), count=self.count, cik=cik))	sec-edgar/sec-edgar	e89db9c12c13aeae47bca40944fc19f093ec12c9	diff --git a/secedgar/tests/filings/test_filings.py b/secedgar/tests/filings/test_filings.py index c17271b..6ed1a63 100644 --- a/secedgar/tests/filings/test_filings.py +++ b/secedgar/tests/filings/test_filings.py @@ -9,7 +9,6 @@ from secedgar.utils.exceptions import FilingTypeError, EDGARQueryError class TestFiling(object): - @pytest.mark.slow def test_count_returns_exact(self, mock_cik_validator_get_single_cik, mock_single_cik_filing): @@ -21,6 +20,53 @@ class TestFiling(object): Got {0}, but expected {1} URLs.""".format( urls, count)) + @pytest.mark.parametrize( + "count", + [ + None, + 5, + 10, + 15, + 27, + 33 + ] + ) + def test_count_setter_on_init(self, count): + filing = Filing(cik_lookup='aapl', filing_type=FilingType.FILING_10Q, count=count) + assert filing.count == count + + @pytest.mark.parametrize( + "start_date", + [ + datetime.datetime(2020, 1, 1), + datetime.datetime(2020, 2, 1), + datetime.datetime(2020, 3, 1), + datetime.datetime(2020, 4, 1), + datetime.datetime(2020, 5, 1), + "20200101", + 20200101, + None + ] + ) + def test_good_start_date_setter_on_init(self, start_date): + filing = Filing(cik_lookup='aapl', filing_type=FilingType.FILING_10Q, start_date=start_date) + assert filing.start_date == start_date + + @pytest.mark.parametrize( + "bad_start_date", + [ + 1, + 2020010101, + "2020010101", + "2020", + "0102" + ] + ) + def test_bad_start_date_setter_on_init(self, bad_start_date): + with pytest.raises(TypeError): + Filing(cik_lookup='aapl', filing_type=FilingType.FILING_10Q, + start_date=bad_start_date) + @pytest.mark.parametrize( "count,expected_error", [ @@ -33,9 +79,9 @@ class TestFiling(object): ) def test_count_setter_bad_values(self, count, expected_error): with pytest.raises(expected_error): - _ = Filing(cik_lookup='aapl', - filing_type=FilingType.FILING_10Q, - count=count) + Filing(cik_lookup='aapl', + filing_type=FilingType.FILING_10Q, + count=count) def test_date_is_sanitized(self): start_date = datetime.datetime(2012, 3, 1) @@ -221,3 +267,9 @@ class TestFiling(object): # Should raise assertion error since no UserWarning should be found except AssertionError: pass + + @pytest.mark.skip + @pytest.mark.smoke + def test_filing_simple_example(self, tmp_data_directory): + my_filings = Filing(cik_lookup='IBM', filing_type=FilingType.FILING_10Q) + my_filings.save(tmp_data_directory)	error running simple example Describe the bug The example: from secedgar.filings import Filing, FilingType my_filings = Filing(cik_lookup='IBM', filing_type=FilingType.FILING_10Q) my_filings.save('./filings') ----------------------------- Gives the error. Traceback (most recent call last): File "testit.py", line 4, in <module> my_filings.save('./filings') File "/yada/sec-edgar/secedgar/filings/filing.py", line 224, in save urls = self.get_urls() File "/yada/sec-edgar/secedgar/filings/filing.py", line 152, in get_urls for key, cik in self.cik_lookup.lookup_dict.items() File "/yada/sec-edgar/secedgar/filings/filing.py", line 152, in <dictcomp> for key, cik in self.cik_lookup.lookup_dict.items() File "/yada/sec-edgar/secedgar/filings/filing.py", line 176, in _get_urls_for_cik while self.count is None or len(links) < self.count: File "/yada/sec-edgar/secedgar/filings/filing.py", line 109, in count return self._count AttributeError: 'Filing' object has no attribute '_count' Desktop (please complete the following information): macOs python3. Also tried on ubuntu, same error. Additional context Using tag 0.2.0	e89db9c12c13aeae47bca40944fc19f093ec12c9	[ "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[None]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[None]" ]	[ "secedgar/tests/filings/test_filings.py::TestFiling::test_count_returns_exact", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[5]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[10]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[15]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[27]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_on_init[33]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[start_date0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[start_date1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[start_date2]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[start_date3]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[start_date4]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[20200101_0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_good_start_date_setter_on_init[20200101_1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_start_date_setter_on_init[1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_start_date_setter_on_init[2020010101_0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_start_date_setter_on_init[2020010101_1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_start_date_setter_on_init[2020]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_start_date_setter_on_init[0102]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_bad_values[-1-ValueError]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_bad_values[0-ValueError]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_bad_values[0.0-TypeError]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_bad_values[1.0-TypeError]", "secedgar/tests/filings/test_filings.py::TestFiling::test_count_setter_bad_values[1-TypeError]", "secedgar/tests/filings/test_filings.py::TestFiling::test_date_is_sanitized", "secedgar/tests/filings/test_filings.py::TestFiling::test_date_is_sanitized_when_changed", "secedgar/tests/filings/test_filings.py::TestFiling::test_end_date_setter[20120101-20120101_0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_end_date_setter[20120101-20120101_1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_end_date_setter[date2-20120101]", "secedgar/tests/filings/test_filings.py::TestFiling::test_txt_urls", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_type_setter[FilingType.FILING_10K]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_type_setter[FilingType.FILING_8K]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_type_setter[FilingType.FILING_13F]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_type_setter[FilingType.FILING_SD]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_filing_type_setter[10-k]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_filing_type_setter[10k]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_filing_type_setter[10-q]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_filing_type_setter[10q]", "secedgar/tests/filings/test_filings.py::TestFiling::test_bad_filing_type_setter[123]", "secedgar/tests/filings/test_filings.py::TestFiling::test_invalid_filing_type_types[10-j]", "secedgar/tests/filings/test_filings.py::TestFiling::test_invalid_filing_type_types[10-k]", "secedgar/tests/filings/test_filings.py::TestFiling::test_invalid_filing_type_types[ssd]", "secedgar/tests/filings/test_filings.py::TestFiling::test_invalid_filing_type_types[invalid]", "secedgar/tests/filings/test_filings.py::TestFiling::test_invalid_filing_type_types[1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_validate_cik_type_inside_filing[1234567891011]", "secedgar/tests/filings/test_filings.py::TestFiling::test_validate_cik_type_inside_filing[12345]", "secedgar/tests/filings/test_filings.py::TestFiling::test_validate_cik_type_inside_filing[123.0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_validate_cik_inside_filing", "secedgar/tests/filings/test_filings.py::TestFiling::test_save_no_filings_raises_error[no_urls0]", "secedgar/tests/filings/test_filings.py::TestFiling::test_save_no_filings_raises_error[no_urls1]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_save_multiple_ciks", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_save_single_cik", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_get_urls_returns_single_list_of_urls", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_returns_correct_number_of_urls[10]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_returns_correct_number_of_urls[25]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_returns_correct_number_of_urls[30]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_raises_warning_when_less_filings_than_count[20-True]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_raises_warning_when_less_filings_than_count[30-True]", "secedgar/tests/filings/test_filings.py::TestFiling::test_filing_raises_warning_when_less_filings_than_count[40-True]" ]	{ "failed_lite_validators": [ "has_added_files" ], "has_test_patch": true, "is_lite": false }	2020-07-27 17:04:42+00:00	apache-2.0	5,450
sec-edgar__sec-edgar-138	diff --git a/docs/source/whatsnew.rst b/docs/source/whatsnew.rst index 6c246e6..c637790 100644 --- a/docs/source/whatsnew.rst +++ b/docs/source/whatsnew.rst @@ -6,6 +6,8 @@ What's New New features, bug fixes, and improvements for each release. +.. include:: whatsnew/v0.2.2.rst + .. include:: whatsnew/v0.2.1.rst .. include:: whatsnew/v0.2.0.rst diff --git a/docs/source/whatsnew/v0.2.2.rst b/docs/source/whatsnew/v0.2.2.rst new file mode 100644 index 0000000..ed0bb99 --- /dev/null +++ b/docs/source/whatsnew/v0.2.2.rst @@ -0,0 +1,13 @@ +v0.2.1 +------ + +Highlights +~~~~~~~~~~ + +* Fixes bug where ``DailyFilings`` and ``MasterFilings`` does not use correct URLs when calling `save` method (thanks to alpbozkurt!) + +Contributors +~~~~~~~~~~~~ + +- jackmoody11 +- alpbozkurt \ No newline at end of file diff --git a/secedgar/__init__.py b/secedgar/__init__.py index fc79d63..020ed73 100644 --- a/secedgar/__init__.py +++ b/secedgar/__init__.py @@ -1,1 +1,1 @@ -__version__ = '0.2.1' +__version__ = '0.2.2' diff --git a/secedgar/filings/_base.py b/secedgar/filings/_base.py index ebbe5e2..ddd526b 100644 --- a/secedgar/filings/_base.py +++ b/secedgar/filings/_base.py @@ -34,7 +34,8 @@ class AbstractFiling(ABC): kwargs: Anything to be passed to requests when making GET request. Returns: - urls (list): List of urls for txt files to download. + urls (dict): Dictionary of urls for txt files to download. + Keys are lookup terms and values are list of URLs. """ pass # pragma: no cover @@ -69,3 +70,19 @@ class AbstractFiling(ABC): allowed = string.digits + string.ascii_letters + string.whitespace stripped = "".join(c for c in path if c in allowed) return stripped.replace(" ", "_") + + def _check_urls_exist(self): + """Wrapper around `get_urls` to check if there is a positive number of URLs. + + .. note:: This method will not check if the URLs are valid. Simply if they exist. + + Raises: + ValueError: If no URLs exist, then ValueError is raised. + + Returns: + urls (dict): Result of `get_urls` method. + """ + urls = self.get_urls() + if all(len(urls[cik]) == 0 for cik in urls.keys()): + raise ValueError("No filings available.") + return urls diff --git a/secedgar/filings/_index.py b/secedgar/filings/_index.py index 10d4638..95bb216 100644 --- a/secedgar/filings/_index.py +++ b/secedgar/filings/_index.py @@ -27,7 +27,7 @@ class IndexFilings(AbstractFiling): self._master_idx_file = None self._filings_dict = None self._paths = [] - self._urls = [] + self._urls = {} @property def client(self): @@ -115,16 +115,19 @@ class IndexFilings(AbstractFiling): # Will have CIK as keys and list of FilingEntry namedtuples as values self._filings_dict = {} FilingEntry = namedtuple( - "FilingEntry", ["cik", "company_name", "form_type", "date_filed", "file_name"]) + "FilingEntry", ["cik", "company_name", "form_type", "date_filed", "file_name", + "path"]) # idx file will have lines of the form CIK\|Company Name\|Form Type\|Date Filed\|File Name entries = re.findall(r'^[0-9]+[\|].+[\|].+[\|][0-9\-]+[\|].+$', idx_file, re.MULTILINE) for entry in entries: fields = entry.split("\|") + path = "Archives/{file_name}".format(file_name=fields[-1]) + entry = FilingEntry(fields, path=path) # Add new filing entry to CIK's list if fields[0] in self._filings_dict: - self._filings_dict[fields[0]].append(FilingEntry(fields)) + self._filings_dict[fields[0]].append(entry) else: - self._filings_dict[fields[0]] = [FilingEntry(*fields)] + self._filings_dict[fields[0]] = [entry] return self._filings_dict def make_url(self, path): @@ -138,28 +141,6 @@ class IndexFilings(AbstractFiling): """ return "{base}{path}".format(base=self.client._BASE, path=path) - def get_paths(self, update_cache=False): - """Gets all paths for given day. - - Each path will look something like - "edgar/data/1000228/0001209191-18-064398.txt". - - Args: - update_cache (bool, optional): Whether urls should be updated on each method call. - Defaults to False. - - Returns: - urls (list of str): List of urls. - """ - if len(self._paths) == 0: - for entries in self.get_filings_dict().values(): - for entry in entries: - # Will be of the form - self._paths.append( - "Archives/{file_name}".format( - file_name=entry.file_name)) - return self._paths - def get_urls(self): """Get all URLs for day. @@ -168,43 +149,38 @@ class IndexFilings(AbstractFiling): Returns: urls (list of str): List of all URLs to get. """ - if len(self._urls) == 0: - paths = self.get_paths() - self._urls = [self.make_url(path) for path in paths] + if not self._urls: + filings_dict = self.get_filings_dict() + self._urls = {company: [self.make_url(entry.path) for entry in entries] + for company, entries in filings_dict.items()} return self._urls def save_filings(self, directory): """Save all filings. - Will store all filings for each unique company name under a separate subdirectory + Will store all filings for each unique CIK under a separate subdirectory within given directory argument. Ex: my_directory \| - ---- Apple Inc. + ---- CIK 1 \| ---- ...txt files - ---- Microsoft Corp. + ---- CIK 2 \| ---- ...txt files Args: - directory (str): Directory where filings should be stored. Will be broken down - further by company name and form type. + directory (str): Directory where filings should be stored. """ - self.get_filings_dict() - for filings in self._filings_dict.values(): - # take the company name from the first filing and make that the subdirectory name - clean_company_name = self.clean_directory_path(filings[0].company_name) - subdirectory = os.path.join(directory, clean_company_name) - # TODO: Clean company name to make valid directory name (get rid of special characters) - make_path(subdirectory) - for filing in filings: - filename = self.get_accession_number(filing.file_name) - filing_path = os.path.join( - subdirectory, filename) - url = self.make_url(filename) - data = requests.get(url).text - with open(filing_path, 'w') as f: + urls = self._check_urls_exist() + + for company, links in urls.items(): + for link in links: + data = requests.get(link).text + path = os.path.join(directory, company) + make_path(path) + path = os.path.join(path, self.get_accession_number(link)) + with open(path, "w") as f: f.write(data) diff --git a/secedgar/filings/filing.py b/secedgar/filings/filing.py index 3af48af..7759b3a 100644 --- a/secedgar/filings/filing.py +++ b/secedgar/filings/filing.py @@ -191,23 +191,6 @@ class Filing(AbstractFiling): # Takes `count` filings at most return txt_urls[:self.count] - def _get_accession_numbers(self, links): - """Gets accession numbers given list of links. - - Of the form https://www.sec.gov/Archives/edgar/data/<cik>/ - <first part of accession number before '-'>/<accession number>-index.htm. - - Args: - links (list): List of links to extract accession numbers from. - - Returns: - List of accession numbers for given links. - """ - self._accession_numbers = [self.get_accession_number( - link).replace('-index.htm', '') for link in links] - return self._accession_numbers - - # TODO: break this method down further def save(self, directory): """Save files in specified directory. @@ -223,9 +206,7 @@ class Filing(AbstractFiling): Raises: ValueError: If no text urls are available for given filing object. """ - urls = self.get_urls() - if all(len(urls[cik]) == 0 for cik in urls.keys()): - raise ValueError("No filings available.") + urls = self._check_urls_exist() for cik, links in urls.items(): for link in links: diff --git a/setup.cfg b/setup.cfg index 51b50a0..e749bba 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,2 +1,7 @@ [flake8] -max-line-length = 100 \ No newline at end of file +max-line-length = 100 + +[tool:pytest] +markers = + smoke: marks tests as smoke tests (deselect with -m not smoke) + slow: marks tests as slow (deselect with -m not slow) \ No newline at end of file	sec-edgar/sec-edgar	51ee1639641f6dfb7b1c7b8daf2c252056624957	diff --git a/secedgar/tests/filings/test_daily.py b/secedgar/tests/filings/test_daily.py index 1ae926a..a29f373 100644 --- a/secedgar/tests/filings/test_daily.py +++ b/secedgar/tests/filings/test_daily.py @@ -54,18 +54,18 @@ class TestDaily: DailyFilings(bad_date) @pytest.mark.parametrize( - "url", + "key,url", [ - "http://www.sec.gov/Archives/edgar/data/1000228/0001209191-18-064398.txt", - "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046093.txt", - "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046095.txt", - "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046101.txt", - "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046102.txt" + ("1000228", "http://www.sec.gov/Archives/edgar/data/1000228/0001209191-18-064398.txt"), + ("1000275", "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046093.txt"), + ("1000275", "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046095.txt"), + ("1000275", "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046101.txt"), + ("1000275", "http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046102.txt") ] ) - def test_get_urls(self, mock_daily_quarter_directory, mock_daily_idx_file, url): + def test_get_urls(self, mock_daily_quarter_directory, mock_daily_idx_file, key, url): daily_filing = DailyFilings(datetime(2018, 12, 31)) - assert url in daily_filing.get_urls() + assert url in daily_filing.get_urls()[key] def test_get_listings_directory(self, mock_daily_quarter_directory): assert DailyFilings(datetime(2018, 12, 31)).get_listings_directory().status_code == 200 @@ -134,11 +134,11 @@ class TestDaily: @pytest.mark.parametrize( "subdir,file", [ - ("HENRY_SCHEIN_INC", "0001209191-18-064398.txt"), - ("ROYAL_BANK_OF_CANADA", "0001140361-18-046093.txt"), - ("NOVAVAX_INC", "0001144204-18-066754.txt"), - ("BROOKFIELD_ASSET_MANAGEMENT_INC", "0001104659-18-075315.txt"), - ("BANK_OF_SOUTH_CAROLINA_CORP", "0001225208-18-017075.txt") + ("1000228", "0001209191-18-064398.txt"), + ("1000275", "0001140361-18-046093.txt"), + ("1000694", "0001144204-18-066754.txt"), + ("1001085", "0001104659-18-075315.txt"), + ("1007273", "0001225208-18-017075.txt") ] ) def test_save(self, tmp_data_directory, diff --git a/secedgar/tests/filings/test_master.py b/secedgar/tests/filings/test_master.py index f08bfbd..cf90359 100644 --- a/secedgar/tests/filings/test_master.py +++ b/secedgar/tests/filings/test_master.py @@ -65,11 +65,11 @@ class TestMaster: @pytest.mark.parametrize( "subdir,file", [ - ("SAGE_CAPITAL_LP", "9999999997-02-056978.txt"), - ("BETHLEHEM_STEEL_CORP_DE", "0000011860-94-000005.txt"), - ("CAPITAL_HOLDING_CORP", "0000017206-94-000007.txt"), - ("DATAPOINT_CORP", "0000205239-94-000003.txt"), - ("CLARK_REFINING__MARKETING_INC", "0000950131-94-000025.txt"), + ("1095785", "9999999997-02-056978.txt"), + ("11860", "0000011860-94-000005.txt"), + ("17206", "0000017206-94-000007.txt"), + ("205239", "0000205239-94-000003.txt"), + ("20762", "0000950131-94-000025.txt"), ] ) def test_save(self, tmp_data_directory,	Daily filings with DailyFilings class all have "404 - Not Found" content Describe the bug With DailyFilings usage, 'save_filings' method of IndexFilings class generates wrong URLs for calls to 'requests.get', which results in "404 - Not Found" page in all downloaded files. I.e: URL: http://www.sec.gov/0001140361-20-015873.txt Interstingly, 'get_urls' method generates correct URL list but 'save_filings' method don't use it and generates URLs in some other way, which is wrong. Also, the accompanying tests don't check the downloaded content, so 404 page content is not caught by those tests. To Reproduce Steps to reproduce the behavior: 1. filings_client = DailyFilings(date) 2. filings_client.get_urls() # correct URLs listed 3. filings_client.save(folder) # All files have 404 page content Expected behavior 'save' method for DailyFilings should generate correct URLs and download filings, not 404 page content. Possible Fix In 'save_filings' method of 'IndexFilings' class: << url = self.make_url(filename) >> archive_filename = "Archives/%s" % filing.file_name # may not work with Python < 3 ? >> url = self.make_url(archive_filename) Tested this in Python 3.8 A better fix might be the use of 'get_urls' the way 'Filing.save' method does. I can create a PR for whichever way you choose. Desktop (please complete the following information): Ubuntu 20.04	51ee1639641f6dfb7b1c7b8daf2c252056624957	[ "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[1000228-http://www.sec.gov/Archives/edgar/data/1000228/0001209191-18-064398.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[1000275-http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046093.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[1000275-http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046095.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[1000275-http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046101.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_urls[1000275-http://www.sec.gov/Archives/edgar/data/1000275/0001140361-18-046102.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[1000228-0001209191-18-064398.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[1000275-0001140361-18-046093.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[1000694-0001144204-18-066754.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[1001085-0001104659-18-075315.txt]", "secedgar/tests/filings/test_daily.py::TestDaily::test_save[1007273-0001225208-18-017075.txt]", "secedgar/tests/filings/test_master.py::TestMaster::test_save[1095785-9999999997-02-056978.txt]", "secedgar/tests/filings/test_master.py::TestMaster::test_save[11860-0000011860-94-000005.txt]", "secedgar/tests/filings/test_master.py::TestMaster::test_save[17206-0000017206-94-000007.txt]", "secedgar/tests/filings/test_master.py::TestMaster::test_save[205239-0000205239-94-000003.txt]", "secedgar/tests/filings/test_master.py::TestMaster::test_save[20762-0000950131-94-000025.txt]" ]	[ "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date0-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date1-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date2-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date3-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date4-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date5-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date6-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_quarter[date7-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_idx_filename[date0-master.20200101.idx]", "secedgar/tests/filings/test_daily.py::TestDaily::test_idx_filename[date1-master.20200331.idx]", "secedgar/tests/filings/test_daily.py::TestDaily::test_idx_filename[date2-master.20200401.idx]", "secedgar/tests/filings/test_daily.py::TestDaily::test_idx_filename[date3-master.20200630.idx]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[1.0]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[12]", "secedgar/tests/filings/test_daily.py::TestDaily::test_bad_date_format_fails[12/31/2018]", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_listings_directory", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[HENRY", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[ROYAL", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[NOVAVAX", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[BROOKFIELD", "secedgar/tests/filings/test_daily.py::TestDaily::test_get_master_idx_file[PERUSAHAAN", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2018-1-1-1]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2017-5-1-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2016-6-30-2]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2015-7-1-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2014-9-30-3]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2013-10-1-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2012-11-20-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_path_property[2011-12-31-4]", "secedgar/tests/filings/test_daily.py::TestDaily::test_no_params", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple0-010294]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple1-123194]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple2-950101]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple3-950102]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple4-980101]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple5-980102]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple6-19980331]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple7-19980401]", "secedgar/tests/filings/test_daily.py::TestDaily::test_master_idx_date_format[date_tuple8-19990101]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[-1-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[0.0-TypeError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[1990-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[1991-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[1992-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[1993-TypeError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_year[1993.0-TypeError]", "secedgar/tests/filings/test_master.py::TestMaster::test_good_year", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[0.0-TypeError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[1.0-TypeError0]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[1-TypeError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[1.0-TypeError1]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[0-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[5-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[6-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_bad_quarter[2020-ValueError]", "secedgar/tests/filings/test_master.py::TestMaster::test_good_quarters", "secedgar/tests/filings/test_master.py::TestMaster::test_idx_filename_is_always_the_same[2018-1]", "secedgar/tests/filings/test_master.py::TestMaster::test_idx_filename_is_always_the_same[2019-2]", "secedgar/tests/filings/test_master.py::TestMaster::test_idx_filename_is_always_the_same[2020-3]", "secedgar/tests/filings/test_master.py::TestMaster::test_clean_path[Apple", "secedgar/tests/filings/test_master.py::TestMaster::test_clean_path[Microsoft", "secedgar/tests/filings/test_master.py::TestMaster::test_clean_path[Bed,", "secedgar/tests/filings/test_master.py::TestMaster::test_clean_path[Company" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_added_files", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-10-25 20:53:10+00:00	apache-2.0	5,451
sec-edgar__sec-edgar-249	diff --git a/docs/source/whatsnew/v0.4.0.rst b/docs/source/whatsnew/v0.4.0.rst index 84a8249..52354c6 100644 --- a/docs/source/whatsnew/v0.4.0.rst +++ b/docs/source/whatsnew/v0.4.0.rst @@ -17,6 +17,8 @@ Many breaking changes, as this update does a lot of restructuring. - Fix issue where daily CLI command would not work due to ``date_cleanup`` returning ``datetime.datetime`` instead of ``datetime.date`` - Fix issue where ``CompanyFilings`` includes links that are not exact matches to ``filing_type``. - Add NSAR filing types. Thanks to mjkoo91! +- Get rid of caching behavior that was causing issues when downloading filings. +- Simplify ``ComboFilings`` logic for getting quarterly and daily dates. - Fix issue where ``get_cik_map`` fails due to the SEC providing ``None`` for title or ticker. Contributors diff --git a/secedgar/core/_index.py b/secedgar/core/_index.py index be2cdcf..71cd44a 100644 --- a/secedgar/core/_index.py +++ b/secedgar/core/_index.py @@ -142,43 +142,39 @@ class IndexFilings(AbstractFiling): .format(filename=self.idx_filename)) return self._master_idx_file - def get_filings_dict(self, update_cache=False, kwargs): + def get_filings_dict(self, kwargs): """Get all filings inside an idx file. Args: - update_cache (bool, optional): Whether filings dict should be - updated on each method call. Defaults to False. - kwargs: Any kwargs to pass to _get_master_idx_file. See ``secedgar.core.daily.DailyFilings._get_master_idx_file``. """ - if self._filings_dict is None or update_cache: - idx_file = self._get_master_idx_file(*kwargs) - # Will have CIK as keys and list of FilingEntry namedtuples as values - self._filings_dict = {} - FilingEntry = namedtuple("FilingEntry", [ - "cik", "company_name", "form_type", "date_filed", "file_name", - "path", "num_previously_valid" - ]) - # idx file will have lines of the form CIK\|Company Name\|Form Type\|Date Filed\|File Name - current_count = 0 - entries = re.findall(r'^[0-9]+[\|].+[\|].+[\|][0-9\-]+[\|].+$', - idx_file, re.MULTILINE) - for entry in entries: - fields = entry.split("\|") - path = "Archives/{file_name}".format(file_name=fields[-1]) - entry = FilingEntry(fields, - path=path, - num_previously_valid=current_count) - if self.entry_filter is not None and not self.entry_filter( - entry): - continue - current_count += 1 - # Add new filing entry to CIK's list - if entry.cik in self._filings_dict: - self._filings_dict[entry.cik].append(entry) - else: - self._filings_dict[entry.cik] = [entry] + idx_file = self._get_master_idx_file(*kwargs) + # Will have CIK as keys and list of FilingEntry namedtuples as values + self._filings_dict = {} + FilingEntry = namedtuple("FilingEntry", [ + "cik", "company_name", "form_type", "date_filed", "file_name", + "path", "num_previously_valid" + ]) + # idx file will have lines of the form CIK\|Company Name\|Form Type\|Date Filed\|File Name + current_count = 0 + entries = re.findall(r'^[0-9]+[\|].+[\|].+[\|][0-9\-]+[\|].+$', + idx_file, re.MULTILINE) + for entry in entries: + fields = entry.split("\|") + path = "Archives/{file_name}".format(file_name=fields[-1]) + entry = FilingEntry(fields, + path=path, + num_previously_valid=current_count) + if self.entry_filter is not None and not self.entry_filter( + entry): + continue + current_count += 1 + # Add new filing entry to CIK's list + if entry.cik in self._filings_dict: + self._filings_dict[entry.cik].append(entry) + else: + self._filings_dict[entry.cik] = [entry] return self._filings_dict def get_urls(self): @@ -189,13 +185,12 @@ class IndexFilings(AbstractFiling): Returns: urls (list of str): List of all URLs to get. """ - if not self._urls: - filings_dict = self.get_filings_dict() - self._urls = { - company: - [self.client._prepare_query(entry.path) for entry in entries] - for company, entries in filings_dict.items() - } + filings_dict = self.get_filings_dict() + self._urls = { + company: + [self.client._prepare_query(entry.path) for entry in entries] + for company, entries in filings_dict.items() + } return self._urls @staticmethod diff --git a/secedgar/core/combo.py b/secedgar/core/combo.py index 604ba04..788e310 100644 --- a/secedgar/core/combo.py +++ b/secedgar/core/combo.py @@ -2,12 +2,32 @@ from datetime import date, timedelta from functools import reduce from typing import Union +from secedgar.client import NetworkClient from secedgar.core.daily import DailyFilings from secedgar.core.quarterly import QuarterlyFilings from secedgar.exceptions import EDGARQueryError, NoFilingsError from secedgar.utils import add_quarter, get_month, get_quarter +def fill_days(start, end, include_start=False, include_end=False): + """Get dates for days in between start and end date. + + Args: + start (``datetime.date``): Start date. + end (``datetime.date``): End date. + include_start (bool, optional): Whether or not to include start date in range. + Defaults to False. + include_end (bool, optional): Whether or not to include end date in range. + Defaults to False. + + Returns: + list of ``datetime.date``: List of dates between ``start`` and ``end``. + """ + start_range = 0 if include_start else 1 + end_range = (end - start).days + 1 if include_end else (end - start).days + return [start + timedelta(days=d) for d in range(start_range, end_range)] + + class ComboFilings: """Class for retrieving all filings between specified dates. @@ -64,92 +84,154 @@ class ComboFilings: self.entry_filter = entry_filter self.start_date = start_date self.end_date = end_date - self.user_agent = user_agent - self.quarterly = QuarterlyFilings(year=self.start_date.year, - quarter=get_quarter(self.start_date), - user_agent=user_agent, - client=client, - entry_filter=self.entry_filter, - kwargs) - self.daily = DailyFilings(date=self.start_date, - user_agent=user_agent, - client=client, - entry_filter=self.entry_filter, - kwargs) - self.balancing_point = balancing_point - self._recompute() - - def _recompute(self): - """Recompute the best list of quarters and days to use based on the start and end date.""" + self._client = client or NetworkClient(user_agent=user_agent, **kwargs) + self._balancing_point = balancing_point + + @property + def entry_filter(self): + """A boolean function to be tested on each listing entry. + + This is tested regardless of download method. + """ + return self._entry_filter + + @entry_filter.setter + def entry_filter(self, fn): + if callable(fn): + self._entry_filter = fn + else: + raise ValueError('entry_filter must be a function or lambda.') + + @property + def client(self): + """``secedgar.client.NetworkClient``: Client to use to make requests.""" + return self._client + + @property + def start_date(self): + """Union([datetime.date]): Date before which no filings fetched.""" + return self._start_date + + @start_date.setter + def start_date(self, val): + if val: + self._start_date = val + else: + self._start_date = None + + @property + def end_date(self): + """Union([datetime.date]): Date after which no filings fetched.""" + return self._end_date + + @end_date.setter + def end_date(self, val): + self._end_date = val + + @property + def balancing_point(self): + """int: Point after which to use ``QuarterlyFilings`` with ``entry_filter`` to get data.""" + return self._balancing_point + + def _get_quarterly_daily_date_lists(self): + """Break down date range into combination of quarters and single dates. + + Returns: + tuple of lists: Quarterly date list and daily date list. + """ + # Initialize quarter and date lists current_date = self.start_date - self.quarterly_date_list = [] - self.daily_date_list = [] + quarterly_date_list = [] + daily_date_list = [] + while current_date <= self.end_date: current_quarter = get_quarter(current_date) current_year = current_date.year next_year, next_quarter = add_quarter(current_year, current_quarter) - next_start_quarter_date = date(next_year, get_month(next_quarter), - 1) + next_start_quarter_date = date(next_year, get_month(next_quarter), 1) days_till_next_quarter = (next_start_quarter_date - current_date).days days_till_end = (self.end_date - current_date).days + + # If there are more days until the end date than there are + # in the quarter, add if days_till_next_quarter <= days_till_end: current_start_quarter_date = date(current_year, get_month(current_quarter), 1) if current_start_quarter_date == current_date: - self.quarterly_date_list.append( + quarterly_date_list.append( (current_year, current_quarter, lambda x: True)) current_date = next_start_quarter_date elif days_till_next_quarter > self.balancing_point: - self.quarterly_date_list.append( + quarterly_date_list.append( (current_year, current_quarter, lambda x: date(x['date_filed']) >= self.start_date)) current_date = next_start_quarter_date else: - while current_date < next_start_quarter_date: - self.daily_date_list.append(current_date) - current_date += timedelta(days=1) + daily_date_list.extend(fill_days(start=current_date, + end=next_start_quarter_date, + include_start=True, + include_end=False)) + current_date = next_start_quarter_date else: if days_till_end > self.balancing_point: if days_till_next_quarter - 1 == days_till_end: - self.quarterly_date_list.append( + quarterly_date_list.append( (current_year, current_quarter, lambda x: True)) current_date = next_start_quarter_date else: - self.quarterly_date_list.append( + quarterly_date_list.append( (current_year, current_quarter, lambda x: date(x['date_filed']) <= self.end_date)) current_date = self.end_date else: - while current_date <= self.end_date: - self.daily_date_list.append(current_date) - current_date += timedelta(days=1) + daily_date_list.extend(fill_days(start=current_date, + end=self.end_date, + include_start=True, + include_end=True)) + break + return quarterly_date_list, daily_date_list + + @property + def quarterly_date_list(self): + """List of tuples: List of tuples with year, quarter, and ``entry_filter`` to use.""" + return self._get_quarterly_daily_date_lists()[0] # 0 = quarterly + + @property + def daily_date_list(self): + """List of ``datetime.date``: List of dates for which to fetch daily data.""" + return self._get_quarterly_daily_date_lists()[1] # 1 = daily def get_urls(self): """Get all urls between ``start_date`` and ``end_date``.""" # Use functools.reduce for speed # see https://stackoverflow.com/questions/10461531/merge-and-sum-of-two-dictionaries - def reducer(accumulator, dictionary): + def _reducer(accumulator, dictionary): for key, value in dictionary.items(): accumulator[key] = accumulator.get(key, []) + value return accumulator list_of_dicts = [] for (year, quarter, f) in self.quarterly_date_list: - self.quarterly.year = year - self.quarterly.quarter = quarter - self.quarterly.entry_filter = lambda x: f(x) and self.entry_filter(x) - list_of_dicts.append(self.quarterly.get_urls()) + q = QuarterlyFilings(year=year, + quarter=quarter, + user_agent=self.user_agent, + client=self.client, + entry_filter=lambda x: f(x) and self.entry_filter(x)) + list_of_dicts.append(q.get_urls()) - for d in self.daily_date_list: - self.daily.date = d + for _date in self.daily_date_list: + d = DailyFilings(date=_date, + user_agent=self.user_agent, + client=self.client, + entry_filter=self.entry_filter) try: - list_of_dicts.append(self.daily.get_urls()) - except EDGARQueryError: - pass + list_of_dicts.append(d.get_urls()) + except EDGARQueryError: # continue if no URLs available for given day + continue - complete_dictionary = reduce(reducer, list_of_dicts, {}) + complete_dictionary = reduce(_reducer, list_of_dicts, {}) return complete_dictionary def save(self, @@ -173,22 +255,28 @@ class ComboFilings: daily_date_format (str, optional): Format string to use for the `{date}` pattern. Defaults to "%Y%m%d". """ + # Go through all quarters and dates and save filings using appropriate class for (year, quarter, f) in self.quarterly_date_list: - self.quarterly.year = year - self.quarterly.quarter = quarter - self.quarterly.entry_filter = lambda x: f(x) and self.entry_filter(x) - self.quarterly.save(directory=directory, - dir_pattern=dir_pattern, - file_pattern=file_pattern, - download_all=download_all) - - for d in self.daily_date_list: - self.daily.date = d + q = QuarterlyFilings(year=year, + quarter=quarter, + user_agent=self.client.user_agent, + client=self.client, + entry_filter=lambda x: f(x) and self.entry_filter(x)) + q.save(directory=directory, + dir_pattern=dir_pattern, + file_pattern=file_pattern, + download_all=download_all) + + for date_ in self.daily_date_list: + d = DailyFilings(date=date_, + user_agent=self.client.user_agent, + client=self.client, + entry_filter=self.entry_filter) try: - self.daily.save(directory=directory, - dir_pattern=dir_pattern, - file_pattern=file_pattern, - download_all=download_all, - date_format=daily_date_format) - except (EDGARQueryError, NoFilingsError): - pass + d.save(directory=directory, + dir_pattern=dir_pattern, + file_pattern=file_pattern, + download_all=download_all, + date_format=daily_date_format) + except (EDGARQueryError, NoFilingsError): # continue if no filings for given day + continue	sec-edgar/sec-edgar	65320eae7c5b256cd197da00c16348824aadc807	diff --git a/secedgar/tests/core/test_combo.py b/secedgar/tests/core/test_combo.py index 55ea6a2..bab68c7 100644 --- a/secedgar/tests/core/test_combo.py +++ b/secedgar/tests/core/test_combo.py @@ -1,8 +1,9 @@ from datetime import date import pytest + from secedgar.client import NetworkClient -from secedgar.core.combo import ComboFilings +from secedgar.core.combo import ComboFilings, fill_days def lambda_matches(a, b): @@ -18,6 +19,22 @@ def quarterly_list_matches(l1, l2): class TestComboFilings: + @pytest.mark.parametrize( + "include_start,include_end,expected", + [ + (True, True, [date(2020, 1, i) for i in (1, 2, 3)]), + (True, False, [date(2020, 1, i) for i in (1, 2)]), + (False, False, [date(2020, 1, 2)]), + (False, True, [date(2020, 1, i) for i in (2, 3)]), + ] + ) + def test_fill_days(self, include_start, include_end, expected): + result = fill_days(start=date(2020, 1, 1), + end=date(2020, 1, 3), + include_start=include_start, + include_end=include_end) + assert result == expected + def test_user_agent_client_none(self): with pytest.raises(TypeError): _ = ComboFilings(start_date=date(2020, 1, 1), @@ -30,8 +47,7 @@ class TestComboFilings: combo = ComboFilings(start_date=date(2020, 1, 1), end_date=date(2020, 12, 31), client=client) - assert combo.quarterly.client == client - assert combo.daily.client == client + assert combo.client == client def test_combo_quarterly_only_one_year(self, mock_user_agent): combo = ComboFilings(start_date=date(2020, 1, 1), @@ -102,9 +118,60 @@ class TestComboFilings: assert [str(s) for s in combo.daily_date_list] == daily_expected assert quarterly_list_matches(combo.quarterly_date_list, quarterly_expected) - def test_user_agent_passed_to_client(self, mock_user_agent): + def test_properties_on_init(self, mock_user_agent): + start = date(2020, 1, 1) + end = date(2020, 5, 30) + bp = 25 + combo = ComboFilings(start_date=start, + end_date=end, + user_agent=mock_user_agent, + balancing_point=bp) + + assert combo.start_date == start + assert combo.end_date == end + assert combo.balancing_point == bp + assert combo.client.user_agent == mock_user_agent + + @pytest.mark.parametrize( + "bad_entry_filter", + [ + None, + [], + (), + 0, + ""] + ) + def test_bad_entry_filter(self, bad_entry_filter): + with pytest.raises(ValueError): + _ = ComboFilings(start_date=date(2020, 1, 1), + end_date=date(2020, 5, 30), + entry_filter=bad_entry_filter) + + @pytest.mark.parametrize( + "good_entry_filter", + [ + lambda x: True, + lambda x: False, + lambda f: f.form_type.lower() == "10-k" + ] + ) + def test_good_entry_filter(self, good_entry_filter, mock_user_agent): + combo = ComboFilings(date(2020, 1, 1), + date(2020, 5, 30), + entry_filter=good_entry_filter, + user_agent=mock_user_agent) + assert combo.entry_filter == good_entry_filter + + def test_client_read_only(self, mock_user_agent): + combo = ComboFilings(start_date=date(2020, 1, 1), + end_date=date(2020, 1, 3), + user_agent=mock_user_agent) + with pytest.raises(AttributeError): + combo.client = None + + def test_balancing_point_read_only(self, mock_user_agent): combo = ComboFilings(start_date=date(2020, 1, 1), - end_date=date(2021, 1, 1), + end_date=date(2020, 1, 3), user_agent=mock_user_agent) - assert combo.quarterly.client.user_agent == mock_user_agent - assert combo.daily.client.user_agent == mock_user_agent + with pytest.raises(AttributeError): + combo.balancing_point = 20	The same and only file gets downloaded for all years and quarters and filing types Describe the bug When running a sample piece of code from the official documentation (with addition of a custom `client`), the data that is downloaded is the same and the only file that gets downloaded for all years, quarters and filing types. See screenshot To Reproduce Steps to reproduce the behavior: 1. Run the code snippet below ``` from datetime import date from secedgar import filings a = NetworkClient(rate_limit=1,user_agent="Mozilla") limit_to_form13 = lambda f: f.form_type in ("13F-HR", "13F-HR/A") daily_filings_limited = filings(start_date=date(1993, 1 ,1), end_date=date(2021, 3, 31), client=a, entry_filter=limit_to_form13) daily_filings_limited.save("./data_13F") ``` Expected behavior All 13F filings being downloaded for all companies and all years Screenshots ![image](https://user-images.githubusercontent.com/9093546/137359490-40cec6e0-b0ee-4a98-b429-1a91f29d60b5.png) Desktop (please complete the following information): Windows 11 v0.4.0-alpha.2 Additional context Add any other context about the problem here.	65320eae7c5b256cd197da00c16348824aadc807	[ "secedgar/tests/core/test_combo.py::TestComboFilings::test_fill_days[True-True-expected0]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_fill_days[True-False-expected1]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_fill_days[False-False-expected2]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_fill_days[False-True-expected3]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_user_agent_client_none", "secedgar/tests/core/test_combo.py::TestComboFilings::test_client_passed_to_objects", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_quarterly_only_one_year", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_quarterly_only_multiple_years", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_only_single_day", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_only_multiple_days", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_quarterly_mixed[start_date0-end_date0-quarterly_expected0-daily_expected0]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_quarterly_mixed[start_date1-end_date1-quarterly_expected1-daily_expected1]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_quarterly_mixed[start_date2-end_date2-quarterly_expected2-daily_expected2]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_combo_daily_quarterly_mixed[start_date3-end_date3-quarterly_expected3-daily_expected3]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_properties_on_init", "secedgar/tests/core/test_combo.py::TestComboFilings::test_bad_entry_filter[None]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_bad_entry_filter[bad_entry_filter1]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_bad_entry_filter[bad_entry_filter2]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_bad_entry_filter[0]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_bad_entry_filter[]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_good_entry_filter[<lambda>0]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_good_entry_filter[<lambda>1]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_good_entry_filter[<lambda>2]", "secedgar/tests/core/test_combo.py::TestComboFilings::test_client_read_only", "secedgar/tests/core/test_combo.py::TestComboFilings::test_balancing_point_read_only" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_media", "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2021-11-29 02:42:01+00:00	apache-2.0	5,452
sec-edgar__sec-edgar-251	diff --git a/docs/source/whatsnew/v0.4.0.rst b/docs/source/whatsnew/v0.4.0.rst index 52354c6..af6620b 100644 --- a/docs/source/whatsnew/v0.4.0.rst +++ b/docs/source/whatsnew/v0.4.0.rst @@ -16,6 +16,7 @@ Many breaking changes, as this update does a lot of restructuring. - Fix use of ``user_agent`` by ``NetworkClient`` and require its use by all filings classes/functions - Fix issue where daily CLI command would not work due to ``date_cleanup`` returning ``datetime.datetime`` instead of ``datetime.date`` - Fix issue where ``CompanyFilings`` includes links that are not exact matches to ``filing_type``. +- Fix issue where ``get_urls`` does not reset ``params`` after getting company filings URLs. - Add NSAR filing types. Thanks to mjkoo91! - Get rid of caching behavior that was causing issues when downloading filings. - Simplify ``ComboFilings`` logic for getting quarterly and daily dates. diff --git a/secedgar/core/company.py b/secedgar/core/company.py index c4fa20e..b4480c4 100644 --- a/secedgar/core/company.py +++ b/secedgar/core/company.py @@ -107,12 +107,10 @@ class CompanyFilings(AbstractFiling): ownership="include", match_format="ALL", kwargs): - # Leave params before other setters self._params = { "action": "getcompany", "output": "xml", - "owner": ownership, - "start": 0, + "start": 0 } self.start_date = start_date self.end_date = end_date @@ -123,6 +121,7 @@ class CompanyFilings(AbstractFiling): self._client = client or NetworkClient(user_agent=user_agent, kwargs) # make CIKLookup object for users if not given self.cik_lookup = cik_lookup + self.ownership = ownership @property def path(self): @@ -132,6 +131,17 @@ class CompanyFilings(AbstractFiling): @property def params(self): """:obj:`dict`: Parameters to include in requests.""" + if self.start_date: + self._params["datea"] = sanitize_date(self.start_date) + else: + self._params.pop("datea", None) # if no start date, make sure it isn't in params + + if self.end_date: + self._params["dateb"] = sanitize_date(self.end_date) + else: + self._params.pop("dateb", None) # if no end date, make sure it isn't in params + + self._params["ownership"] = self.ownership return self._params @property @@ -151,18 +161,14 @@ class CompanyFilings(AbstractFiling): @match_format.setter def match_format(self, val): - if val in ["EXACT", "AMEND", "ALL"]: - self._match_format = val - else: - raise ValueError("Format must be one of EXACT,AMEND,ALL") + if val not in ("EXACT", "AMEND", "ALL"): + raise ValueError("Format must be 'EXACT', 'AMEND', or 'ALL'.") + self._match_format = val @start_date.setter def start_date(self, val): - if val is not None: - self._params["datea"] = sanitize_date(val) - self._start_date = val - else: - self._start_date = None + sanitize_date(val) # make sure start date is valid + self._start_date = val @property def end_date(self): @@ -171,7 +177,7 @@ class CompanyFilings(AbstractFiling): @end_date.setter def end_date(self, val): - self._params["dateb"] = sanitize_date(val) + sanitize_date(val) # make sure end date is valid self._end_date = val @property @@ -184,7 +190,9 @@ class CompanyFilings(AbstractFiling): if isinstance(filing_type, FilingType): self._params["type"] = filing_type.value elif filing_type is not None: - raise FilingTypeError + raise FilingTypeError( + f"filing_type must be of type FilingType. Given {type(filing_type)}." + ) self._filing_type = filing_type @property @@ -215,6 +223,17 @@ class CompanyFilings(AbstractFiling): val = CIKLookup(val, client=self.client) self._cik_lookup = val + @property + def ownership(self): + """str: Whether or not to include ownership in search.""" + return self._ownership + + @ownership.setter + def ownership(self, val): + if val not in ("include", "exclude"): + raise ValueError(f"Ownership must be 'include' or 'exclude'. Given {val}.") + self._ownership = val + def get_urls(self, **kwargs): """Get urls for all CIKs given to Filing object.	sec-edgar/sec-edgar	d210e7d340863d14f862866786e6ca28194bed81	diff --git a/secedgar/tests/core/test_company.py b/secedgar/tests/core/test_company.py index 238cfe9..744e8e7 100644 --- a/secedgar/tests/core/test_company.py +++ b/secedgar/tests/core/test_company.py @@ -72,6 +72,24 @@ def mock_single_cik_filing_limited_responses(monkeypatch): class TestCompanyFilings: + valid_dates = [ + datetime.datetime(2020, 1, 1), + datetime.datetime(2020, 2, 1), + datetime.datetime(2020, 3, 1), + datetime.datetime(2020, 4, 1), + datetime.datetime(2020, 5, 1), + "20200101", + 20200101, + None + ] + bad_dates = [ + 1, + 2020010101, + "2020010101", + "2020", + "0102" + ] + class TestCompanyFilingsClient: def test_user_agent_client_none(self): @@ -114,13 +132,7 @@ class TestCompanyFilings: count=count) assert filing.count == count - @pytest.mark.parametrize("start_date", [ - datetime.datetime(2020, 1, 1), - datetime.datetime(2020, 2, 1), - datetime.datetime(2020, 3, 1), - datetime.datetime(2020, 4, 1), - datetime.datetime(2020, 5, 1), "20200101", 20200101, None - ]) + @pytest.mark.parametrize("start_date", valid_dates) def test_good_start_date_setter_on_init(self, start_date, mock_user_agent): filing = CompanyFilings( cik_lookup="aapl", @@ -129,8 +141,7 @@ class TestCompanyFilings: user_agent=mock_user_agent) assert filing.start_date == start_date - @pytest.mark.parametrize("bad_start_date", - [1, 2020010101, "2020010101", "2020", "0102"]) + @pytest.mark.parametrize("bad_start_date", bad_dates) def test_bad_start_date_setter_on_init(self, mock_user_agent, bad_start_date): with pytest.raises(TypeError): CompanyFilings(user_agent=mock_user_agent, @@ -138,6 +149,23 @@ class TestCompanyFilings: filing_type=FilingType.FILING_10Q, start_date=bad_start_date) + @pytest.mark.parametrize("end_date", valid_dates) + def test_good_end_date_setter_on_init(self, end_date, mock_user_agent): + filing = CompanyFilings( + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + end_date=end_date, + user_agent=mock_user_agent) + assert filing.end_date == end_date + + @pytest.mark.parametrize("bad_end_date", bad_dates) + def test_bad_end_date_setter_on_init(self, mock_user_agent, bad_end_date): + with pytest.raises(TypeError): + CompanyFilings(user_agent=mock_user_agent, + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + end_date=bad_end_date) + @pytest.mark.parametrize("count,expected_error", [(-1, ValueError), (0, ValueError), (0.0, TypeError), @@ -325,7 +353,6 @@ class TestCompanyFilings: my_filings.save(tmp_data_directory) def test__filter_filing_links(self, mock_user_agent, mock_single_cik_filing): - # data = f = CompanyFilings(cik_lookup="aapl", filing_type=FilingType.FILING_10Q, user_agent=mock_user_agent) @@ -333,3 +360,85 @@ class TestCompanyFilings: links = f._filter_filing_links(data) assert len(links) == 10 assert all(["BAD_LINK" not in link for link in links]) + + def test_same_urls_fetched(self, mock_user_agent, mock_single_cik_filing): + # mock_single_filing_cik has more than 10 URLs + # using count = 5 should help test whether the same URLs + # are fetched each time + f = CompanyFilings(cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + user_agent=mock_user_agent, + count=5) + first_urls = f.get_urls() + second_urls = f.get_urls() + assert all(f == s for f, s in zip(first_urls, second_urls)) + + @pytest.mark.parametrize( + "bad_ownership", + [ + "notright", + "_exclude", + "_include", + "notvalid", + 1, + True, + False + ] + ) + def test_ownership(self, bad_ownership, mock_user_agent): + with pytest.raises(ValueError): + CompanyFilings( + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + user_agent=mock_user_agent, + ownership=bad_ownership + ) + + def test_good_ownership(self, mock_user_agent): + shared_params = dict( + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + user_agent=mock_user_agent, + ) + f_include = CompanyFilings( + shared_params, + ownership="include" + ) + f_exclude = CompanyFilings( + shared_params, + ownership="exclude" + ) + assert f_include.ownership == "include" + assert f_exclude.ownership == "exclude" + + # Change ownership type + f_include.ownership = "exclude" + assert f_include.ownership == "exclude" + + def test_start_date_change_to_none(self, mock_user_agent): + start_date = datetime.date(2020, 1, 1) + f = CompanyFilings( + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + user_agent=mock_user_agent, + start_date=start_date + ) + assert f.start_date == start_date + assert f.params["datea"] == "20200101" + f.start_date = None + assert f.start_date is None + assert "datea" not in f.params + + def test_end_date_change_to_none(self, mock_user_agent): + end_date = datetime.date(2020, 1, 1) + f = CompanyFilings( + cik_lookup="aapl", + filing_type=FilingType.FILING_10Q, + user_agent=mock_user_agent, + end_date=end_date + ) + assert f.end_date == end_date + assert f.params["dateb"] == "20200101" + f.end_date = None + assert f.end_date is None + assert "dateb" not in f.params	Count/params not resetting after `get_urls` Describe the bug `CompanyFilings` not resetting start parameter after using `get_urls` method. To Reproduce ```python from secedgar.core.company import CompanyFilings a = CompanyFilings(cik_lookup='aapl', start_date=datetime(2021,2,28)) print(a.params) first_urls = a.get_urls() # returns urls print(a.params) second_urls = a.get_urls() # Will not return same urls as first_urls ``` Expected behavior Should reset start parameter after while loop.	d210e7d340863d14f862866786e6ca28194bed81	[ "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[notright]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[_exclude]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[_include]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[notvalid]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[False]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_ownership", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_start_date_change_to_none", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_change_to_none" ]	[ "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_user_agent_client_none", "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_user_agent_set_to_client", "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_client_property_set", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_returns_exact", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[5]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[10]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[15]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[27]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[33]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date2]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date3]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date4]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[20200101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[20200101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020010101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020010101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[0102]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date2]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date3]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date4]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[20200101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[20200101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020010101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020010101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[0102]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[-1-ValueError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[0-ValueError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[0.0-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[1.0-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[1-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_date_is_sanitized", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_date_is_sanitized_when_changed", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[20120101-20120101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[20120101-20120101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[date2-20120101]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_txt_urls", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_10K]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_8K]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_13FHR]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_SD]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10-k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10-q]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10q]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[123]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[10-j]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[10-k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[ssd]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[invalid]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[1234567891011]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[12345]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[123.0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_save_no_filings_raises_error[no_urls0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_save_no_filings_raises_error[no_urls1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_multiple_ciks", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_single_cik", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_get_urls_returns_single_list_of_urls", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[10]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[25]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[30]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[20-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[30-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[40-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test__filter_filing_links", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_same_urls_fetched" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-12-05 16:04:32+00:00	apache-2.0	5,453
sec-edgar__sec-edgar-254	diff --git a/docs/source/parser.rst b/docs/source/parser.rst index a13e72b..d684367 100644 --- a/docs/source/parser.rst +++ b/docs/source/parser.rst @@ -16,4 +16,9 @@ Parsing Meta Data ----------------- .. autoclass:: secedgar.parser.MetaParser + :members: + +Parsing Form 4 Data + +.. autoclass:: secedgar.parser.F4Parser :members: \ No newline at end of file diff --git a/secedgar/parser.py b/secedgar/parser.py index bbb0a4c..cd3cb6b 100644 --- a/secedgar/parser.py +++ b/secedgar/parser.py @@ -4,8 +4,26 @@ import os import re import uu +from secedgar.exceptions import FilingTypeError from secedgar.utils import make_path +value_pattern = r"<value>(.?)</value>" +non_derivative_trans_pattern = r"<nonDerivativeTransaction>(.?)</nonDerivativeTransaction>" +sec_title_pattern = r"<securityTitle>(.?)</securityTitle>" +trans_date_pattern = r"<transactionDate>(.?)</transactionDate>" +trans_shares_pattern = r"<transactionShares>(.?)</transactionShares>" +trans_pps_pattern = r"<transactionPricePerShare>(.?)</transactionPricePerShare>" +trans_disp_code_pattern = ( + r"<transactionAcquiredDisposedCode>" + r"(.?)" + r"</transactionAcquiredDisposedCode>" + ) +soft_pattern = r"<sharesOwnedFollowingTransaction>(.?)</sharesOwnedFollowingTransaction>" +doio_pattern = r"<directOrIndirectOwnership>(.?)</directOrIndirectOwnership>" +trans_form_type_pattern = r"<transactionFormType>(.?)</transactionFormType>" +trans_code_pattern = r"<transactionCode>(.?)</transactionCode>" +equity_swap_involved_pattern = r"<equitySwapInvolved>(.?)</equitySwapInvolved>" + class MetaParser: """Utility class to extract metadata and documents from a single text file. @@ -203,6 +221,7 @@ class MetaParser: Return: dict: Dictionary with fields parsed from document. + """ metadata_doc = {} @@ -221,3 +240,100 @@ class MetaParser: metadata_doc["filename"] = fn_m.group(1) return metadata_doc + + +class F4Parser: + """Utility class to extract actionable data and documents from a single text file. + + .. warning:: + The ``F4Parser`` class is still experimental. Use with caution. + + .. versionadded:: 0.4.0 + """ + + @staticmethod + def process(doc): + """Process the actionable data of the document. + + Args: + doc (str): Document from which to extract core data. + + Return: + data (dict): Tradable buy/sell/gift data from document. + + """ + metadata = MetaParser.process_document_metadata(doc) + + if metadata["type"] == "4": + # Regex find all nested values. + def nested_findall(parent_pattern, doc, child_pattern=value_pattern): + matches = [ + re.search(child_pattern, match).group(1) + for match + in re.findall(parent_pattern, doc, re.S)] + return matches + + # Find core data from document. + security_title_matches = nested_findall(sec_title_pattern, doc) + trans_date_matches = nested_findall(trans_date_pattern, doc) + trans_shares_matches = nested_findall(trans_shares_pattern, doc) + trans_pps_matches = nested_findall(trans_pps_pattern, doc) + trans_disp_code_matches = nested_findall(trans_disp_code_pattern, doc) + soft_matches = nested_findall(soft_pattern, doc) + doio_matches = nested_findall(doio_pattern, doc) + trans_form_matches = re.findall(trans_form_type_pattern, doc) + trans_code_matches = re.findall(trans_code_pattern, doc) + equity_swap_matches = re.findall(equity_swap_involved_pattern, doc) + + # Map core data to dict + data = { + "nonDerivativeTable": { + "nonDerivativeTransaction": [ + { + "securityTitle": securityTitle, + "transactionDate": transactionDate, + "transactionCoding": { + "transactionFormType": transactionFormType, + "transactionCode": transactionCode, + "equitySwapInvolved": equitySwapInvolved + }, + "transactionAmounts": { + "transactionShares": transactionShares, + "transactionPricePerShare": transactionPricePerShare, + "transactionAcquiredDisposedCode": transactionAcquiredDisposedCode + }, + "postTransactionAmounts": { + "sharesOwnedFollowingTransaction": sharesOwnedFollowingTransaction + }, + "ownershipNature": { + "directOrIndirectOwnership": directOrIndirectOwnership + } + } + for securityTitle, + transactionDate, + transactionFormType, + transactionCode, + equitySwapInvolved, + transactionShares, + transactionPricePerShare, + transactionAcquiredDisposedCode, + sharesOwnedFollowingTransaction, + directOrIndirectOwnership + in zip( + security_title_matches, + trans_date_matches, + trans_form_matches, + trans_code_matches, + equity_swap_matches, + trans_shares_matches, + trans_pps_matches, + trans_disp_code_matches, + soft_matches, + doio_matches + ) + ] + } + } + return data + else: + raise FilingTypeError	sec-edgar/sec-edgar	42f32806c1d3d0c73b27bcc3762d8bb0f32f0398	diff --git a/secedgar/tests/test_parser.py b/secedgar/tests/test_parser.py index 6528f8a..a6407d3 100644 --- a/secedgar/tests/test_parser.py +++ b/secedgar/tests/test_parser.py @@ -1,5 +1,5 @@ import pytest -from secedgar.parser import MetaParser +from secedgar.parser import F4Parser, MetaParser class TestParser: @@ -26,3 +26,136 @@ class TestParser: def test_bad_filetypes_raises_error(self, bad_filetype): with pytest.raises(ValueError): self.parser.process(infile="test.{0}".format(bad_filetype)) + + +class TestF4Parser: + + parser = F4Parser() + + def test_process_document_metadata_form_4(self): + doc = """<TYPE>4 + <SEQUENCE>123 + <FILENAME>test-filename.txt + <nonDerivativeTable> + <nonDerivativeTransaction> + <securityTitle> + <value>Common Stock</value> + </securityTitle> + <transactionDate> + <value>2021-05-14</value> + </transactionDate> + <transactionCoding> + <transactionFormType>5</transactionFormType> + <transactionCode>G</transactionCode> + <equitySwapInvolved>0</equitySwapInvolved> + </transactionCoding> + <transactionTimeliness> + <value>E</value> + </transactionTimeliness> + <transactionAmounts> + <transactionShares> + <value>4010</value> + </transactionShares> + <transactionPricePerShare> + <value>0</value> + </transactionPricePerShare> + <transactionAcquiredDisposedCode> + <value>D</value> + </transactionAcquiredDisposedCode> + </transactionAmounts> + <postTransactionAmounts> + <sharesOwnedFollowingTransaction> + <value>324164</value> + </sharesOwnedFollowingTransaction> + </postTransactionAmounts> + <ownershipNature> + <directOrIndirectOwnership> + <value>D</value> + </directOrIndirectOwnership> + </ownershipNature> + </nonDerivativeTransaction> + <nonDerivativeTransaction> + <securityTitle> + <value>Common Stock</value> + <footnoteId id="F1"/> + </securityTitle> + <transactionDate> + <value>2021-08-02</value> + </transactionDate> + <transactionCoding> + <transactionFormType>4</transactionFormType> + <transactionCode>S</transactionCode> + <equitySwapInvolved>0</equitySwapInvolved> + </transactionCoding> + <transactionAmounts> + <transactionShares> + <value>15600</value> + </transactionShares> + <transactionPricePerShare> + <value>145.83</value> + <footnoteId id="F2"/> + </transactionPricePerShare> + <transactionAcquiredDisposedCode> + <value>D</value> + </transactionAcquiredDisposedCode> + </transactionAmounts> + <postTransactionAmounts> + <sharesOwnedFollowingTransaction> + <value>308564</value> + </sharesOwnedFollowingTransaction> + </postTransactionAmounts> + <ownershipNature> + <directOrIndirectOwnership> + <value>D</value> + </directOrIndirectOwnership> + </ownershipNature> + </nonDerivativeTransaction> + </nonDerivativeTable> + """ + data = self.parser.process(doc) + assert data == { + "nonDerivativeTable": { + "nonDerivativeTransaction": [ + { + "securityTitle": "Common Stock", + "transactionDate": "2021-05-14", + "transactionCoding": { + "transactionFormType": "5", + "transactionCode": "G", + "equitySwapInvolved": "0" + }, + "transactionAmounts": { + "transactionShares": "4010", + "transactionPricePerShare": "0", + "transactionAcquiredDisposedCode": "D" + }, + "postTransactionAmounts": { + "sharesOwnedFollowingTransaction": "324164" + }, + "ownershipNature": { + "directOrIndirectOwnership": "D" + } + }, + { + "securityTitle": "Common Stock", + "transactionDate": "2021-08-02", + "transactionCoding": { + "transactionFormType": "4", + "transactionCode": "S", + "equitySwapInvolved": "0" + }, + "transactionAmounts": { + "transactionShares": "15600", + "transactionPricePerShare": "145.83", + "transactionAcquiredDisposedCode": "D" + }, + "postTransactionAmounts": { + "sharesOwnedFollowingTransaction": "308564" + }, + "ownershipNature": { + "directOrIndirectOwnership": "D" + } + } + ] + } + }	Form 4 Parser Is your feature request related to a problem? Please describe. Insider trading information has become a hot commodity for retail investors. The parser does not currently extract pertinent data on buying and selling of securities by insiders. Describe the solution you'd like Add a function to the parser to extract non-derivative transaction information pertinent to retail investors intending to track trades of insiders. Describe alternatives you've considered All other alternatives are closed-source/proprietary and paid. Additional context No additional context.	42f32806c1d3d0c73b27bcc3762d8bb0f32f0398	[ "secedgar/tests/test_parser.py::TestParser::test_process_document_metadata", "secedgar/tests/test_parser.py::TestParser::test_bad_filetypes_raises_error[xml]", "secedgar/tests/test_parser.py::TestParser::test_bad_filetypes_raises_error[json]", "secedgar/tests/test_parser.py::TestParser::test_bad_filetypes_raises_error[html]", "secedgar/tests/test_parser.py::TestParser::test_bad_filetypes_raises_error[txt.gz]", "secedgar/tests/test_parser.py::TestParser::test_bad_filetypes_raises_error[zip]", "secedgar/tests/test_parser.py::TestF4Parser::test_process_document_metadata_form_4" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-12-18 03:36:03+00:00	apache-2.0	5,454
sec-edgar__sec-edgar-274	diff --git a/docs/source/index.rst b/docs/source/index.rst index 776f001..a3b7971 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -16,6 +16,7 @@ Welcome to secedgar's documentation! ciklookup filings filingtypes + rest_api cikmap client parser diff --git a/docs/source/rest_api.rst b/docs/source/rest_api.rst new file mode 100644 index 0000000..fdb2961 --- /dev/null +++ b/docs/source/rest_api.rst @@ -0,0 +1,24 @@ +.. _rest_api: + +REST API +======== + +The SEC recently released an API which can be used to more easily access data on companies. +For a complete overview of the API, you can +`read more here <https://www.sec.gov/edgar/sec-api-documentation>`_. + + +Wrapper +------- + +In order to make this information even easier to extract, ``secedgar`` contains functions that +wrap around the EDGAR API to make the data even more accessible. Below are the functions available +via ``secedgar``. + +.. autofunction:: secedgar.core.rest.get_submissions + +.. autofunction:: secedgar.core.rest.get_company_concepts + +.. autofunction:: secedgar.core.rest.get_company_facts + +.. autofunction:: secedgar.core.rest.get_xbrl_frames \ No newline at end of file diff --git a/docs/source/whatsnew.rst b/docs/source/whatsnew.rst index bbe2b34..1673705 100644 --- a/docs/source/whatsnew.rst +++ b/docs/source/whatsnew.rst @@ -6,6 +6,10 @@ What's New New features, bug fixes, and improvements for each release. +.. include:: whatsnew/v0.5.0.rst + +.. include:: whatsnew/v0.4.1.rst + .. include:: whatsnew/v0.4.0.rst .. include:: whatsnew/v0.3.4.rst diff --git a/docs/source/whatsnew/v0.5.0.rst b/docs/source/whatsnew/v0.5.0.rst new file mode 100644 index 0000000..b4f1550 --- /dev/null +++ b/docs/source/whatsnew/v0.5.0.rst @@ -0,0 +1,14 @@ +v0.5.0 +------ + +Highlights +~~~~~~~~~~ + +- Add access to SEC's REST API via ``secedgar.core.rest`` module +- New functions include ``get_submissions``, ``get_company_concepts``, ``get_company_facts``, and ``get_xbrl_frames``. +- Set ``client`` keyword arg to ``None`` by default for ``CIKLookup``. This will create client object automatically instead of requiring user to provide client. + +Contributors +~~~~~~~~~~~~ + +- jackmoody11 \ No newline at end of file diff --git a/secedgar/__init__.py b/secedgar/__init__.py index 89c9884..ca7abca 100644 --- a/secedgar/__init__.py +++ b/secedgar/__init__.py @@ -1,4 +1,4 @@ -__version__ = '0.4.1' +__version__ = '0.5.0' from secedgar.core.combo import ComboFilings # noqa: F401 from secedgar.core.company import CompanyFilings # noqa: F401 diff --git a/secedgar/cik_lookup.py b/secedgar/cik_lookup.py index 4b51964..167d522 100644 --- a/secedgar/cik_lookup.py +++ b/secedgar/cik_lookup.py @@ -43,13 +43,19 @@ class CIKLookup: Args: lookup (Union[str, list]): Ticker, company name, or list of tickers and/or company names. - client (secedgar.client.NetworkClient): A network client object to use. See - :class:`secedgar.client.NetworkClient` for more details. + client (Union[None, secedgar.client.NetworkClient]): A network client object to use. + If ``None`` is given, then will pass kwargs to :class:`secedgar.client.NetworkClient`. + See :class:`secedgar.client.NetworkClient` for more details. Defaults to ``None``. + + .. warning:: + + If ``None`` is passed to client, you must specify your ``user_agent`` in ``kwargs``. + For example, ``CIKLookup(lookup=["aapl"], user_agent="Name ([email protected]")``. .. versionadded:: 0.1.5 """ - def __init__(self, lookups, client, kwargs): + def __init__(self, lookups, client=None, kwargs): if lookups and isinstance(lookups, str): self._lookups = [lookups] # make single string into list else: diff --git a/secedgar/core/rest.py b/secedgar/core/rest.py new file mode 100644 index 0000000..766e406 --- /dev/null +++ b/secedgar/core/rest.py @@ -0,0 +1,205 @@ +from typing import List, Union + +import requests + +from secedgar.cik_lookup import CIKLookup + +API_BASE = "https://data.sec.gov/api/" +XBRL_BASE = "{0}xbrl/".format(API_BASE) + + +def _get_lookup_dict(lookups: List[str], user_agent: str): + """Utility function to get CIKs for lookups. + + Args: + lookups (list of str): List of tickers or company names to get CIKs for. + user_agent (str): User agent to give to SEC. + + Returns: + dict: Dictionary with lookup and CIK key-value pairs. + """ + cik_lookup = CIKLookup(lookups=lookups, + user_agent=user_agent, + client=None) + return cik_lookup.lookup_dict + + +def _combine_dicts(dicts): + """Utility function to combine dictionary values when values are lists. + + Returns: + dict: Dictionaries combined into one. + + Examples: + >>> a = {"A": [1, 2, 3], "B": [4, 5, 6]} + >>> b = {"A": [7, 8], "B": [0, 1, 2]} + >>> _combine_dicts(a, b) + {'A': [1, 2, 3, 7, 8], 'B': [4, 5, 6, 0, 1, 2]} + >>> _combine_dicts(a) + {'A': [1, 2, 3], 'B': [4, 5, 6]} + """ + final = {} + for d in dicts: + for k, v in d.items(): + if k in final: + final[k] += v + else: + final[k] = v + return final + + +def get_submissions(lookups: Union[List[str], str], + user_agent: str, + recent: bool = True) -> dict: + """Get information about submissions for entities. + + Args: + lookups (list of str or str): Tickers or CIKs to get submission data for. + user_agent (str): User agent to provide the SEC. + recent (bool, optional): Whether or not to only get the most recent. + Setting ``recent`` to True will give at least one year of filings or 1000 filings + (whichever is more). Setting ``recent`` to False will return all filings. + Defaults to True. + + Returns: + dict: Dictionary with keys being the lookups and values being the responses from the API. + """ + lookup_dict = _get_lookup_dict(lookups=lookups, user_agent=user_agent) + submissions_dict = dict() + url_base = "https://data.sec.gov/submissions/" + for lookup, cik in lookup_dict.items(): + resp = requests.get("{0}CIK{1}.json".format(url_base, cik.zfill(10)), + headers={"user-agent": user_agent}) + resp_json = resp.json() + if not recent: + try: + older_submission_files = resp_json["filings"]["files"] + except KeyError: + pass + + # Get data for older submission files and add to recent + older_submissions = [requests.get("{0}{1}".format(url_base, f["name"]), + headers={"user-agent": user_agent}).json() + for f in older_submission_files] + + resp_json["filings"]["recent"] = _combine_dicts(resp_json["filings"]["recent"], + older_submissions) + submissions_dict[lookup] = resp_json + return submissions_dict + + +def get_company_concepts(lookups: Union[List[str], str], + user_agent: str, + concept_name: str) -> dict: + """Get company concepts using SEC's REST API. + + Args: + lookups (list of str or str): Tickers or CIKs to get concepts for. + user_agent (str): User agent to send to SEC. + concept_name (str): Name of the concept to get data for. + + Returns: + dict: Dictionary with concept data for given lookups. + + Example: + .. code:: + + concept = "AccountsPayableCurrent" + get_company_concepts(lookups=["AAPL"], + user_agent="Name ([email protected])", + concept_name=concept) + """ + lookup_dict = _get_lookup_dict(lookups=lookups, user_agent=user_agent) + company_concepts = dict() + for lookup, cik in lookup_dict.items(): + url = "{0}companyconcept/CIK{1}/us-gaap/{2}.json".format( + XBRL_BASE, + cik.zfill(10), + concept_name + ) + resp = requests.get(url, + headers={"user-agent": user_agent}) + company_concepts[lookup] = resp.json() + return company_concepts + + +def get_company_facts(lookups: Union[List[str], str], user_agent: str) -> dict: + """Get company facts for lookups. + + Args: + lookups (list of str or str): Tickers or CIKs to get company facts for. + user_agent (str): User agent to send to SEC. + + Returns: + dict: Dictionary with lookups as keys and company fact dictionaries as values. + + Examples: + >>> facts = get_company_facts(["aapl"], "Name ([email protected])") + >>> single_fact = facts["aapl"]["facts"]["us-gaap"]["Assets"]["units"]["USD"][0] + >>> single_fact["val"] + 39572000000 + >>> single_fact["fy"] + 2009 + >>> single_fact["fp"] + Q3 + >>> single_fact["form"] + '10-Q' + >>> single_fact["filed"] + '2009-07-22' + """ + lookup_dict = _get_lookup_dict(lookups=lookups, user_agent=user_agent) + company_facts = dict() + for lookup, cik in lookup_dict.items(): + url = "{0}companyfacts/CIK{1}.json".format(XBRL_BASE, cik.zfill(10)) + resp = requests.get(url, headers={"user-agent": user_agent}) + company_facts[lookup] = resp.json() + return company_facts + + +def get_xbrl_frames(user_agent: str, + concept_name: str, + year: int, + quarter: Union[None, int] = None, + currency: str = "USD", + instantaneous: bool = False) -> dict: + """Get data for concept name in year (and quarter, if given). + + Args: + user_agent (str): User agent to send to the SEC. + concept_name (str): Concept name to get. For example, "Assets". + year (int): Year to get concept data for. + quarter (Union[int, NoneType], optional): Quarter to get data for. If given None, + will look for data for the entire year. Defaults to None. + instantaneous (bool, optional): Whether to look for instantaneous data. + See `SEC website for more <https://www.sec.gov/edgar/sec-api-documentation>`_. + Defaults to False. + + Returns: + dict: Dictionary with information about concept_name. + Dig into the data key for all period data. + + Examples: + .. code:: + + frames = get_xbrl_frames(user_agent="Name ([email protected])", + concept_name="Assets", + year=2020, + quarter=3, + instantaneous=True) + print(frames["data"][-1]["entityName"]) + # Prints "MOXIAN (BVI) INC" + print(frames["data"][-1]["val"]) + # Prints 2295657 + print(frames["data"][-1]["accn"]) + # Prints "0001493152-22-013323" + """ + # Create URL + period = "CY{0}".format(year) if quarter is None else "CY{0}Q{1}".format(year, quarter) + if instantaneous: + period += "I" + url = "{0}frames/us-gaap/{1}/{2}/{3}.json".format(XBRL_BASE, concept_name, currency, period) + print(url) + # Request and add to dictionary + resp = requests.get(url, headers={"user-agent": user_agent}) + xbrl_frames = resp.json() + return xbrl_frames	sec-edgar/sec-edgar	dfbca033a65a38614094c4386fa83ee29b0d9799	diff --git a/secedgar/tests/core/test_company.py b/secedgar/tests/core/test_company.py index ec7e80c..26c1375 100644 --- a/secedgar/tests/core/test_company.py +++ b/secedgar/tests/core/test_company.py @@ -3,6 +3,7 @@ import datetime import os import pytest + from secedgar.cik_lookup import CIKLookup from secedgar.client import NetworkClient from secedgar.core import CompanyFilings, FilingType @@ -291,6 +292,45 @@ class TestCompanyFilings: f.save(tmp_data_directory) assert len(os.listdir(tmp_data_directory)) > 0 + @pytest.mark.parametrize( + "match_format", + [ + "EXACT", + "AMEND", + "ALL" + ] + ) + def test_match_format_good(self, mock_user_agent, match_format): + f = CompanyFilings(["aapl", "amzn", "msft"], + FilingType.FILING_10Q, + user_agent=mock_user_agent, + count=3, + match_format=match_format) + + assert f.match_format == match_format + + @pytest.mark.parametrize( + "match_format", + [ + "exact", + "amend", + "all", + "none", + None, + True, + False, + 1, + 0 + ] + ) + def test_match_format_bad(self, mock_user_agent, match_format): + with pytest.raises(ValueError): + CompanyFilings(["aapl", "amzn", "msft"], + FilingType.FILING_10Q, + user_agent=mock_user_agent, + count=3, + match_format=match_format) + @pytest.mark.smoke def test_filing_save_multiple_ciks_smoke(self, tmp_data_directory, real_test_client): diff --git a/secedgar/tests/core/test_rest.py b/secedgar/tests/core/test_rest.py new file mode 100644 index 0000000..743763f --- /dev/null +++ b/secedgar/tests/core/test_rest.py @@ -0,0 +1,104 @@ +import pytest + +from secedgar.core.rest import (_combine_dicts, get_company_concepts, + get_company_facts, get_submissions, + get_xbrl_frames) + + +class TestRest: + @pytest.mark.parametrize("dicts,expected", + [ + ([{"A": [1, 2, 3], "B": [4, 5, 6]}, + {"A": [7, 8], "B": [0, 1, 2]}], + {'A': [1, 2, 3, 7, 8], 'B': [4, 5, 6, 0, 1, 2]}), + ([{"A": [1, 2, 3]}, + {"B": [4, 5, 6]}], + {"A": [1, 2, 3], "B": [4, 5, 6]}), + ([{"A": [1]}], + {"A": [1]}) + ] + ) + def test__combine_dicts(self, dicts, expected): + assert _combine_dicts(*dicts) == expected + + @pytest.mark.parametrize( + "recent", + [True, False] + ) + @pytest.mark.smoke + def test_get_submissions(self, mock_user_agent, recent): + submissions = get_submissions(lookups=["aapl"], + user_agent=mock_user_agent, + recent=recent) + assert submissions + # Make sure Apple's CIK shows up properly + assert str(submissions["aapl"]["cik"]) == "320193" + + # Make sure there are accession numbers + assert submissions["aapl"]["filings"]["recent"]["accessionNumber"] + + # Result should be dictionary + assert isinstance(submissions, dict) + + @pytest.mark.smoke + def test_get_company_concepts(self, mock_user_agent): + concept = "AccountsPayableCurrent" + concepts = get_company_concepts(lookups=["AAPL"], + user_agent=mock_user_agent, + concept_name=concept) + assert concepts + # Ensure CIK is correct + assert str(concepts["AAPL"]["cik"]) == "320193" + + # Make sure that there are results for accounts payable + assert concepts["AAPL"]["units"]["USD"] + + # Result should be dictionary + assert isinstance(concepts, dict) + + @pytest.mark.smoke + def test_get_company_facts(self, mock_user_agent): + facts = get_company_facts(lookups=["aapl"], user_agent=mock_user_agent) + + assert facts + # Ensure CIK is correct - sometimes will give number, so cast to string + assert str(facts["aapl"]["cik"]) == "320193" + + # Make sure there are facts + assert facts["aapl"]["facts"] + + # Make sure that us-gaap and dei both are keys + assert "us-gaap" in facts["aapl"]["facts"] + assert "dei" in facts["aapl"]["facts"] + + # Make sure we can get Revenues for Apple + assert facts["aapl"]["facts"]["us-gaap"]["Revenues"]["units"]["USD"] + + # Result should be dictionary + assert isinstance(facts, dict) + + @pytest.mark.smoke + @pytest.mark.parametrize( + "concept,instantaneous", + [ + ("Revenues", False), + ("Revenues", True) + ] + ) + def test_get_xbrl_frames(self, mock_user_agent, concept, instantaneous): + frames = get_xbrl_frames(user_agent=mock_user_agent, + concept_name=concept, + year=2020, + quarter=1, + instantaneous=instantaneous) + # Check to make sure we got the right frame + assert frames["tag"] == concept + + # Make sure there is data + assert frames["data"] + + # Data should have accn and cik as keys + assert "accn" in frames["data"][0] + assert "cik" in frames["data"][0] + + assert isinstance(frames, dict) diff --git a/secedgar/tests/test_cik_lookup.py b/secedgar/tests/test_cik_lookup.py index 165c229..5587ac8 100644 --- a/secedgar/tests/test_cik_lookup.py +++ b/secedgar/tests/test_cik_lookup.py @@ -235,3 +235,8 @@ class TestCIKLookup(object): cik_map = get_cik_map() assert "ticker" in cik_map and "title" in cik_map assert cik_map["ticker"] and cik_map["title"] + + def test_cik_lookup_client_none(self, ticker_lookups, mock_user_agent): + lookup = CIKLookup(lookups=ticker_lookups, user_agent=mock_user_agent, client=None) + assert isinstance(lookup.client, NetworkClient) + assert lookup.lookups == ticker_lookups	Add compatibility with EDGAR APIs Is your feature request related to a problem? Please describe. The SEC is currently offering a RESTful API in beta! See more [here](https://www.sec.gov/edgar/sec-api-documentation). Not sure exactly what the best way to integrate this into the package would be, but want to put it out there so that it can be discussed. Describe the solution you'd like Not sure yet. Add an api package that provides utilities to easily access the API? Should be able to reuse `NetworkClient` code.	dfbca033a65a38614094c4386fa83ee29b0d9799	[ "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_user_agent_client_none", "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_user_agent_set_to_client", "secedgar/tests/core/test_company.py::TestCompanyFilings::TestCompanyFilingsClient::test_client_property_set", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_returns_exact", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[5]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[10]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[15]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[27]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_on_init[33]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date2]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date3]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[start_date4]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[20200101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[20200101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_start_date_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020010101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020010101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[2020]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_start_date_setter_on_init[0102]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date2]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date3]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[end_date4]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[20200101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[20200101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_end_date_setter_on_init[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020010101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020010101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[2020]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_end_date_setter_on_init[0102]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[-1-ValueError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[0-ValueError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[0.0-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[1.0-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_count_setter_bad_values[1-TypeError]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_date_is_sanitized", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_date_is_sanitized_when_changed", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[20120101-20120101_0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[20120101-20120101_1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_setter[date2-20120101]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_txt_urls", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_10K]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_8K]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_13FHR]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_type_setter[FilingType.FILING_SD]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10-k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10-q]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[10q]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_bad_filing_type_setter[123]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[10-j]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[10-k]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[ssd]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[invalid]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_invalid_filing_type_types[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[1234567891011]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[12345]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_validate_cik_type_inside_filing[123.0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_save_no_filings_raises_error[no_urls0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_save_no_filings_raises_error[no_urls1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_multiple_ciks", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_good[EXACT]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_good[AMEND]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_good[ALL]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[exact]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[amend]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[all]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[none]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[None]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[False]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_match_format_bad[0]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_multiple_ciks_smoke", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_single_cik", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_save_single_cik_smoke", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_get_urls_returns_single_list_of_urls", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[10]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[25]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_returns_correct_number_of_urls[30]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[5-False]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[10-False]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[20-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[30-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filings_warning_lt_count[40-True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_filing_simple_example_smoke", "secedgar/tests/core/test_company.py::TestCompanyFilings::test__filter_filing_links", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_same_urls_fetched", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[notright]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[_exclude]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[_include]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[notvalid]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[1]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[True]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_ownership[False]", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_good_ownership", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_start_date_change_to_none", "secedgar/tests/core/test_company.py::TestCompanyFilings::test_end_date_change_to_none", "secedgar/tests/core/test_rest.py::TestRest::test__combine_dicts[dicts0-expected0]", "secedgar/tests/core/test_rest.py::TestRest::test__combine_dicts[dicts1-expected1]", "secedgar/tests/core/test_rest.py::TestRest::test__combine_dicts[dicts2-expected2]", "secedgar/tests/core/test_rest.py::TestRest::test_get_xbrl_frames[Revenues-False]", "secedgar/tests/core/test_rest.py::TestRest::test_get_xbrl_frames[Revenues-True]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup0-expected0]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup1-expected1]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup2-expected2]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup3-expected3]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup4-expected4]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup5-expected5]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup6-expected6]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values[lookup7-expected7]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup0-expected0]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup1-expected1]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup2-expected2]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup3-expected3]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup4-expected4]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup5-expected5]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup6-expected6]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_returns_correct_values_smoke[lookup7-expected7]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_lookups_property", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_multiple_results_company_name_search", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_multiple_results_raises_warnings", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_cik_hits_request", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_cik_bypasses_request", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik__is_string[1234567890]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik__is_string[123.0]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_after_cik_lookup", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_client_property", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_bad_lookups_raises_type_error[bad_lookups0]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_bad_lookups_raises_type_error[]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_bad_lookups_raises_type_error[bad_lookups2]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_lookups_property", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_lookup[]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_lookup[4]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[1234_0]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[1234_1]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[1234567890]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[AAPL]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_validate_cik_on_bad_ciks[None]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_params_reset_after_get_cik", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers[aapl-320193]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers[AMZN-1018724]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers[Msft-789019]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers_smoke[aapl-320193]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers_smoke[AMZN-1018724]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_tickers_smoke[Msft-789019]", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_company_names[meta", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_company_names[Alphabet", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_company_names_smoke[meta", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_company_names_smoke[Alphabet", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_get_cik_map_smoke", "secedgar/tests/test_cik_lookup.py::TestCIKLookup::test_cik_lookup_client_none" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_added_files", "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2022-05-27 20:52:58+00:00	apache-2.0	5,455
secure-systems-lab__securesystemslib-486	diff --git a/.github/workflows/check-upstream-ed25519.yml b/.github/workflows/check-upstream-ed25519.yml index ce01c30..dee5d60 100644 --- a/.github/workflows/check-upstream-ed25519.yml +++ b/.github/workflows/check-upstream-ed25519.yml @@ -13,7 +13,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out repository - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b + uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - name: Test if ed25519 upstream master HEAD is what we expect id: test_ed25519 run: \| diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 68a022e..fe24767 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,7 +38,7 @@ jobs: steps: - name: Checkout securesystemslib - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b + uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@5ccb29d8773c3f3f653e1705f474dfaa8a06a912 diff --git a/securesystemslib/signer/__init__.py b/securesystemslib/signer/__init__.py index 0b06507..d5c816d 100644 --- a/securesystemslib/signer/__init__.py +++ b/securesystemslib/signer/__init__.py @@ -5,12 +5,12 @@ This module provides extensible interfaces for public keys and signers: Some implementations are provided by default but more can be added by users. """ from securesystemslib.signer._gcp_signer import GCPSigner +from securesystemslib.signer._gpg_signer import GPGSigner from securesystemslib.signer._hsm_signer import HSMSigner from securesystemslib.signer._key import KEY_FOR_TYPE_AND_SCHEME, Key, SSlibKey -from securesystemslib.signer._signature import GPGSignature, Signature +from securesystemslib.signer._signature import Signature from securesystemslib.signer._signer import ( SIGNER_FOR_URI_SCHEME, - GPGSigner, SecretsHandler, Signer, SSlibSigner, diff --git a/securesystemslib/signer/_gpg_signer.py b/securesystemslib/signer/_gpg_signer.py new file mode 100644 index 0000000..6d48b0e --- /dev/null +++ b/securesystemslib/signer/_gpg_signer.py @@ -0,0 +1,75 @@ +"""Signer implementation for OpenPGP """ +from typing import Dict, Optional + +import securesystemslib.gpg.functions as gpg +from securesystemslib.signer._key import Key +from securesystemslib.signer._signer import SecretsHandler, Signature, Signer + + +class GPGSigner(Signer): + """OpenPGP Signer + + Runs command in ``GNUPG`` environment variable to sign, fallback commands are + ``gpg2`` and ``gpg``. + + Supported signing schemes are: "pgp+rsa-pkcsv1.5", "pgp+dsa-fips-180-2" and + "pgp+eddsa-ed25519", with SHA-256 hashing. + + + Arguments: + keyid: GnuPG local user signing key id. If not passed, the default key is used. + homedir: GnuPG home directory path. If not passed, the default homedir is used. + + """ + + def __init__( + self, keyid: Optional[str] = None, homedir: Optional[str] = None + ): + self.keyid = keyid + self.homedir = homedir + + @classmethod + def from_priv_key_uri( + cls, + priv_key_uri: str, + public_key: Key, + secrets_handler: Optional[SecretsHandler] = None, + ) -> "GPGSigner": + raise NotImplementedError("Incompatible with private key URIs") + + @staticmethod + def _to_gpg_sig(sig: Signature) -> Dict: + """Helper to convert Signature -> internal gpg signature format.""" + sig_dict = sig.to_dict() + sig_dict["signature"] = sig_dict.pop("sig") + return sig_dict + + @staticmethod + def _from_gpg_sig(sig_dict: Dict) -> Signature: + """Helper to convert internal gpg signature format -> Signature.""" + sig_dict["sig"] = sig_dict.pop("signature") + return Signature.from_dict(sig_dict) + + def sign(self, payload: bytes) -> Signature: + """Signs payload with ``gpg``. + + Arguments: + payload: bytes to be signed. + + Raises: + ValueError: The gpg command failed to create a valid signature. + OSError: the gpg command is not present or non-executable. + securesystemslib.exceptions.UnsupportedLibraryError: The gpg + command is not available, or the cryptography library is + not installed. + securesystemslib.gpg.exceptions.CommandError: The gpg command + returned a non-zero exit code. + securesystemslib.gpg.exceptions.KeyNotFoundError: The used gpg + version is not fully supported. + + Returns: + Signature. + """ + return self._from_gpg_sig( + gpg.create_signature(payload, self.keyid, self.homedir) + ) diff --git a/securesystemslib/signer/_signature.py b/securesystemslib/signer/_signature.py index 190afc3..1869125 100644 --- a/securesystemslib/signer/_signature.py +++ b/securesystemslib/signer/_signature.py @@ -81,55 +81,3 @@ class Signature: "sig": self.signature, self.unrecognized_fields, } - - -class GPGSignature(Signature): - """A container class containing information about a gpg signature. - - Besides the signature, it also contains other meta information - needed to uniquely identify the key used to generate the signature. - - Attributes: - keyid: HEX string used as a unique identifier of the key. - signature: HEX string representing the signature. - other_headers: HEX representation of additional GPG headers. - """ - - def __init__( - self, - keyid: str, - signature: str, - other_headers: str, - ): - super().__init__(keyid, signature) - self.other_headers = other_headers - - @classmethod - def from_dict(cls, signature_dict: Dict) -> "GPGSignature": - """Creates a GPGSignature object from its JSON/dict representation. - - Args: - signature_dict: Dict containing valid "keyid", "signature" and - "other_fields" fields. - - Raises: - KeyError: If any of the "keyid", "sig" or "other_headers" fields - are missing from the signature_dict. - - Returns: - GPGSignature instance. - """ - - return cls( - signature_dict["keyid"], - signature_dict["signature"], - signature_dict["other_headers"], - ) - - def to_dict(self) -> Dict: - """Returns the JSON-serializable dictionary representation of self.""" - return { - "keyid": self.keyid, - "signature": self.signature, - "other_headers": self.other_headers, - } diff --git a/securesystemslib/signer/_signer.py b/securesystemslib/signer/_signer.py index 42a8281..6a767ed 100644 --- a/securesystemslib/signer/_signer.py +++ b/securesystemslib/signer/_signer.py @@ -6,10 +6,9 @@ from abc import ABCMeta, abstractmethod from typing import Callable, Dict, Optional, Type from urllib import parse -import securesystemslib.gpg.functions as gpg import securesystemslib.keys as sslib_keys from securesystemslib.signer._key import Key, SSlibKey -from securesystemslib.signer._signature import GPGSignature, Signature +from securesystemslib.signer._signature import Signature logger = logging.getLogger(__name__) @@ -212,62 +211,3 @@ class SSlibSigner(Signer): """ sig_dict = sslib_keys.create_signature(self.key_dict, payload) return Signature(sig_dict) - - -class GPGSigner(Signer): - """A securesystemslib gpg implementation of the "Signer" interface. - - Provides a sign method to generate a cryptographic signature with gpg, using - an RSA, DSA or EdDSA private key identified by the keyid on the instance. - """ - - def __init__( - self, keyid: Optional[str] = None, homedir: Optional[str] = None - ): - self.keyid = keyid - self.homedir = homedir - - @classmethod - def from_priv_key_uri( - cls, - priv_key_uri: str, - public_key: Key, - secrets_handler: Optional[SecretsHandler] = None, - ) -> "GPGSigner": - raise NotImplementedError("Incompatible with private key URIs") - - def sign(self, payload: bytes) -> GPGSignature: - """Signs a given payload by the key assigned to the GPGSigner instance. - - Calls the gpg command line utility to sign the passed content with the - key identified by the passed keyid from the gpg keyring at the passed - homedir. - - The executed base command is defined in - securesystemslib.gpg.constants.gpg_sign_command. - - Arguments: - payload: The bytes to be signed. - - Raises: - securesystemslib.exceptions.FormatError: - If the keyid was passed and does not match - securesystemslib.formats.KEYID_SCHEMA. - - ValueError: the gpg command failed to create a valid signature. - OSError: the gpg command is not present or non-executable. - securesystemslib.exceptions.UnsupportedLibraryError: the gpg - command is not available, or the cryptography library is - not installed. - securesystemslib.gpg.exceptions.CommandError: the gpg command - returned a non-zero exit code. - securesystemslib.gpg.exceptions.KeyNotFoundError: the used gpg - version is not fully supported and no public key can be found - for short keyid. - - Returns: - Returns a "GPGSignature" class instance. - """ - - sig_dict = gpg.create_signature(payload, self.keyid, self.homedir) - return GPGSignature(**sig_dict)	secure-systems-lab/securesystemslib	c10b0e9c38f0d9bac833b1adc71308158a4afb69	diff --git a/.github/workflows/test-kms.yml b/.github/workflows/test-kms.yml index 6b63854..d843074 100644 --- a/.github/workflows/test-kms.yml +++ b/.github/workflows/test-kms.yml @@ -16,7 +16,7 @@ jobs: steps: - name: Checkout securesystemslib - uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b + uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c - name: Set up Python uses: actions/setup-python@5ccb29d8773c3f3f653e1705f474dfaa8a06a912 diff --git a/tests/test_signer.py b/tests/test_signer.py index 5224858..c296f49 100644 --- a/tests/test_signer.py +++ b/tests/test_signer.py @@ -22,7 +22,6 @@ from securesystemslib.gpg.functions import verify_signature as verify_sig from securesystemslib.signer import ( KEY_FOR_TYPE_AND_SCHEME, SIGNER_FOR_URI_SCHEME, - GPGSignature, GPGSigner, Key, SecretsHandler, @@ -398,11 +397,11 @@ class TestGPGRSA(unittest.TestCase): def test_gpg_sign_and_verify_object_with_default_key(self): """Create a signature using the default key on the keyring.""" - + # pylint: disable=protected-access signer = GPGSigner(homedir=self.gnupg_home) signature = signer.sign(self.test_data) - signature_dict = signature.to_dict() + signature_dict = GPGSigner._to_gpg_sig(signature) key_data = export_pubkey(self.default_keyid, self.gnupg_home) self.assertTrue(verify_sig(signature_dict, key_data, self.test_data)) @@ -410,27 +409,28 @@ class TestGPGRSA(unittest.TestCase): def test_gpg_sign_and_verify_object(self): """Create a signature using a specific key on the keyring.""" - + # pylint: disable=protected-access signer = GPGSigner(self.signing_subkey_keyid, self.gnupg_home) signature = signer.sign(self.test_data) - signature_dict = signature.to_dict() + signature_dict = GPGSigner._to_gpg_sig(signature) key_data = export_pubkey(self.signing_subkey_keyid, self.gnupg_home) self.assertTrue(verify_sig(signature_dict, key_data, self.test_data)) self.assertFalse(verify_sig(signature_dict, key_data, self.wrong_data)) - def test_gpg_serialization(self): - """Tests from_dict and to_dict methods of GPGSignature.""" - - sig_dict = { - "keyid": "f4f90403af58eef6", - "signature": "c39f86e70e12e70e11d87eb7e3ab7d3b", - "other_headers": "d8f8a89b5d71f07b842a", - } - - signature = GPGSignature.from_dict(sig_dict) - self.assertEqual(sig_dict, signature.to_dict()) + def test_gpg_signature_data_structure(self): + """Test custom fields and legacy data structure in gpg signatures.""" + # pylint: disable=protected-access + signer = GPGSigner(homedir=self.gnupg_home) + sig = signer.sign(self.test_data) + self.assertIn("other_headers", sig.unrecognized_fields) + + sig_dict = GPGSigner._to_gpg_sig(sig) + self.assertIn("signature", sig_dict) + self.assertNotIn("sig", sig_dict) + sig2 = GPGSigner._from_gpg_sig(sig_dict) + self.assertEqual(sig, sig2) # Run the unit tests.	GPGSigner (and gpg.functions.create_signature) produce invalid signature dicts ```python signer = GPGSigner(self.signing_subkey_keyid, self.gnupg_home) signature = signer.sign(self.test_data) print(signature.to_dict()) ``` The result does not look like a TUF compliant signature (notice the key name "signature" instead of "sig"): ``` { 'keyid': 'c5a0abe6ec19d0d65f85e2c39be9df5131d924e9', 'signature': '5630c9b9436ed438cdf1386abe9ca3201612c24dee868e7294f6f4592fa05820a194cf1f87fd21f5ea0a596578a20491ca8829ef8d352df1139a953e28cf2176e3c3dc484e669782f65a1cc7ac4d1798ef3874e1f4a113aa59e5b6d350aacfa3c9c58a3ef2770995396971db3aae93d122a73795bb6b6b8d6e5b49a9be64bed8c13f849b09d43c7e916366a6290e92e41987636107703147b2fc86eec59909ddf1d002f39655c11176c18f04b927ecce48781258aa4e8f715014e2e30332839475528afa7faac0c48b425984eb726176092a2cbc3ece7d7e7eea372b8ffdf82715564536b961e5d195f1746b578ccaea19a5eb5936a2d38e0187af490ecc902a', 'other_headers': '04000108001d162104c5a0abe6ec19d0d65f85e2c39be9df5131d924e90502635bbb2e' } ``` Did no-one ever actually try to put a GPG signature in TUF metadata?	c10b0e9c38f0d9bac833b1adc71308158a4afb69	[ "tests/test_signer.py::TestGPGRSA::test_gpg_sign_and_verify_object", "tests/test_signer.py::TestGPGRSA::test_gpg_sign_and_verify_object_with_default_key", "tests/test_signer.py::TestGPGRSA::test_gpg_signature_data_structure" ]	[ "tests/test_signer.py::TestKey::test_custom_key", "tests/test_signer.py::TestKey::test_key_from_to_dict", "tests/test_signer.py::TestKey::test_key_verify_signature", "tests/test_signer.py::TestKey::test_sslib_key_from_dict_invalid", "tests/test_signer.py::TestKey::test_unsupported_key", "tests/test_signer.py::TestSigner::test_custom_signer", "tests/test_signer.py::TestSigner::test_signature_eq_", "tests/test_signer.py::TestSigner::test_signature_from_to_dict", "tests/test_signer.py::TestSigner::test_signer_sign_with_enc_file_uri", "tests/test_signer.py::TestSigner::test_signer_sign_with_envvar_uri", "tests/test_signer.py::TestSigner::test_signer_sign_with_file_uri", "tests/test_signer.py::TestSigner::test_signer_sign_with_incorrect_uri", "tests/test_signer.py::TestSigner::test_sslib_signer_sign" ]	{ "failed_lite_validators": [ "has_git_commit_hash", "has_added_files", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-12-15 09:42:52+00:00	mit	5,456
sedders123__phial-169	diff --git a/.circleci/config.yml b/.circleci/config.yml index e2a4b2d..ae2a87d 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -5,8 +5,9 @@ jobs: - image: circleci/python:3.7 steps: - checkout + - run: echo "$CIRCLE_JOB" > _circle_job - restore_cache: - key: v1-deps-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} + key: v1-deps-{{ checksum "_circle_job" }}-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} - run: name: Create Virtual Env command: \| @@ -22,7 +23,7 @@ jobs: . venv/bin/activate pip install -e . - save_cache: - key: v1-deps-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} + key: v1-deps-{{ checksum "_circle_job" }}-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} paths: - "venv" - run: @@ -44,7 +45,7 @@ jobs: name: Upload coverage command: \| . venv/bin/activate - if [ -z $COVERALLS_REPO_TOKEN ]; then echo "No Coveralls Token"; else coveralls; fi + if [ -z $COVERALLS_REPO_TOKEN ] \|\| [ "$CIRCLE_JOB" != "build" ]; then echo "No Coveralls Token"; else coveralls; fi test-3.6: <<: *template @@ -61,9 +62,9 @@ jobs: - image: circleci/python:3.7 steps: - checkout - + - run: echo "build" > build_job - restore_cache: - key: v1-deps-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} + key: v1-deps-{{checksum "build_job"}}--{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} - run: name: Create Virtual Env @@ -83,7 +84,7 @@ jobs: pip install -e . - save_cache: - key: v1-deps-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} + key: v1-deps-{{checksum "build_job"}}-{{ checksum "dev-requirements.txt" }}-{{ checksum "setup.py" }} paths: - "venv" diff --git a/CHANGELOG.md b/CHANGELOG.md index 0149024..7658e83 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0. ### Added - Added 'loopDelay' config option. Specifes how to long to sleep for in the main loop, this helps to prevent super high CPU usage while doing nothing. Defaults to 0.001 + - Added `hide_from_help_command` argument to command creation. This hides the command from the list generated by inbuilt help command. ### Changed - Python 3.6.1 is now marked as incompatible due to an issue with the `NoReturn` type diff --git a/examples/starter.py b/examples/starter.py index b91b49e..ec5defe 100644 --- a/examples/starter.py +++ b/examples/starter.py @@ -67,7 +67,7 @@ def case_sensitive(): @slackbot.command('messageWithAttachment') def get_message_with_attachment(): ''' - A command that posts a message with a Slack attachment + A command that posts a message with a Slack attachment. Read more: https://api.slack.com/docs/message-attachments ''' attachments = [{ @@ -78,6 +78,14 @@ def get_message_with_attachment(): return Response(channel=command.channel, attachments=attachments) [email protected]('hidden', hide_from_help_command=True) +def hidden(): + ''' + A command that is hidden from the default help command + ''' + return "Suprise" + + @slackbot.fallback_command() def fallback_command(command): return "Thats not a command" diff --git a/phial/bot.py b/phial/bot.py index 33d0eb4..ced4ecb 100644 --- a/phial/bot.py +++ b/phial/bot.py @@ -43,7 +43,7 @@ class Phial: self.scheduler = Scheduler() self.fallback_func = None # type: Optional[Callable[[Message], PhialResponse]] # noqa: E501 self.logger = logging.getLogger(__name__) - if not self.logger.hasHandlers(): + if not self.logger.hasHandlers(): # pragma: nocover handler = logging.StreamHandler() formatter = logging.Formatter( fmt="%(asctime)s [%(name)s] - %(message)s") @@ -57,7 +57,8 @@ class Phial: pattern: str, func: Callable[..., PhialResponse], case_sensitive: bool = False, - help_text_override: Optional[str] = None) -> None: + help_text_override: Optional[str] = None, + hide_from_help_command: Optional[bool] = False) -> None: """ Registers a command with the bot. @@ -80,6 +81,12 @@ class Phial: help text. Defaults to None + :param hide_from_help_command: A flag to specify whether or not + the inbuilt help command should + hide this command from the list + it generates. + + Defaults to False :raises ValueError: If command with the same pattern is already registered @@ -110,7 +117,11 @@ class Phial: .format(pattern.split("<")[0])) # Create and add command - command = Command(pattern, func, case_sensitive, help_text_override) + command = Command(pattern, + func, + case_sensitive, + help_text_override=help_text_override, + hide_from_help_command=hide_from_help_command) self.commands.append(command) self.logger.debug("Command {0} added" .format(pattern)) @@ -118,7 +129,8 @@ class Phial: def command(self, pattern: str, case_sensitive: bool = False, - help_text_override: Optional[str] = None) -> Callable: + help_text_override: Optional[str] = None, + hide_from_help_command: Optional[bool] = False) -> Callable: """ Registers a command with the bot. @@ -139,6 +151,12 @@ class Phial: help text. Defaults to None + :param hide_from_help_command: A flag to specify whether or not + the inbuilt help command should + hide this command from the list + it generates. + + Defaults to False .. rubric:: Example @@ -154,7 +172,10 @@ class Phial: """ def decorator(f: Callable) -> Callable: - self.add_command(pattern, f, case_sensitive, help_text_override) + self.add_command(pattern, f, + case_sensitive, + help_text_override=help_text_override, + hide_from_help_command=hide_from_help_command) return f return decorator diff --git a/phial/commands.py b/phial/commands.py index f696d2e..cb6be4d 100644 --- a/phial/commands.py +++ b/phial/commands.py @@ -13,6 +13,8 @@ def help_command(bot: 'Phial') -> str: if help_text: help_text += "\n" for command in bot.commands: + if command.hide_from_help_command: + continue command_doc = command.help_text if not command_doc: # If no help text default to blank string diff --git a/phial/types.py b/phial/types.py index f215336..074230d 100644 --- a/phial/types.py +++ b/phial/types.py @@ -1,7 +1,7 @@ """Shared types for phial.""" from typing import TYPE_CHECKING, Union -if TYPE_CHECKING: +if TYPE_CHECKING: # pragma: nocover from phial.wrappers import Response, Attachment # noqa #: A union of all response types phial can use diff --git a/phial/wrappers.py b/phial/wrappers.py index 57fddea..d30b5fd 100644 --- a/phial/wrappers.py +++ b/phial/wrappers.py @@ -151,19 +151,23 @@ class Command: sensitivity :param help_text_override: Overrides the function's docstring in the standard help command + :param hide_from_help_command: Prevents function from being displayed by + the standard help command """ def __init__(self, pattern: str, func: Callable[..., PhialResponse], case_sensitive: bool = False, - help_text_override: Optional[str] = None): + help_text_override: Optional[str] = None, + hide_from_help_command: Optional[bool] = False): self.pattern_string = pattern self.pattern = self._build_pattern_regex(pattern, case_sensitive) self.alias_patterns = self._get_alias_patterns(func) self.func = func self.case_sensitive = case_sensitive self.help_text_override = help_text_override + self.hide_from_help_command = hide_from_help_command def __repr__(self) -> str: return "<Command: {0}>".format(self.pattern_string)	sedders123/phial	36d86f63670e9872c618eb13b6dbc4c7fb31b42c	diff --git a/tests/commands/test_help_command.py b/tests/commands/test_help_command.py index 00db3f1..1972141 100644 --- a/tests/commands/test_help_command.py +++ b/tests/commands/test_help_command.py @@ -33,6 +33,37 @@ def test_returns_help_string_correctly_when_no_help_text() -> None: assert help_text == expected_help_text +def test_hide_from_help_command_hides_correctly() -> None: + """Test returns help text correctly when none set.""" + bot = Phial('token') + + @bot.command("test", hide_from_help_command=True) + def test() -> None: + pass + + help_text = help_command(bot) + expected_help_text = ("All available commands:\n!help - List all" + " available commmands\n") + + assert help_text == expected_help_text + + +def test_help_text_override_overrides_correctly() -> None: + """Test returns help text correctly when none set.""" + bot = Phial('token') + + @bot.command("test", help_text_override="Override") + def test() -> None: + """Not this.""" + pass + + help_text = help_command(bot) + expected_help_text = ("All available commands:\n!help - List all" + " available commmands\n!test - Override\n") + + assert help_text == expected_help_text + + def test_returns_help_string_correctly_when_no_base() -> None: """Test returns help text correctly when no base.""" bot = Phial('token', {'registerHelpCommand': False,	Have ability to hide a command from !help Allow users to hide a command from the in built help command if passed a parameter.	36d86f63670e9872c618eb13b6dbc4c7fb31b42c	[ "tests/commands/test_help_command.py::test_hide_from_help_command_hides_correctly" ]	[ "tests/commands/test_help_command.py::test_returns_help_string_correctly", "tests/commands/test_help_command.py::test_returns_help_string_correctly_when_no_help_text", "tests/commands/test_help_command.py::test_help_text_override_overrides_correctly", "tests/commands/test_help_command.py::test_returns_help_string_correctly_when_no_base" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2019-05-30 15:56:33+00:00	mit	5,457
sedders123__phial-29	diff --git a/README.rst b/README.rst index e6aceda..67b6459 100644 --- a/README.rst +++ b/README.rst @@ -1,15 +1,13 @@ phial ===== -\|Documentation Status\| \|CircleCI\| \|Coverage Status\| +\|Documentation Status\| \|CircleCI\| \|Coverage Status\| \|PyPi\| A simple framework for building slack bots Phial is a slack bot framework, modelled loosely on `flask <https://github.com/pallets/flask/>`__. -NOTE: This package is still in early development, things are likely to -change Table of Contents ----------------- @@ -90,3 +88,5 @@ Erlenmeyer Flask by Iconic from the Noun Project - `CC BY :target: https://circleci.com/gh/sedders123/phial .. \|Coverage Status\| image:: https://coveralls.io/repos/github/sedders123/phial/badge.svg?branch=develop :target: https://coveralls.io/github/sedders123/phial?branch=develop +.. \|PyPi\| image:: https://badge.fury.io/py/phial-slack.svg + :target: https://badge.fury.io/py/phial-slack diff --git a/phial/bot.py b/phial/bot.py index 9f25b14..9d7cc3c 100644 --- a/phial/bot.py +++ b/phial/bot.py @@ -1,6 +1,7 @@ from slackclient import SlackClient # type: ignore import re from typing import Dict, List, Pattern, Callable, Union, Tuple, Any # noqa +import logging from .globals import _command_ctx_stack, command, _global_ctx_stack from .wrappers import Command, Response, Message, Attachment @@ -17,12 +18,17 @@ class Phial(): 'prefix': '!' } - def __init__(self, token: str, config: dict = default_config) -> None: + def __init__(self, + token: str, + config: dict = default_config, + logger: logging.Logger = logging.getLogger(__name__)) -> None: self.slack_client = SlackClient(token) self.commands = {} # type: Dict self.middleware_functions = [] # type: List self.config = config self.running = False + self.logger = logger + _global_ctx_stack.push({}) @staticmethod @@ -69,6 +75,8 @@ class Phial(): case_sensitive) if command_pattern not in self.commands: self.commands[command_pattern] = command_func + self.logger.debug("Command {0} added" + .format(command_pattern_template)) else: raise ValueError('Command {0} already exists' .format(command_pattern.split("<")[0])) @@ -158,7 +166,7 @@ class Phial(): ''' def decorator(f: Callable) -> Callable: - self.middleware_functions.append(f) + self.add_middleware(f) return f return decorator @@ -183,6 +191,10 @@ class Phial(): middleware_func(func): The function to be added to the middleware pipeline ''' + self.logger.debug("Middleware {0} added" + .format(getattr(middleware_func, + '__name__', + repr(middleware_func)))) self.middleware_functions.append(middleware_func) def alias(self, @@ -247,6 +259,8 @@ class Phial(): if output_list and len(output_list) > 0: for output in output_list: if(output and 'text' in output): + self.logger.debug("Message recieved from Slack: {0}" + .format(output)) bot_id = None if 'bot_id' in output: bot_id = output['bot_id'] @@ -359,7 +373,7 @@ class Phial(): response = self._handle_command(command) self._execute_response(response) except ValueError as err: - print('ValueError: {}'.format(err)) + self.logger.exception('ValueError: {}'.format(err)) finally: _command_ctx_stack.pop() @@ -370,7 +384,7 @@ class Phial(): if not slack_client.rtm_connect(): raise ValueError("Connection failed. Invalid Token or bot ID") - print("Phial connected and running!") + self.logger.info("Phial connected and running!") while self._is_running(): try: message = self._parse_slack_output(slack_client @@ -378,4 +392,4 @@ class Phial(): if message: self._handle_message(message) except Exception as e: - print("Error: {0}".format(e)) + self.logger.exception("Error: {0}".format(e))	sedders123/phial	b786240e7834e6b5d98d447638144612869027c2	diff --git a/tests/test_bot.py b/tests/test_bot.py index 93faed7..19d905c 100644 --- a/tests/test_bot.py +++ b/tests/test_bot.py @@ -4,7 +4,7 @@ from phial import Phial, command, Response, Attachment, g import phial.wrappers import phial.globals import re -from .helpers import captured_output, MockTrueFunc +from .helpers import MockTrueFunc class TestPhialBotIsRunning(unittest.TestCase): @@ -580,12 +580,13 @@ class TestRun(TestPhialBot): 'user_id', 'timestamp') self.bot._parse_slack_output = MagicMock(return_value=test_command) - with captured_output() as (out, err): - self.bot.run() - output = out.getvalue().strip() expected_msg = 'ValueError: Command "test" has not been registered' - self.assertTrue(expected_msg in output) + with self.assertLogs(logger='phial.bot', level='ERROR') as cm: + self.bot.run() + + error = cm.output[0] + self.assertIn(expected_msg, error) class TestGlobalContext(unittest.TestCase):	Add support for logger Allow a user to pass in a `logger` and log when events of interest happen.	b786240e7834e6b5d98d447638144612869027c2	[ "tests/test_bot.py::TestRun::test_errors_with_invalid_command" ]	[ "tests/test_bot.py::TestPhialBotIsRunning::test_returns_expected_value", "tests/test_bot.py::TestCommandDecarator::test_command_decorator_calls_add_command", "tests/test_bot.py::TestCommandDecarator::test_command_decorator_functionality", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_calls_add_command_case_insensitive", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_calls_add_command_case_sensitive", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_functionality", "tests/test_bot.py::TestAddCommand::test_add_command_errors_on_duplicate_name", "tests/test_bot.py::TestAddCommand::test_add_command_functionality", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_multiple_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_multiple_substition_ignore_case", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_no_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_no_substition_ignore_case", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_single_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_single_substition_ignore_case", "tests/test_bot.py::TestGetCommandMatch::test_basic_functionality", "tests/test_bot.py::TestGetCommandMatch::test_multi_substition_matching", "tests/test_bot.py::TestGetCommandMatch::test_returns_none_correctly", "tests/test_bot.py::TestGetCommandMatch::test_single_substition_matching", "tests/test_bot.py::TestCreateCommand::test_basic_functionality", "tests/test_bot.py::TestCreateCommand::test_basic_functionality_with_args", "tests/test_bot.py::TestCreateCommand::test_errors_when_no_command_match", "tests/test_bot.py::TestHandleCommand::test_handle_command_basic_functionality", "tests/test_bot.py::TestCommandContextWorksCorrectly::test_command_context_pops_correctly", "tests/test_bot.py::TestCommandContextWorksCorrectly::test_command_context_works_correctly", "tests/test_bot.py::TestParseSlackOutput::test_basic_functionality", "tests/test_bot.py::TestParseSlackOutput::test_returns_message_correctly_for_normal_message", "tests/test_bot.py::TestParseSlackOutput::test_returns_message_with_bot_id_correctly", "tests/test_bot.py::TestParseSlackOutput::test_returns_none_correctly_if_no_messages", "tests/test_bot.py::TestSendMessage::test_send_message", "tests/test_bot.py::TestSendMessage::test_send_reply", "tests/test_bot.py::TestSendReaction::test_basic_functionality", "tests/test_bot.py::TestUploadAttachment::test_basic_functionality", "tests/test_bot.py::TestExecuteResponse::test_errors_on_invalid_response", "tests/test_bot.py::TestExecuteResponse::test_errors_with_invalid_attachment", "tests/test_bot.py::TestExecuteResponse::test_errors_with_reaction_and_reply", "tests/test_bot.py::TestExecuteResponse::test_send_message", "tests/test_bot.py::TestExecuteResponse::test_send_reaction", "tests/test_bot.py::TestExecuteResponse::test_send_reply", "tests/test_bot.py::TestExecuteResponse::test_send_string", "tests/test_bot.py::TestExecuteResponse::test_upload_attachment", "tests/test_bot.py::TestMiddleware::test_add_function", "tests/test_bot.py::TestMiddleware::test_decarator", "tests/test_bot.py::TestMiddleware::test_halts_message_when_none_returned", "tests/test_bot.py::TestMiddleware::test_passes_on_message_correctly", "tests/test_bot.py::TestHandleMessage::test_bot_message_does_not_trigger_command", "tests/test_bot.py::TestRun::test_basic_functionality", "tests/test_bot.py::TestRun::test_errors_with_invalid_token", "tests/test_bot.py::TestGlobalContext::test_global_context_in_command" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2018-04-19 21:06:41+00:00	mit	5,458
sedders123__phial-40	diff --git a/phial/bot.py b/phial/bot.py index 43d0251..0f1d678 100644 --- a/phial/bot.py +++ b/phial/bot.py @@ -279,22 +279,28 @@ class Phial(): message(Response): message object to be sent to Slack ''' + + api_method = ('chat.postEphemeral' if message.ephemeral + else 'chat.postMessage') + if message.original_ts: - self.slack_client.api_call("chat.postMessage", + self.slack_client.api_call(api_method, channel=message.channel, text=message.text, thread_ts=message.original_ts, attachments=json.dumps( message.attachments, default=lambda o: o.__dict__), + user=message.user, as_user=True) else: - self.slack_client.api_call("chat.postMessage", + self.slack_client.api_call(api_method, channel=message.channel, text=message.text, attachments=json.dumps( message.attachments, default=lambda o: o.__dict__), + user=message.user, as_user=True) def send_reaction(self, response: Response) -> None: diff --git a/phial/wrappers.py b/phial/wrappers.py index 397dded..dbe3145 100644 --- a/phial/wrappers.py +++ b/phial/wrappers.py @@ -164,6 +164,8 @@ class Response(): List[Dict[str, Dict[str, str]]]]): A list of MessageAttachment objects to be attached to the message + ephemeral(bool): Whether to send the message as an ephemeral message + user(str): The user id to display the ephemeral message to Examples: The following would send a message to a slack channel when executed :: @@ -195,12 +197,16 @@ class Response(): original_ts: Optional[str] = None, attachments: Optional[Union[List[MessageAttachment], List[MessageAttachmentJson]]] = None, - reaction: Optional[str] = None) -> None: + reaction: Optional[str] = None, + ephemeral: bool = False, + user: Optional[str] = None) -> None: self.channel = channel self.text = text self.original_ts = original_ts self.reaction = reaction self.attachments = attachments + self.ephemeral = ephemeral + self.user = user def __repr__(self) -> str: return "<Response: {0}>".format(self.text)	sedders123/phial	8f6c931b420b4ad29fd8ea32164786c9c6d5f4ed	diff --git a/tests/test_bot.py b/tests/test_bot.py index 18f2261..3b25849 100644 --- a/tests/test_bot.py +++ b/tests/test_bot.py @@ -346,7 +346,8 @@ class TestSendMessage(TestPhialBot): channel='channel_id', text='Hi test', as_user=True, - attachments='null') + attachments='null', + user=None) def test_send_reply(self): self.bot.slack_client = MagicMock() @@ -362,7 +363,8 @@ class TestSendMessage(TestPhialBot): text='Hi test', thread_ts='timestamp', as_user=True, - attachments='null') + attachments='null', + user=None) class TestSendMessageWithMessageAttachments(TestPhialBot): @@ -430,7 +432,8 @@ class TestSendMessageWithMessageAttachments(TestPhialBot): channel='channel_id', as_user=True, attachments=json.dumps(json.loads(attachments)), - text=None) + text=None, + user=None) class TestSendMessageWithMessageAttachmentsDictionary(TestPhialBot): @@ -503,7 +506,42 @@ class TestSendMessageWithMessageAttachmentsDictionary(TestPhialBot): channel='channel_id', as_user=True, attachments=json.dumps(json.loads(expected_attachments)), - text=None) + text=None, + user=None) + + +class TestSendEphemeralMessage(TestPhialBot): + '''Test phial's send_message function when sending an ephemeral message''' + + def test_ephemeral(self): + self.bot.slack_client = MagicMock() + message = Response(channel="channel_id", + ephemeral=True, + text="Test text", + user="user_id") + self.bot.send_message(message) + + self.bot.slack_client.api_call.assert_called_with( + 'chat.postEphemeral', + channel='channel_id', + as_user=True, + attachments='null', + text='Test text', + user='user_id') + + def test_ephemeral_defaults_to_false(self): + self.bot.slack_client = MagicMock() + message = Response(channel="channel_id", + text="Test text") + self.bot.send_message(message) + + self.bot.slack_client.api_call.assert_called_with( + 'chat.postMessage', + channel='channel_id', + as_user=True, + attachments='null', + text='Test text', + user=None) class TestSendReaction(TestPhialBot):	Allow sending of ephemeral messages Add a `ephemeral` property to `Response` that defaults to false. If its true send an ephemeral message. [Slack Docs](https://api.slack.com/methods/chat.postEphemeral)	8f6c931b420b4ad29fd8ea32164786c9c6d5f4ed	[ "tests/test_bot.py::TestSendMessage::test_send_message", "tests/test_bot.py::TestSendMessage::test_send_reply", "tests/test_bot.py::TestSendMessageWithMessageAttachments::test_send_message", "tests/test_bot.py::TestSendMessageWithMessageAttachmentsDictionary::test_send_message", "tests/test_bot.py::TestSendEphemeralMessage::test_ephemeral", "tests/test_bot.py::TestSendEphemeralMessage::test_ephemeral_defaults_to_false" ]	[ "tests/test_bot.py::TestPhialBotIsRunning::test_returns_expected_value", "tests/test_bot.py::TestCommandDecarator::test_command_decorator_calls_add_command", "tests/test_bot.py::TestCommandDecarator::test_command_decorator_functionality", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_calls_add_command_case_insensitive", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_calls_add_command_case_sensitive", "tests/test_bot.py::TestAliasDecarator::test_command_decorator_functionality", "tests/test_bot.py::TestAddCommand::test_add_command_errors_on_duplicate_name", "tests/test_bot.py::TestAddCommand::test_add_command_functionality", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_multiple_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_multiple_substition_ignore_case", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_no_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_no_substition_ignore_case", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_single_substition_case_sensitive", "tests/test_bot.py::TestBuildCommandPattern::test_build_command_pattern_single_substition_ignore_case", "tests/test_bot.py::TestGetCommandMatch::test_basic_functionality", "tests/test_bot.py::TestGetCommandMatch::test_multi_substition_matching", "tests/test_bot.py::TestGetCommandMatch::test_returns_none_correctly", "tests/test_bot.py::TestGetCommandMatch::test_single_substition_matching", "tests/test_bot.py::TestCreateCommand::test_basic_functionality", "tests/test_bot.py::TestCreateCommand::test_basic_functionality_with_args", "tests/test_bot.py::TestCreateCommand::test_errors_when_no_command_match", "tests/test_bot.py::TestHandleCommand::test_handle_command_basic_functionality", "tests/test_bot.py::TestCommandContextWorksCorrectly::test_command_context_pops_correctly", "tests/test_bot.py::TestCommandContextWorksCorrectly::test_command_context_works_correctly", "tests/test_bot.py::TestParseSlackOutput::test_basic_functionality", "tests/test_bot.py::TestParseSlackOutput::test_returns_message_correctly_for_normal_message", "tests/test_bot.py::TestParseSlackOutput::test_returns_message_with_bot_id_correctly", "tests/test_bot.py::TestParseSlackOutput::test_returns_none_correctly_if_no_messages", "tests/test_bot.py::TestSendReaction::test_basic_functionality", "tests/test_bot.py::TestUploadAttachment::test_basic_functionality", "tests/test_bot.py::TestExecuteResponse::test_errors_on_invalid_response", "tests/test_bot.py::TestExecuteResponse::test_errors_with_invalid_attachment", "tests/test_bot.py::TestExecuteResponse::test_errors_with_reaction_and_reply", "tests/test_bot.py::TestExecuteResponse::test_send_message", "tests/test_bot.py::TestExecuteResponse::test_send_message_attachments", "tests/test_bot.py::TestExecuteResponse::test_send_reaction", "tests/test_bot.py::TestExecuteResponse::test_send_reply", "tests/test_bot.py::TestExecuteResponse::test_send_string", "tests/test_bot.py::TestExecuteResponse::test_upload_attachment", "tests/test_bot.py::TestMiddleware::test_add_function", "tests/test_bot.py::TestMiddleware::test_decarator", "tests/test_bot.py::TestMiddleware::test_halts_message_when_none_returned", "tests/test_bot.py::TestMiddleware::test_passes_on_message_correctly", "tests/test_bot.py::TestHandleMessage::test_bot_message_does_not_trigger_command", "tests/test_bot.py::TestRun::test_basic_functionality", "tests/test_bot.py::TestRun::test_errors_with_invalid_command", "tests/test_bot.py::TestRun::test_errors_with_invalid_token", "tests/test_bot.py::TestGlobalContext::test_global_context_in_command" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2018-06-09 23:48:26+00:00	mit	5,459
seddonym__import-linter-79	diff --git a/AUTHORS.rst b/AUTHORS.rst index b34e861..b0fa74b 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -9,3 +9,4 @@ Contributors ============ * Anthony Sottile - https://github.com/asottile +* Łukasz Skarżyński - https://github.com/skarzi diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 49ecc2c..3df7df3 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -87,3 +87,5 @@ latest ------ * Upgrade Grimp to 1.2.2. +* Add SetField +* Use a SetField for ignore_imports options diff --git a/src/importlinter/contracts/forbidden.py b/src/importlinter/contracts/forbidden.py index 89a10de..6badb2b 100644 --- a/src/importlinter/contracts/forbidden.py +++ b/src/importlinter/contracts/forbidden.py @@ -14,8 +14,8 @@ class ForbiddenContract(Contract): - source_modules: A list of Modules that should not import the forbidden modules. - forbidden_modules: A list of Modules that should not be imported by the source modules. - - ignore_imports: A list of DirectImports. These imports will be ignored: if the import - would cause a contract to be broken, adding it to the list will cause + - ignore_imports: A set of DirectImports. These imports will be ignored: if the import + would cause a contract to be broken, adding it to the set will cause the contract be kept instead. (Optional.) """ @@ -23,7 +23,7 @@ class ForbiddenContract(Contract): source_modules = fields.ListField(subfield=fields.ModuleField()) forbidden_modules = fields.ListField(subfield=fields.ModuleField()) - ignore_imports = fields.ListField(subfield=fields.DirectImportField(), required=False) + ignore_imports = fields.SetField(subfield=fields.DirectImportField(), required=False) def check(self, graph: ImportGraph) -> ContractCheck: is_kept = True diff --git a/src/importlinter/contracts/independence.py b/src/importlinter/contracts/independence.py index 71a7ff7..14f206e 100644 --- a/src/importlinter/contracts/independence.py +++ b/src/importlinter/contracts/independence.py @@ -16,15 +16,15 @@ class IndependenceContract(Contract): Configuration options: - modules: A list of Modules that should be independent from each other. - - ignore_imports: A list of DirectImports. These imports will be ignored: if the import - would cause a contract to be broken, adding it to the list will cause + - ignore_imports: A set of DirectImports. These imports will be ignored: if the import + would cause a contract to be broken, adding it to the set will cause the contract be kept instead. (Optional.) """ type_name = "independence" modules = fields.ListField(subfield=fields.ModuleField()) - ignore_imports = fields.ListField(subfield=fields.DirectImportField(), required=False) + ignore_imports = fields.SetField(subfield=fields.DirectImportField(), required=False) def check(self, graph: ImportGraph) -> ContractCheck: is_kept = True diff --git a/src/importlinter/contracts/layers.py b/src/importlinter/contracts/layers.py index 6aa43b5..cf15223 100644 --- a/src/importlinter/contracts/layers.py +++ b/src/importlinter/contracts/layers.py @@ -42,8 +42,8 @@ class LayersContract(Contract): - layers: An ordered list of layers. Each layer is the name of a module relative to its parent package. The order is from higher to lower level layers. - containers: A list of the parent Modules of the layers (optional). - - ignore_imports: A list of DirectImports. These imports will be ignored: if the import - would cause a contract to be broken, adding it to the list will cause + - ignore_imports: A set of DirectImports. These imports will be ignored: if the import + would cause a contract to be broken, adding it to the set will cause the contract be kept instead. (Optional.) """ @@ -51,7 +51,7 @@ class LayersContract(Contract): layers = fields.ListField(subfield=LayerField()) containers = fields.ListField(subfield=fields.StringField(), required=False) - ignore_imports = fields.ListField(subfield=fields.DirectImportField(), required=False) + ignore_imports = fields.SetField(subfield=fields.DirectImportField(), required=False) def check(self, graph: ImportGraph) -> ContractCheck: is_kept = True diff --git a/src/importlinter/domain/fields.py b/src/importlinter/domain/fields.py index 7809113..e226ec9 100644 --- a/src/importlinter/domain/fields.py +++ b/src/importlinter/domain/fields.py @@ -1,16 +1,18 @@ import abc import re -from typing import Any, List, Union +from typing import Generic, Iterable, List, Set, TypeVar, Union from importlinter.domain.imports import DirectImport, Module +FieldValue = TypeVar("FieldValue") + class ValidationError(Exception): def __init__(self, message: str) -> None: self.message = message -class Field(abc.ABC): +class Field(Generic[FieldValue], abc.ABC): """ Base class for containers for some data on a Contract. @@ -21,7 +23,7 @@ class Field(abc.ABC): self.required = required @abc.abstractmethod - def parse(self, raw_data: Union[str, List[str]]) -> Any: + def parse(self, raw_data: Union[str, List[str]]) -> FieldValue: """ Given some raw data supplied by a user, return some clean data. @@ -42,16 +44,13 @@ class StringField(Field): return str(raw_data) -class ListField(Field): +class BaseMultipleValueField(Field): """ - A field for multiple values of any type. + An abstract field for multiple values of any type. Arguments: - - subfield: An instance of a single-value Field. Each item in the list will be the return - value of this subfield. - Usage: - - field = ListField(subfield=AnotherField()) + - subfield: An instance of a single-value Field. Each item in the iterable will be + the return value of this subfield. """ @@ -59,7 +58,8 @@ class ListField(Field): super().__init__(args, *kwargs) self.subfield = subfield - def parse(self, raw_data: Union[str, List]) -> List[Any]: + @abc.abstractmethod + def parse(self, raw_data: Union[str, List]) -> Iterable[FieldValue]: if isinstance(raw_data, tuple): raw_data = list(raw_data) if not isinstance(raw_data, list): @@ -70,6 +70,37 @@ class ListField(Field): return clean_list +class ListField(BaseMultipleValueField): + """ + A field for multiple values of any type. + + Fields values are returned in list sorted by parsing order. + + Usage: + + field = ListField(subfield=AnotherField()) + """ + + def parse(self, raw_data: Union[str, List]) -> List[FieldValue]: + return list(super().parse(raw_data)) + + +class SetField(BaseMultipleValueField): + """ + A field for multiple, unique values of any type. + + Fields values are returned inordered in set. + + Usage: + + field = SetField(subfield=AnotherField()) + + """ + + def parse(self, raw_data: Union[str, List]) -> Set[FieldValue]: + return set(super().parse(raw_data)) + + class ModuleField(Field): """ A field for Modules.	seddonym/import-linter	334b4d1b85bae7f21f7678e5bda17af0e7487af2	diff --git a/tests/unit/contracts/test_forbidden.py b/tests/unit/contracts/test_forbidden.py index 684d8eb..e69dc93 100644 --- a/tests/unit/contracts/test_forbidden.py +++ b/tests/unit/contracts/test_forbidden.py @@ -125,6 +125,19 @@ class TestForbiddenContract: ): contract.check(graph=graph) + def test_ignore_imports_tolerates_duplicates(self): + graph = self._build_graph() + contract = self._build_contract( + forbidden_modules=("mypackage.blue", "mypackage.yellow"), + ignore_imports=( + "mypackage.three -> mypackage.green", + "mypackage.utils -> mypackage.purple", + "mypackage.three -> mypackage.green", + ), + include_external_packages=False, + ) + assert contract.check(graph=graph) + def _build_graph(self): graph = ImportGraph() for module in ( @@ -171,7 +184,9 @@ class TestForbiddenContract: ) return graph - def _build_contract(self, forbidden_modules, include_external_packages=False): + def _build_contract( + self, forbidden_modules, ignore_imports=None, include_external_packages=False + ): session_options = {"root_packages": ["mypackage"]} if include_external_packages: session_options["include_external_packages"] = "True" @@ -182,6 +197,7 @@ class TestForbiddenContract: contract_options={ "source_modules": ("mypackage.one", "mypackage.two", "mypackage.three"), "forbidden_modules": forbidden_modules, + "ignore_imports": ignore_imports or [], }, ) diff --git a/tests/unit/contracts/test_independence.py b/tests/unit/contracts/test_independence.py index fefc36d..db3ba26 100644 --- a/tests/unit/contracts/test_independence.py +++ b/tests/unit/contracts/test_independence.py @@ -392,3 +392,30 @@ def test_missing_module(): with pytest.raises(ValueError, match=("Module 'mypackage.bar' does not exist.")): contract.check(graph=graph) + + +def test_ignore_imports_tolerates_duplicates(): + graph = ImportGraph() + graph.add_module("mypackage") + graph.add_import( + importer="mypackage.a", imported="mypackage.b", line_number=1, line_contents="-" + ) + graph.add_import( + importer="mypackage.a", imported="mypackage.c", line_number=2, line_contents="-" + ) + contract = IndependenceContract( + name="Independence contract", + session_options={"root_packages": ["mypackage"]}, + contract_options={ + "modules": ("mypackage.a", "mypackage.b"), + "ignore_imports": [ + "mypackage.a -> mypackage.b", + "mypackage.a -> mypackage.c", + "mypackage.a -> mypackage.b", + ], + }, + ) + + contract_check = contract.check(graph=graph) + + assert contract_check.kept diff --git a/tests/unit/contracts/test_layers.py b/tests/unit/contracts/test_layers.py index 36b1086..82231c4 100644 --- a/tests/unit/contracts/test_layers.py +++ b/tests/unit/contracts/test_layers.py @@ -765,6 +765,20 @@ class TestIgnoreImports: with pytest.raises(MissingImport): contract.check(graph=graph) + def test_ignore_imports_tolerates_duplicates(self): + contract = self._build_contract( + ignore_imports=[ + "mypackage.low.black -> mypackage.medium.orange", + "mypackage.utils.foo -> mypackage.utils.bar", + "mypackage.low.black -> mypackage.medium.orange", + ] + ) + graph = self._build_graph() + + contract_check = contract.check(graph=graph) + + assert contract_check.kept + def _build_graph(self): graph = ImportGraph() for module in ( diff --git a/tests/unit/domain/test_fields.py b/tests/unit/domain/test_fields.py index 851404a..76883f0 100644 --- a/tests/unit/domain/test_fields.py +++ b/tests/unit/domain/test_fields.py @@ -7,6 +7,7 @@ from importlinter.domain.fields import ( Field, ListField, ModuleField, + SetField, StringField, ValidationError, ) @@ -83,9 +84,23 @@ class TestDirectImportField(BaseFieldTest): "raw_data, expected_value", ( (["mypackage.foo", "mypackage.bar"], [Module("mypackage.foo"), Module("mypackage.bar")]), + (["mypackage.foo", "mypackage.foo"], [Module("mypackage.foo"), Module("mypackage.foo")]), ("singlevalue", [Module("singlevalue")]), ), ) class TestListField(BaseFieldTest): field_class = ListField field_kwargs = dict(subfield=ModuleField()) + + [email protected]( + "raw_data, expected_value", + ( + (["mypackage.foo", "mypackage.bar"], {Module("mypackage.foo"), Module("mypackage.bar")}), + (["mypackage.foo", "mypackage.foo"], {Module("mypackage.foo")}), + ("singlevalue", {Module("singlevalue")}), + ), +) +class TestSetField(BaseFieldTest): + field_class = SetField + field_kwargs = dict(subfield=ModuleField())	Duplicate ignored_imports lead to confusing error If you include an ignored import twice in a contract, you get the following error (as it tries to remove it the second time): ``` The edge mypackage.foo-mypackage.bar not in graph. ```	334b4d1b85bae7f21f7678e5bda17af0e7487af2	[ "tests/unit/contracts/test_forbidden.py::TestForbiddenContract::test_is_kept_when_no_forbidden_modules_imported", "tests/unit/contracts/test_forbidden.py::TestForbiddenContract::test_is_broken_when_forbidden_modules_imported", "tests/unit/contracts/test_forbidden.py::TestForbiddenContract::test_is_broken_when_forbidden_external_modules_imported", "tests/unit/contracts/test_forbidden.py::TestForbiddenContract::test_is_invalid_when_forbidden_externals_but_graph_does_not_include_externals", "tests/unit/contracts/test_forbidden.py::TestForbiddenContract::test_ignore_imports_tolerates_duplicates", "tests/unit/contracts/test_forbidden.py::test_render_broken_contract", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_when_modules_are_independent", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_when_root_imports_root_directly", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_when_root_imports_root_indirectly", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_chains_via_other_independent_modules", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_when_child_imports_child", "tests/unit/contracts/test_independence.py::TestIndependenceContract::test_when_grandchild_imports_root", "tests/unit/contracts/test_independence.py::test_ignore_imports[ignore_imports0-False]", "tests/unit/contracts/test_independence.py::test_ignore_imports[ignore_imports1-True]", "tests/unit/contracts/test_independence.py::test_ignore_imports[ignore_imports2-True]", "tests/unit/contracts/test_independence.py::test_render_broken_contract", "tests/unit/contracts/test_independence.py::test_missing_module", "tests/unit/contracts/test_independence.py::test_ignore_imports_tolerates_duplicates", "tests/unit/contracts/test_layers.py::TestLayerContractSingleContainers::test_no_illegal_imports_means_contract_is_kept", "tests/unit/contracts/test_layers.py::TestLayerContractSingleContainers::test_illegal_child_imports_means_contract_is_broken", "tests/unit/contracts/test_layers.py::TestLayerContractSingleContainers::test_illegal_grandchild_to_child_means_contract_is_broken", "tests/unit/contracts/test_layers.py::TestLayerMultipleContainers::test_no_illegal_imports_means_contract_is_kept", "tests/unit/contracts/test_layers.py::TestLayerMultipleContainers::test_imports_from_low_to_high_but_in_different_container_doesnt_break_contract", "tests/unit/contracts/test_layers.py::TestLayerMultipleContainers::test_illegal_grandchild_imports_means_contract_is_broken", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_metadata", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_extra_firsts_one_indirect", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_extra_firsts_two_indirects", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_extra_lasts_one_indirect", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_extra_lasts_two_indirects", "tests/unit/contracts/test_layers.py::TestLayerContractPopulatesMetadata::test_layer_contract_populates_firsts_and_lasts_three_indirects", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_one_ignored_from_each_chain_means_contract_is_kept", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_ignore_only_one_chain_should_fail_because_of_the_other", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_multiple_ignore_from_same_chain_should_not_error", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_ignore_from_nonexistent_importer_raises_missing_import", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_ignore_from_nonexistent_imported_raises_missing_import", "tests/unit/contracts/test_layers.py::TestIgnoreImports::test_ignore_imports_tolerates_duplicates", "tests/unit/contracts/test_layers.py::test_optional_layers[True-False]", "tests/unit/contracts/test_layers.py::test_missing_containerless_layers_raise_value_error", "tests/unit/contracts/test_layers.py::test_render_broken_contract", "tests/unit/contracts/test_layers.py::test_invalid_container[notingraph]", "tests/unit/contracts/test_layers.py::test_invalid_container[notingraph.foo]", "tests/unit/contracts/test_layers.py::test_invalid_container[notinpackage]", "tests/unit/contracts/test_layers.py::test_invalid_container[notinpackage.foo]", "tests/unit/contracts/test_layers.py::test_invalid_container[notinpackage.foo.one]", "tests/unit/contracts/test_layers.py::test_invalid_container[mypackagebeginscorrectly]", "tests/unit/contracts/test_layers.py::test_invalid_container_multiple_packages", "tests/unit/contracts/test_layers.py::TestLayerContractNoContainer::test_no_illegal_imports_means_contract_is_kept", "tests/unit/contracts/test_layers.py::TestLayerContractNoContainer::test_illegal_imports_means_contract_is_broken", "tests/unit/contracts/test_layers.py::TestLayerContractNoContainer::test_no_illegal_imports_across_multiple_root_packages_means_contract_is_kept", "tests/unit/contracts/test_layers.py::TestLayerContractNoContainer::test_illegal_imports_across_multiple_root_packages_means_contract_is_broken", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_no_chains", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_direct_imports_raises_value_error", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_chain_length_2_is_included", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_chain_length_3_is_included", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_multiple_chains_of_length_2_same_segment", "tests/unit/contracts/test_layers.py::TestGetIndirectCollapsedChains::test_multiple_chains_of_length_3_same_segment", "tests/unit/contracts/test_layers.py::TestPopDirectImports::test_direct_import_between_descendants", "tests/unit/contracts/test_layers.py::TestPopDirectImports::test_direct_import_between_roots", "tests/unit/contracts/test_layers.py::TestPopDirectImports::test_direct_import_root_to_descendant", "tests/unit/contracts/test_layers.py::TestPopDirectImports::test_direct_import_descendant_to_root", "tests/unit/domain/test_fields.py::TestStringField::test_field[Hello,", "tests/unit/domain/test_fields.py::TestStringField::test_field[raw_data1-expected_value1]", "tests/unit/domain/test_fields.py::TestModuleField::test_field[mypackage.foo.bar-expected_value0]", "tests/unit/domain/test_fields.py::TestModuleField::test_field[raw_data1-expected_value1]", "tests/unit/domain/test_fields.py::TestDirectImportField::test_field[mypackage.foo", "tests/unit/domain/test_fields.py::TestDirectImportField::test_field[raw_data1-expected_value1]", "tests/unit/domain/test_fields.py::TestListField::test_field[raw_data0-expected_value0]", "tests/unit/domain/test_fields.py::TestListField::test_field[raw_data1-expected_value1]", "tests/unit/domain/test_fields.py::TestListField::test_field[singlevalue-expected_value2]", "tests/unit/domain/test_fields.py::TestSetField::test_field[raw_data0-expected_value0]", "tests/unit/domain/test_fields.py::TestSetField::test_field[raw_data1-expected_value1]", "tests/unit/domain/test_fields.py::TestSetField::test_field[singlevalue-expected_value2]" ]	[]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2020-07-26 10:23:27+00:00	bsd-2-clause	5,460
seek-oss__aec-376	diff --git a/src/aec/__init__.py b/src/aec/__init__.py index a7c8d66..71ed17d 100644 --- a/src/aec/__init__.py +++ b/src/aec/__init__.py @@ -1,1 +1,1 @@ -__version__ = "2.5.5" +__version__ = "2.5.6" diff --git a/src/aec/command/ec2.py b/src/aec/command/ec2.py index d76bbdc..9adc37c 100755 --- a/src/aec/command/ec2.py +++ b/src/aec/command/ec2.py @@ -250,6 +250,10 @@ def tag( parts = t.split("=") tagdefs.append({"Key": parts[0], "Value": parts[1]}) + if not name and not name_match: + # avoid tagging all instances when there's no name + raise NoInstancesError(name=name, name_match=name_match) + instances = describe(config, name, name_match) ids = [i["InstanceId"] for i in instances] @@ -317,6 +321,10 @@ def start(config: Config, name: str) -> List[Instance]: print(f"Starting instances with the name {name} ... ") + if not name: + # avoid starting all instances when there's no name + raise NoInstancesError(name=name) + instances = describe(config, name) if not instances: @@ -336,6 +344,10 @@ def stop(config: Config, name: str) -> List[Dict[str, Any]]: ec2_client = boto3.client("ec2", region_name=config.get("region", None)) + if not name: + # avoid stopping all instances when there's no name + raise NoInstancesError(name=name) + instances = describe(config, name) if not instances: @@ -351,6 +363,10 @@ def terminate(config: Config, name: str) -> List[Dict[str, Any]]: ec2_client = boto3.client("ec2", region_name=config.get("region", None)) + if not name: + # avoid terminating all instances when there's no name + raise NoInstancesError(name=name) + instances = describe(config, name) if not instances: @@ -368,6 +384,10 @@ def modify(config: Config, name: str, type: str) -> List[Instance]: ec2_client = boto3.client("ec2", region_name=config.get("region", None)) + if not name: + # avoid modifying all instances when there's no name + raise NoInstancesError(name=name) + instances = describe(config, name) if not instances: @@ -399,6 +419,10 @@ def logs(config: Config, name: str) -> str: ec2_client = boto3.client("ec2", region_name=config.get("region", None)) + if not name: + # avoid describing all instances when there's no name + raise NoInstancesError(name=name) + instances = describe(config, name) if not instances:	seek-oss/aec	f0b8372ce5e36014c0cba8da94bae9feecb1656a	diff --git a/tests/test_ec2.py b/tests/test_ec2.py index b6ce0ea..0632ec1 100644 --- a/tests/test_ec2.py +++ b/tests/test_ec2.py @@ -357,6 +357,18 @@ def test_terminate(mock_aws_config): terminate(config=mock_aws_config, name="alice") +def test_terminate_empty_name_does_not_delete_all_instances(mock_aws_config): + launch(mock_aws_config, "alice", ami_id) + + with pytest.raises(ValueError) as exc_info: + terminate(config=mock_aws_config, name="") + print(exc_info.value.args[0]) + assert exc_info.value.args[0] == """Missing name or name_match""" + + instances = describe(config=mock_aws_config) + assert len(instances) == 1 + + def test_logs(mock_aws_config): launch(mock_aws_config, "alice", ami_id)	Inadvertant termination of ALL ec2 instances in region I am using aec via a bash script, which because of a configuration error executed `aec ec2 terminate "$instanceId"` with an empty `$instanceId`. This had the rather unfortunate effect of terminating all of the ec2 instances visible to my role in the selected region. Looking at `ec2.py` it looks like the empty `name` argument was passed through to describe which happily returned all of the instances which where then deleted. I think that terminate (and probably start and stop) should probably refuse to operate on more than one instance at a time, or alternatively guard against an empty name filter.	f0b8372ce5e36014c0cba8da94bae9feecb1656a	[ "tests/test_ec2.py::test_terminate_empty_name_does_not_delete_all_instances" ]	[ "tests/test_ec2.py::test_launch", "tests/test_ec2.py::test_launch_template", "tests/test_ec2.py::test_launch_multiple_security_groups", "tests/test_ec2.py::test_launch_without_instance_profile", "tests/test_ec2.py::test_launch_no_region_specified", "tests/test_ec2.py::test_launch_with_ami_match_string", "tests/test_ec2.py::test_override_key_name", "tests/test_ec2.py::test_override_volume_size", "tests/test_ec2.py::test_config_override_volume_size", "tests/test_ec2.py::test_launch_has_userdata", "tests/test_ec2.py::test_describe", "tests/test_ec2.py::test_describe_instance_without_tags", "tests/test_ec2.py::test_tag", "tests/test_ec2.py::test_describe_by_name", "tests/test_ec2.py::test_describe_by_name_match", "tests/test_ec2.py::test_describe_terminated", "tests/test_ec2.py::test_describe_running_only", "tests/test_ec2.py::test_describe_instance_id", "tests/test_ec2.py::test_describe_sort_by", "tests/test_ec2.py::test_describe_columns", "tests/test_ec2.py::test_tags", "tests/test_ec2.py::test_tags_volume", "tests/test_ec2.py::test_tags_filter", "tests/test_ec2.py::test_stop_start", "tests/test_ec2.py::test_modify", "tests/test_ec2.py::test_status", "tests/test_ec2.py::test_terminate", "tests/test_ec2.py::test_logs", "tests/test_ec2.py::test_ebs_encrypted_by_default", "tests/test_ec2.py::test_ebs_encrypt_with_kms", "tests/test_ec2.py::test_create_key_pair" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2022-07-27 08:44:33+00:00	mit	5,461
seequent__methoddispatch-9	diff --git a/README.md b/README.md index ba94edb..68fd599 100644 --- a/README.md +++ b/README.md @@ -2,12 +2,10 @@ [![Build Status](https://travis-ci.com/seequent/methoddispatch.svg?branch=master)](https://travis-ci.com/seequent/methoddispatch) +Python 3.4 added the ``singledispatch`` decorator to the ``functools`` standard library module. +This library extends this functionality to instance methods (and works for functions too). -[PEP 443](http://www.python.org/dev/peps/pep-0443) proposed to expose a mechanism in the ``functools`` standard library module in Python 3.4 that provides a simple form of generic programming known as single-dispatch generic functions. - -This library extends this functionality to instance methods (and works for functions too) - -To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly:: +To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly. >>> from methoddispatch import singledispatch, register, SingleDispatch @@ -110,16 +108,20 @@ Decorating class methods requires the class to inherit from ``SingleDispatch`` 'int' Subclasses can extend the type registry of the function on the base class with their own overrides. -Because the ``foo`` function is not in scope, the ``methoddispatch.register`` decorator must be used instead +Because we do not want to modify the base class ``foo`` registry the ``methoddispatch.register`` decorator must be used instead of ``foo.register``. The module level ``register`` function takes either the method name or the method itself as the first parameter and the dispatch type as the second. >>> class SubClass(BaseClass): ... @register('foo', float) ... def foo_float(self, bar): ... return 'float' ... + ... @register(BaseClass.foo, str) + ... def foo_str(self, bar): + ... return 'str' + ... >>> s = SubClass() - >>> s.foo(1) - 'int' + >>> s.foo('') + 'str' >>> s.foo(1.0) 'float' @@ -144,7 +146,7 @@ Decorating a method override with a different type (not a good idea) will regist In Python 3.7 and later, for functions annotated with types, the decorator will infer the type of the first argument automatically as shown below - >>> class BaseClass(SingleDispatch): + >>> class BaseClassAnno(SingleDispatch): ... @singledispatch ... def foo(self, bar): ... return 'default' @@ -153,13 +155,13 @@ In Python 3.7 and later, for functions annotated with types, the decorator will ... def foo_int(self, bar: int): ... return 'int' ... - >>> class SubClass(BaseClass): + >>> class SubClassAnno(BaseClassAnno): ... @register('foo') ... def foo_float(self, bar: float): ... return 'float' In Python 3.6 and earlier, the ``SingleDispatch`` class uses a meta-class ``SingleDispatchMeta`` to manage the dispatch registries. However in Python 3.7 and later the ``__init_subclass__`` method is used instead. -If your class also inhertits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.6 and earlier. +If your class also inherits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.6 and earlier. Finally, accessing the method ``foo`` via a class will use the dispatch registry for that class diff --git a/methoddispatch/__init__.py b/methoddispatch/__init__.py index 242cd91..ea0cd33 100644 --- a/methoddispatch/__init__.py +++ b/methoddispatch/__init__.py @@ -2,11 +2,12 @@ """ # methoddispatch - [PEP 443](http://www.python.org/dev/peps/pep-0443) proposed to expose a mechanism in the ``functools`` standard library module in Python 3.4 that provides a simple form of generic programming known as single-dispatch generic functions. +[![Build Status](https://travis-ci.com/seequent/methoddispatch.svg?branch=master)](https://travis-ci.com/seequent/methoddispatch) -This library extends this functionality to instance methods (and works for functions too) +Python 3.4 added the ``singledispatch`` decorator to the ``functools`` standard library module. +This library extends this functionality to instance methods (and works for functions too). -To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly:: +To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly. >>> from methoddispatch import singledispatch, register, SingleDispatch @@ -109,16 +110,20 @@ Decorating class methods requires the class to inherit from ``SingleDispatch`` 'int' Subclasses can extend the type registry of the function on the base class with their own overrides. -Because the ``foo`` function is not in scope, the ``methoddispatch.register`` decorator must be used instead +Because we do not want to modify the base class ``foo`` registry the ``methoddispatch.register`` decorator must be used instead of ``foo.register``. The module level ``register`` function takes either the method name or the method itself as the first parameter and the dispatch type as the second. >>> class SubClass(BaseClass): ... @register('foo', float) ... def foo_float(self, bar): ... return 'float' ... + ... @register(BaseClass.foo, str) + ... def foo_str(self, bar): + ... return 'str' + ... >>> s = SubClass() - >>> s.foo(1) - 'int' + >>> s.foo('') + 'str' >>> s.foo(1.0) 'float' @@ -143,7 +148,7 @@ Decorating a method override with a different type (not a good idea) will regist In Python 3.7 and later, for functions annotated with types, the decorator will infer the type of the first argument automatically as shown below - >>> class BaseClass2(SingleDispatch): + >>> class BaseClassAnno(SingleDispatch): ... @singledispatch ... def foo(self, bar): ... return 'default' @@ -152,13 +157,13 @@ In Python 3.7 and later, for functions annotated with types, the decorator will ... def foo_int(self, bar: int): ... return 'int' ... - >>> class SubClass2(BaseClass2): + >>> class SubClassAnno(BaseClassAnno): ... @register('foo') ... def foo_float(self, bar: float): ... return 'float' In Python 3.6 and earlier, the ``SingleDispatch`` class uses a meta-class ``SingleDispatchMeta`` to manage the dispatch registries. However in Python 3.7 and later the ``__init_subclass__`` method is used instead. -If your class also inhertits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.6 and earlier. +If your class also inherits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.6 and earlier. Finally, accessing the method ``foo`` via a class will use the dispatch registry for that class diff --git a/methoddispatch/methoddispatch2.py b/methoddispatch/methoddispatch2.py index df42610..d136ad4 100644 --- a/methoddispatch/methoddispatch2.py +++ b/methoddispatch/methoddispatch2.py @@ -265,17 +265,20 @@ class sd_method(object): return self.dispatch(args[0].__class__)(self._instance, args, kwargs) -def _fixup_class_attributes(attributes, bases): +def _fixup_class_attributes(cls): generics = [] - for base in bases: + attributes = cls.__dict__ + patched = set() + for base in cls.mro()[1:]: if isinstance(base, SingleDispatchMeta): for name, value in base.__dict__.items(): - if isinstance(value, singledispatch): + if isinstance(value, singledispatch) and name not in patched: if name in attributes: raise RuntimeError('Cannot override generic function. ' - 'Try @register({}, object) instead.'.format(name)) + 'Try @register("{}", object) instead.'.format(name)) generic = value.copy() - attributes[name] = generic + setattr(cls, name, generic) + patched.add(name) generics.append(generic) for name, value in attributes.items(): if not callable(value) or isinstance(value, singledispatch): @@ -298,8 +301,8 @@ class SingleDispatchMeta(type): so that registered types on sub-classes do not modify the base class. """ def __new__(mcs, clsname, bases, attributes): - _fixup_class_attributes(attributes, bases) cls = super(SingleDispatchMeta, mcs).__new__(mcs, clsname, bases, attributes) + _fixup_class_attributes(cls) return cls @@ -317,9 +320,10 @@ class SingleDispatchABC(object): def register(name, cls): """ Decorator for methods on a sub-class to register an overload on a base-class generic method - name is the name of the generic method on the base class - cls is the type to register + :param name: is the name of the generic method on the base class, or the unbound method itself + :param cls: is the type to register """ + name = getattr(name, '__name__', name) # __name__ exists on sd_method courtesy of update_wrapper def wrapper(func): overloads = getattr(func, 'overloads', []) overloads.append((name, cls)) diff --git a/methoddispatch/methoddispatch3.py b/methoddispatch/methoddispatch3.py index 7efe791..bb82d51 100644 --- a/methoddispatch/methoddispatch3.py +++ b/methoddispatch/methoddispatch3.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # -- coding: utf-8 -- from abc import get_cache_token, ABCMeta -from functools import update_wrapper, _find_impl, _c3_mro +from functools import update_wrapper, _find_impl from types import MappingProxyType from weakref import WeakKeyDictionary @@ -111,15 +111,17 @@ class sd_method(object): def _fixup_class_attributes(cls): generics = [] attributes = cls.__dict__ + patched = set() for base in cls.mro()[1:]: if isinstance(base, SingleDispatchMeta): for name, value in base.__dict__.items(): - if isinstance(value, singledispatch): + if isinstance(value, singledispatch) and name not in patched: if name in attributes: raise RuntimeError('Cannot override generic function. ' - 'Try @register({}, object) instead.'.format(name)) + 'Try @register("{}", object) instead.'.format(name)) generic = value.copy() setattr(cls, name, generic) + patched.add(name) generics.append(generic) for name, value in attributes.items(): if not callable(value) or isinstance(value, singledispatch): @@ -158,12 +160,12 @@ class SingleDispatch(metaclass=SingleDispatchMeta): class SingleDispatchABC(metaclass=SingleDispatchABCMeta): pass - def register(name, cls): - """ Decorator for methods on a sub-class to register an overload on a base-class generic method - name is the name of the generic method on the base class - cls is the type to register + """ Decorator for methods on a sub-class to register an overload on a base-class generic method. + :param name: is the name of the generic method on the base class, or the unbound method itself + :param cls: is the type to register """ + name = getattr(name, '__name__', name) # __name__ exists on sd_method courtesy of update_wrapper def wrapper(func): overloads = getattr(func, 'overloads', []) overloads.append((name, cls)) diff --git a/methoddispatch/methoddispatch37.py b/methoddispatch/methoddispatch37.py index 6c5e80c..06be769 100644 --- a/methoddispatch/methoddispatch37.py +++ b/methoddispatch/methoddispatch37.py @@ -84,7 +84,7 @@ class singledispatch(object): def __get__(self, instance, cls=None): if cls is not None and not issubclass(cls, SingleDispatch): - raise ValueError('singledispatch can only be used on methods of SingleDispatchMeta types') + raise ValueError('singledispatch can only be used on methods of SingleDispatch subclasses') wrapper = sd_method(self, instance) update_wrapper(wrapper, self.func) return wrapper @@ -124,40 +124,46 @@ class sd_method(object): return self.dispatch(args[0].__class__)(self._instance, args, kwargs) +def _fixup_class_attributes(cls): + generics = [] + attributes = cls.__dict__ + patched = set() + for base in cls.mro()[1:]: + if issubclass(base, SingleDispatch): + for name, value in base.__dict__.items(): + if isinstance(value, singledispatch) and name not in patched: + if name in attributes: + raise RuntimeError('Cannot override generic function. ' + 'Try @register("{}", object) instead.'.format(name)) + generic = value.copy() + setattr(cls, name, generic) + patched.add(name) + generics.append(generic) + for name, value in attributes.items(): + if not callable(value) or isinstance(value, singledispatch): + continue + if hasattr(value, 'overloads'): + for generic_name, cls in value.overloads: + generic = attributes[generic_name] + if cls is None: + generic.register(value) + else: + generic.register(cls, value) + else: # register over-ridden methods + for generic in generics: + for cls, f in generic.registry.items(): + if name == f.__name__: + generic.register(cls, value) + break + + class SingleDispatch(object): """ Base or mixin class to enable single dispatch on methods. """ def __init_subclass__(cls, kwargs): super().__init_subclass__(**kwargs) - generics = [] - attributes = cls.__dict__ - for base in cls.mro()[1:]: - if issubclass(base, SingleDispatch): - for name, value in base.__dict__.items(): - if isinstance(value, singledispatch): - if name in attributes: - raise RuntimeError('Cannot override generic function. ' - 'Try @register("{}", object) instead.'.format(name)) - generic = value.copy() - setattr(cls, name, generic) - generics.append(generic) - for name, value in attributes.items(): - if not callable(value) or isinstance(value, singledispatch): - continue - if hasattr(value, 'overloads'): - for generic_name, cls in value.overloads: - generic = attributes[generic_name] - if cls is None: - generic.register(value) - else: - generic.register(cls, value) - else: # register over-ridden methods - for generic in generics: - for cls, f in generic.registry.items(): - if name == f.__name__: - generic.register(cls, value) - break + _fixup_class_attributes(cls) SingleDispatchABC = SingleDispatch # for backwards compatibility @@ -165,9 +171,10 @@ SingleDispatchABC = SingleDispatch # for backwards compatibility def register(name, cls=None): """ Decorator for methods on a sub-class to register an overload on a base-class generic method. - :param name: is the name of the generic method on the base class + :param name: is the name of the generic method on the base class, or the unbound method itself :param cls: is the type to register or may be omitted or None to use the annotated parameter type. """ + name = getattr(name, '__name__', name) # __name__ exists on sd_method courtesy of update_wrapper def wrapper(func): overloads = getattr(func, 'overloads', []) overloads.append((name, cls))	seequent/methoddispatch	233ca14427acd92bb3a0bcf734c171b6cb1f36a6	diff --git a/test.py b/test.py index 4de209f..66710aa 100644 --- a/test.py +++ b/test.py @@ -27,6 +27,15 @@ class SubClass(BaseClass): def foo_int(self, bar): return 'sub int' + @register(BaseClass.foo, str) + def foo_str(self, bar): + return 'str' + +class SubSubClass(SubClass): + @register('foo', list) + def foo_list(self, bar): + return 'list' + @six.add_metaclass(abc.ABCMeta) class IFoo(object): @@ -64,9 +73,18 @@ class TestMethodDispatch(unittest.TestCase): def test_sub_class(self): s = SubClass() - self.assertEqual(s.foo('text'), 'default') + self.assertEqual(s.foo([]), 'default') + self.assertEqual(s.foo(1), 'sub int') + self.assertEqual(s.foo(1.0), 'float') + self.assertEqual(s.foo(''), 'str') + + def test_sub_sub_class(self): + # this checks that we are using MRO and not just bases. + s = SubSubClass() + self.assertEqual(s.foo([]), 'list') self.assertEqual(s.foo(1), 'sub int') self.assertEqual(s.foo(1.0), 'float') + self.assertEqual(s.foo(''), 'str') def test_independence(self): b = BaseClass() @@ -100,7 +118,7 @@ class TestMethodDispatch(unittest.TestCase): self.assertTrue(hasattr(SubClass.foo, 'dispatch')) self.assertTrue(hasattr(SubClass.foo, 'registry')) self.assertIs(SubClass.foo.dispatch(float), SubClass.__dict__['foo_float']) - self.assertEqual(set(SubClass.foo.registry.keys()), set([float, object, int])) + self.assertEqual(set(SubClass.foo.registry.keys()), set([float, object, int, str])) def test_instance_extra_attributes(self): """ Check that dispatch and registry attributes are accessible """ @@ -108,7 +126,7 @@ class TestMethodDispatch(unittest.TestCase): self.assertTrue(hasattr(s.foo, 'dispatch')) self.assertTrue(hasattr(s.foo, 'registry')) self.assertIs(s.foo.dispatch(float), SubClass.__dict__['foo_float']) - self.assertEqual(set(s.foo.registry.keys()), set([float, object, int])) + self.assertEqual(set(s.foo.registry.keys()), set([float, object, int, str])) @unittest.skipIf(six.PY2, 'docs are in python3 syntax') def test_docs(self): @@ -119,10 +137,10 @@ class TestMethodDispatch(unittest.TestCase): @unittest.skipIf(sys.version_info < (3, 7), 'python < 3.7') def test_annotations(self): - exec(py_37_tests) + exec(annotation_tests) -py_37_tests = """ +annotation_tests = """ def test_annotations(self): class AnnClass(BaseClass): @register('foo')	Allow passing method object to register You can't navigate from a string to the method you are dispatching. permit: ``` class SubClass(BaseClass): @register(BaseClass.foo, int) def foo_int(self, bar): ... ```	233ca14427acd92bb3a0bcf734c171b6cb1f36a6	[ "test.py::TestMethodDispatch::test_abc_interface_support", "test.py::TestMethodDispatch::test_annotations", "test.py::TestMethodDispatch::test_attempted_override", "test.py::TestMethodDispatch::test_base_class", "test.py::TestMethodDispatch::test_class_access", "test.py::TestMethodDispatch::test_class_extra_attributes", "test.py::TestMethodDispatch::test_docs", "test.py::TestMethodDispatch::test_independence", "test.py::TestMethodDispatch::test_instance_extra_attributes", "test.py::TestMethodDispatch::test_pure_funcs", "test.py::TestMethodDispatch::test_sub_class", "test.py::TestMethodDispatch::test_sub_sub_class" ]	[]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2018-07-03 02:57:32+00:00	bsd-3-clause	5,462
seequent__pure_interface-48	diff --git a/pure_interface.py b/pure_interface.py index ab4c2e0..8643394 100644 --- a/pure_interface.py +++ b/pure_interface.py @@ -755,6 +755,44 @@ def register_adapter(adapter, from_type, to_interface): adapters[from_type] = weakref.ref(adapter, on_gone) +class AdapterTracker(object): + """ The idiom of checking if `x is b` is broken for adapted objects because a new adapter is potentially + instantiated each time x or b is adapted. Also in some context we adapt the same objects many times and don't + want the overhead of lots of copies. This class provides adapt() and adapt_or_none() methods that track adaptions. + Thus if `x is b` is `True` then `adapter.adapt(x, I) is adapter.adapt(b, I)` is `True`. + """ + def __init__(self, mapping_factory=dict): + self._factory = mapping_factory + self._adapters = mapping_factory() + + def adapt(self, obj, interface): + """ Adapts `obj` to `interface`""" + try: + return self._adapters[interface][obj] + except KeyError: + return self._adapt(obj, interface) + + def adapt_or_none(self, obj, interface): + """ Adapt obj to interface returning None on failure.""" + try: + return self.adapt(obj, interface) + except ValueError: + return None + + def clear(self): + """ Clears the cached adapters.""" + self._adapters = self._factory() + + def _adapt(self, obj, interface): + adapted = interface.adapt(obj) + try: + adapters = self._adapters[interface] + except KeyError: + adapters = self._adapters[interface] = self._factory() + adapters[obj] = adapted + return adapted + + def type_is_pure_interface(cls): # type: (Type[Any]) -> bool """ Return True if cls is a pure interface"""	seequent/pure_interface	a65ae43cec46701249104cafeea6aec09a95628d	diff --git a/tests/test_tracker.py b/tests/test_tracker.py new file mode 100644 index 0000000..3bea47e --- /dev/null +++ b/tests/test_tracker.py @@ -0,0 +1,86 @@ +# -- coding: utf-8 -- +from __future__ import absolute_import, division, print_function, unicode_literals + +import unittest + +from pure_interface import * + + +class ISpeaker(PureInterface): + def speak(self, volume): + pass + + +class ISleeper(PureInterface): + is_asleep = None + + +class Talker(object): + def __init__(self, saying='talk'): + self._saying = saying + + def talk(self): + return self._saying + + +class Sleeper(Concrete, ISleeper): + def __init__(self, is_asleep=False): + self.is_asleep = is_asleep + + +@adapts(Talker, ISleeper) +def talker_to_sleeper(talker): + return Sleeper(talker.talk() == 'zzz') + + +@adapts(Talker) +class TalkerToSpeaker(Concrete, ISpeaker): + def __init__(self, talker): + self._talker = talker + + def speak(self, volume): + return self._talker.talk() + + +class TestAdapterTracker(unittest.TestCase): + def test_adapt_is_same(self): + tracker = AdapterTracker() + t = Talker() + + speaker1 = tracker.adapt(t, ISpeaker) + speaker2 = tracker.adapt(t, ISpeaker) + self.assertIsInstance(speaker1, ISpeaker) + self.assertIsInstance(speaker2, ISpeaker) + self.assertIs(speaker1, speaker2) + + def test_adapt_multiple_interfaces(self): + tracker = AdapterTracker() + t = Talker() + + speaker = tracker.adapt(t, ISpeaker) + sleeper = tracker.adapt(t, ISleeper) + self.assertIsInstance(speaker, ISpeaker) + self.assertIsInstance(sleeper, ISleeper) + + def test_adapt_multiple_instances(self): + tracker = AdapterTracker() + t1 = Talker('hello') + t2 = Talker('zzz') + + speaker1 = tracker.adapt(t1, ISpeaker) + speaker2 = tracker.adapt(t2, ISpeaker) + self.assertEqual('hello', speaker1.speak(5)) + self.assertEqual('zzz', speaker2.speak(5)) + + def test_mapping_factory_is_used(self): + mocks = [] + + def factory(): + mocks.append(dict()) + return mocks[-1] + + tracker = AdapterTracker(mapping_factory=factory) + t = Talker('hello') + + tracker.adapt(t, ISpeaker) + self.assertTrue(len(mocks) > 1)	Add adapter tracking class This idiom of checking if `x is b` is broken for adapted objects because a new adapter is potentially instantiated each time x or b is adapted. Add a class for tracking and re-using adapters for use in contexts where this is required. Starting point: ``` class InterfaceAdapter(object): def __init__(self, interface, mapping_factory=weakref.WeakValueDictionary): self._factory = mapping_factory self._interface = interface self._adapters = mapping_factory() def clear(self): self._adapters = self._factory() def adapt(self, obj): try: return self._adapters[obj] except KeyError: adapted = self._interface.adapt(obj) self._adapters[obj] = adapted return adapted def adapt_or_none(self, obj): try: return self.adapt(obj) except ValueError: return None ``` Should use weak value dict for mapping.	a65ae43cec46701249104cafeea6aec09a95628d	[ "tests/test_tracker.py::TestAdapterTracker::test_adapt_is_same", "tests/test_tracker.py::TestAdapterTracker::test_adapt_multiple_instances", "tests/test_tracker.py::TestAdapterTracker::test_adapt_multiple_interfaces", "tests/test_tracker.py::TestAdapterTracker::test_mapping_factory_is_used" ]	[]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2019-04-12 00:41:54+00:00	mit	5,463
seequent__pure_interface-54	diff --git a/.gitignore b/.gitignore index 4fbf9db..4dc0b15 100644 --- a/.gitignore +++ b/.gitignore @@ -93,3 +93,9 @@ ENV/ # PyCharm .idea/ + +# MyPy +.mypy_cache/ + +# build output +dist/ diff --git a/pure_interface.py b/pure_interface.py index c3d38f8..511959e 100644 --- a/pure_interface.py +++ b/pure_interface.py @@ -40,7 +40,7 @@ else: super(abstractstaticmethod, self).__init__(callable) -__version__ = '3.4.0' +__version__ = '3.4.1' is_development = not hasattr(sys, 'frozen') @@ -473,13 +473,13 @@ class PureInterfaceType(abc.ABCMeta): * if the type is a concrete class then patch the abstract properties with AttributeProperies. """ - def __new__(mcs, clsname, bases, attributes): + def __new__(mcs, clsname, bases, attributes, kwargs): # PureInterface is not in globals() when we are constructing the PureInterface class itself. has_interface = any(PureInterface in base.mro() for base in bases) if 'PureInterface' in globals() else True if not has_interface: # Don't interfere if meta class is only included to permit interface inheritance, # but no actual interface is being used. - cls = super(PureInterfaceType, mcs).__new__(mcs, clsname, bases, attributes) + cls = super(PureInterfaceType, mcs).__new__(mcs, clsname, bases, attributes, kwargs) cls._pi = _PIAttributes(False, (), {}, ()) return cls @@ -546,7 +546,7 @@ class PureInterfaceType(abc.ABCMeta): 'pi_partial_implementation attribute, not it''s value') # create class - cls = super(PureInterfaceType, mcs).__new__(mcs, clsname, bases, namespace) + cls = super(PureInterfaceType, mcs).__new__(mcs, clsname, bases, namespace, **kwargs) cls._pi = _PIAttributes(type_is_interface, abstract_properties, interface_method_signatures, interface_attribute_names) diff --git a/setup.py b/setup.py index d28b81f..1304da6 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ from setuptools import setup setup( name='pure_interface', - version='3.4.0', + version='3.4.1', py_modules=['pure_interface', 'pure_contracts'], url='https://github.com/aranzgeo/pure_interface', install_requires=['six', 'typing'],	seequent/pure_interface	d3717fad8acb27d8f71a9fee7d9de798fdee8c16	diff --git a/tests/test_py3/test_impl3_checks.py b/tests/test_py3/test_impl3_checks.py index c936bab..12b7404 100644 --- a/tests/test_py3/test_impl3_checks.py +++ b/tests/test_py3/test_impl3_checks.py @@ -22,3 +22,16 @@ class TestImplementationChecks(unittest.TestCase): self.assertIn('a', get_interface_attribute_names(IAnnotation)) self.assertIn('b', get_interface_attribute_names(IAnnotation)) + + def test_works_with_init_subclass_kwargs(self): + saved_kwargs = {} + + class ReceivesClassKwargs: + def __init_subclass__(cls, **kwargs): + super().__init_subclass__() + saved_kwargs.update(kwargs) + + class Receiver(ReceivesClassKwargs, PureInterface, x=1, y=2, z=3): + pass + + self.assertEqual(saved_kwargs, dict(x=1, y=2, z=3))	PI does not work with __init_subclass__ with kwargs See this case for the related ABC change that was made in 3.7: [https://bugs.python.org/issue29581](url) Since __init_subclass__ landed into 3.6, it's now possible to define classes that support arbitrary keyword arguments in the class definition, like: `class Foo(Bar, Baz=True):` However, these kwargs need to be handled by __new__ and passed along (eventually) to init subclass. Currently classes that are PIType do not support this and give a TypeError on declaration. Simply patching new to pass the kwargs through seems to do the job: [pi_kwargs.zip](https://github.com/seequent/pure_interface/files/3105569/pi_kwargs.zip)	d3717fad8acb27d8f71a9fee7d9de798fdee8c16	[ "tests/test_py3/test_impl3_checks.py::TestImplementationChecks::test_works_with_init_subclass_kwargs" ]	[ "tests/test_py3/test_impl3_checks.py::TestImplementationChecks::test_annotations", "tests/test_py3/test_impl3_checks.py::TestImplementationChecks::test_annotations2" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2019-04-23 03:04:59+00:00	mit	5,464
sendgrid__sendgrid-python-233	diff --git a/sendgrid/helpers/mail/mail.py b/sendgrid/helpers/mail/mail.py index 48d25f1..661c036 100644 --- a/sendgrid/helpers/mail/mail.py +++ b/sendgrid/helpers/mail/mail.py @@ -117,7 +117,11 @@ class Mail(object): def add_header(self, header): if self.headers is None: self.headers = [] - self.headers.append(header) + if isinstance(header, dict): + (k,v) = list(header.items())[0] + self.headers.append(Header(k,v)) + else: + self.headers.append(header) def add_category(self, category): if self.categories is None:	sendgrid/sendgrid-python	ca96c8dcd66224e13b38ab8fd2d2b429dd07dd02	diff --git a/test/test_mail.py b/test/test_mail.py index e0dc945..9b482dc 100644 --- a/test/test_mail.py +++ b/test/test_mail.py @@ -100,6 +100,8 @@ class UnitTests(unittest.TestCase): mail.add_header(Header("X-Test1", "test1")) mail.add_header(Header("X-Test3", "test2")) + mail.add_header({"X-Test4" : "test4"}) + mail.add_category(Category("May")) mail.add_category(Category("2016")) @@ -131,4 +133,4 @@ class UnitTests(unittest.TestCase): mail.set_reply_to(Email("[email protected]")) - self.assertEqual(json.dumps(mail.get(), sort_keys=True), '{"asm": {"group_id": 99, "groups_to_display": [4, 5, 6, 7, 8]}, "attachments": [{"content": "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4gQ3JhcyBwdW12", "content_id": "Balance Sheet", "disposition": "attachment", "filename": "balance_001.pdf", "type": "application/pdf"}, {"content": "BwdW", "content_id": "Banner", "disposition": "inline", "filename": "banner.png", "type": "image/png"}], "batch_id": "sendgrid_batch_id", "categories": ["May", "2016"], "content": [{"type": "text/plain", "value": "some text here"}, {"type": "text/html", "value": "<html><body>some text here</body></html>"}], "custom_args": {"campaign": "welcome", "weekday": "morning"}, "from": {"email": "[email protected]", "name": "Example User"}, "headers": {"X-Test1": "test1", "X-Test3": "test2"}, "ip_pool_name": "24", "mail_settings": {"bcc": {"email": "[email protected]", "enable": true}, "bypass_list_management": {"enable": true}, "footer": {"enable": true, "html": "<html><body>Footer Text</body></html>", "text": "Footer Text"}, "sandbox_mode": {"enable": true}, "spam_check": {"enable": true, "post_to_url": "https://spamcatcher.sendgrid.com", "threshold": 1}}, "personalizations": [{"bcc": [{"email": "[email protected]"}, {"email": "[email protected]"}], "cc": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}], "custom_args": {"type": "marketing", "user_id": "343"}, "headers": {"X-Mock": "true", "X-Test": "test"}, "send_at": 1443636843, "subject": "Hello World from the Personalized SendGrid Python Library", "substitutions": {"%city%": "Denver", "%name%": "Example User"}, "to": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}]}, {"bcc": [{"email": "[email protected]"}, {"email": "[email protected]"}], "cc": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}], "custom_args": {"type": "marketing", "user_id": "343"}, "headers": {"X-Mock": "true", "X-Test": "test"}, "send_at": 1443636843, "subject": "Hello World from the Personalized SendGrid Python Library", "substitutions": {"%city%": "Denver", "%name%": "Example User"}, "to": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}]}], "reply_to": {"email": "[email protected]"}, "sections": {"%section1%": "Substitution Text for Section 1", "%section2%": "Substitution Text for Section 2"}, "send_at": 1443636842, "subject": "Hello World from the SendGrid Python Library", "template_id": "13b8f94f-bcae-4ec6-b752-70d6cb59f932", "tracking_settings": {"click_tracking": {"enable": true, "enable_text": true}, "ganalytics": {"enable": true, "utm_campaign": "some campaign", "utm_content": "some content", "utm_medium": "some medium", "utm_source": "some source", "utm_term": "some term"}, "open_tracking": {"enable": true, "substitution_tag": "Optional tag to replace with the open image in the body of the message"}, "subscription_tracking": {"enable": true, "html": "<html><body>html to insert into the text/html portion of the message</body></html>", "substitution_tag": "Optional tag to replace with the open image in the body of the message", "text": "text to insert into the text/plain portion of the message"}}}') + self.assertEqual(json.dumps(mail.get(), sort_keys=True), '{"asm": {"group_id": 99, "groups_to_display": [4, 5, 6, 7, 8]}, "attachments": [{"content": "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4gQ3JhcyBwdW12", "content_id": "Balance Sheet", "disposition": "attachment", "filename": "balance_001.pdf", "type": "application/pdf"}, {"content": "BwdW", "content_id": "Banner", "disposition": "inline", "filename": "banner.png", "type": "image/png"}], "batch_id": "sendgrid_batch_id", "categories": ["May", "2016"], "content": [{"type": "text/plain", "value": "some text here"}, {"type": "text/html", "value": "<html><body>some text here</body></html>"}], "custom_args": {"campaign": "welcome", "weekday": "morning"}, "from": {"email": "[email protected]", "name": "Example User"}, "headers": {"X-Test1": "test1", "X-Test3": "test2", "X-Test4": "test4"}, "ip_pool_name": "24", "mail_settings": {"bcc": {"email": "[email protected]", "enable": true}, "bypass_list_management": {"enable": true}, "footer": {"enable": true, "html": "<html><body>Footer Text</body></html>", "text": "Footer Text"}, "sandbox_mode": {"enable": true}, "spam_check": {"enable": true, "post_to_url": "https://spamcatcher.sendgrid.com", "threshold": 1}}, "personalizations": [{"bcc": [{"email": "[email protected]"}, {"email": "[email protected]"}], "cc": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}], "custom_args": {"type": "marketing", "user_id": "343"}, "headers": {"X-Mock": "true", "X-Test": "test"}, "send_at": 1443636843, "subject": "Hello World from the Personalized SendGrid Python Library", "substitutions": {"%city%": "Denver", "%name%": "Example User"}, "to": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}]}, {"bcc": [{"email": "[email protected]"}, {"email": "[email protected]"}], "cc": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}], "custom_args": {"type": "marketing", "user_id": "343"}, "headers": {"X-Mock": "true", "X-Test": "test"}, "send_at": 1443636843, "subject": "Hello World from the Personalized SendGrid Python Library", "substitutions": {"%city%": "Denver", "%name%": "Example User"}, "to": [{"email": "[email protected]", "name": "Example User"}, {"email": "[email protected]", "name": "Example User"}]}], "reply_to": {"email": "[email protected]"}, "sections": {"%section1%": "Substitution Text for Section 1", "%section2%": "Substitution Text for Section 2"}, "send_at": 1443636842, "subject": "Hello World from the SendGrid Python Library", "template_id": "13b8f94f-bcae-4ec6-b752-70d6cb59f932", "tracking_settings": {"click_tracking": {"enable": true, "enable_text": true}, "ganalytics": {"enable": true, "utm_campaign": "some campaign", "utm_content": "some content", "utm_medium": "some medium", "utm_source": "some source", "utm_term": "some term"}, "open_tracking": {"enable": true, "substitution_tag": "Optional tag to replace with the open image in the body of the message"}, "subscription_tracking": {"enable": true, "html": "<html><body>html to insert into the text/html portion of the message</body></html>", "substitution_tag": "Optional tag to replace with the open image in the body of the message", "text": "text to insert into the text/plain portion of the message"}}}')	Using .add_header() raises a TypeError ### Issue Summary .add_header() cannot be used because python raises a TypeError exception. ### Steps to Reproduce 1. Create an instance of Mail `mail = Mail( Email(from_email), subject, Email(to_emails), Content('text/html', message) )` 2. Add a header to the instance `mail.add_header( {'Reply-To' : '[email protected], [email protected]'} )` 3. Send the Request `response = sg.client.mail.send.post(request_body=mail.get())` ### Stack Trace [File "mail.py", line 63](https://github.com/sendgrid/sendgrid-python/blob/master/sendgrid/helpers/mail/mail.py#L63), in get > headers.update(key.get()) TypeError: get expected at least 1 arguments, got 0	ca96c8dcd66224e13b38ab8fd2d2b429dd07dd02	[ "test/test_mail.py::UnitTests::test_kitchenSink" ]	[ "test/test_mail.py::UnitTests::test_helloEmail" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2016-10-11 13:11:27+00:00	mit	5,465
sendgrid__sendgrid-python-348	diff --git a/sendgrid/helpers/mail/mail.py b/sendgrid/helpers/mail/mail.py index de41bad..a2159b2 100644 --- a/sendgrid/helpers/mail/mail.py +++ b/sendgrid/helpers/mail/mail.py @@ -262,11 +262,15 @@ class Email(object): def __init__(self, email=None, name=None): self._name = None self._email = None - - if email is not None: - self.email = email - if name is not None: - self.name = name + if name or email: + if not name: + # allows passing emails as "dude Fella <[email protected]>" + self.parse_email(email) + else: + #allows backwards compatibility for Email(email, name) + if email is not None: + self.email = email + self.name = name @property def name(self): @@ -293,6 +297,28 @@ class Email(object): email["email"] = self.email return email + def parse_email(self, email_info): + try: + import rfc822 + except ImportError: + import email.utils as rfc822 + + name, email = rfc822.parseaddr(email_info) + + # more than likely a string was passed here instead of an email address + if "@" not in email: + name = email + email = None + + if not name: + name = None + + if not email: + email = None + + self.name = name + self.email = email + return name, email class Content(object):	sendgrid/sendgrid-python	08845196565bee2cdc1efafdd9d27018c2530eea	diff --git a/test/test_email.py b/test/test_email.py new file mode 100644 index 0000000..92ae10a --- /dev/null +++ b/test/test_email.py @@ -0,0 +1,59 @@ +# -- coding: utf-8 -- +import json + +from sendgrid.helpers.mail import (Email) + +try: + import unittest2 as unittest +except ImportError: + import unittest + + +class TestEmailObject(unittest.TestCase): + def test_add_email_address(self): + address = "[email protected]" + email = Email(address) + + self.assertEqual(email.email, "[email protected]") + + def test_add_name(self): + name = "SomeName" + email = Email(name=name) + + self.assertEqual(email.name, name) + + def test_add_name_email(self): + name = "SomeName" + address = "[email protected]" + email = Email(email=address, name=name) + self.assertEqual(email.name, name) + self.assertEqual(email.email, "[email protected]") + + def test_add_rfc_function_finds_name_not_email(self): + name = "SomeName" + email = Email(name) + + self.assertEqual(email.name, name) + self.assertIsNone(email.email) + + def test_add_rfc_email(self): + name = "SomeName" + address = "[email protected]" + name_address = "{0} <{1}>".format(name, address) + email = Email(name_address) + self.assertEqual(email.name, name) + self.assertEqual(email.email, "[email protected]") + + def test_empty_obj_add_name(self): + email = Email() + name = "SomeName" + email.name = name + + self.assertEqual(email.name, name) + + def test_empty_obj_add_email(self): + email = Email() + address = "[email protected]" + email.email = address + + self.assertEqual(email.email, address) \ No newline at end of file	Inconsistent format of email from header “name <email>” #### Issue Summary Current implementation restrict use default `email_from` behavior. For more info please see https://tools.ietf.org/html/rfc2822#section-3.4 #### Steps to Reproduce 1. When user try to create `Email` instance from https://github.com/sendgrid/sendgrid-python/blob/master/sendgrid/helpers/mail/mail.py#L173-L179. You must specify `from_email` and `from_name` as seperate parametrs ``` def get(self): email = {} if self.name != None: email["name"] = self.name if self.email != None: email["email"] = self.email return email from_email = Email("[email protected]", "Example Name") ``` As a result client should split `from_email`: ``` try: import rfc822 except ImportError: import email.utils as rfc822 from_name, from_email = rfc822.parseaddr(email.from_email) # Python sendgrid client should improve # sendgrid/helpers/mail/mail.py:164 if not from_name: from_name = None Mail(from_email, from_name) ``` Proposal to how to improve this bahaviour. Because if user now create `Email` from: ``` from_email = Email("Andrii Soldatenko <[email protected]>") ``` Actual result: ![image](https://cloud.githubusercontent.com/assets/1374633/20647168/e2159a04-b495-11e6-95f9-20c2bb5fc21f.png) #### Technical details: * sendgrid-python Version: master * Python Version: all #### References: - https://github.com/sendgrid/sendgrid-python/issues/277 - RFC: https://tools.ietf.org/html/rfc2822#section-3.4 - Django docs: https://docs.djangoproject.com/en/1.10/topics/email/#emailmessage-objects NOTE: In `sengrid-python==1.4` this feature is working	08845196565bee2cdc1efafdd9d27018c2530eea	[ "test/test_email.py::TestEmailObject::test_add_rfc_email", "test/test_email.py::TestEmailObject::test_add_rfc_function_finds_name_not_email" ]	[ "test/test_email.py::TestEmailObject::test_add_email_address", "test/test_email.py::TestEmailObject::test_add_name", "test/test_email.py::TestEmailObject::test_add_name_email", "test/test_email.py::TestEmailObject::test_empty_obj_add_email", "test/test_email.py::TestEmailObject::test_empty_obj_add_name" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_media" ], "has_test_patch": true, "is_lite": false }	2017-10-01 18:30:18+00:00	mit	5,466
sendgrid__sendgrid-python-454	diff --git a/sendgrid/helpers/mail/mail.py b/sendgrid/helpers/mail/mail.py index 116afb4..7d131f4 100644 --- a/sendgrid/helpers/mail/mail.py +++ b/sendgrid/helpers/mail/mail.py @@ -293,7 +293,14 @@ class Mail(object): :type content: Content """ - self._contents.append(content) + if self._contents is None: + self._contents = [] + + # Text content should be before HTML content + if content._type == "text/plain": + self._contents.insert(0, content) + else: + self._contents.append(content) @property def attachments(self):	sendgrid/sendgrid-python	718ff6a1f91f7696b25c4ffd5b1dff9892e76f54	diff --git a/test/test_mail.py b/test/test_mail.py index 8b88f5b..0941fa7 100644 --- a/test/test_mail.py +++ b/test/test_mail.py @@ -68,6 +68,39 @@ class UnitTests(unittest.TestCase): self.assertTrue(isinstance(str(mail), str)) + def test_helloEmailAdditionalContent(self): + """Tests bug found in Issue-451 with Content ordering causing a crash""" + + self.maxDiff = None + + """Minimum required to send an email""" + mail = Mail() + + mail.from_email = Email("[email protected]") + + mail.subject = "Hello World from the SendGrid Python Library" + + personalization = Personalization() + personalization.add_to(Email("[email protected]")) + mail.add_personalization(personalization) + + mail.add_content(Content("text/html", "<html><body>some text here</body></html>")) + mail.add_content(Content("text/plain", "some text here")) + + self.assertEqual( + json.dumps( + mail.get(), + sort_keys=True), + '{"content": [{"type": "text/plain", "value": "some text here"}, ' + '{"type": "text/html", ' + '"value": "<html><body>some text here</body></html>"}], ' + '"from": {"email": "[email protected]"}, "personalizations": ' + '[{"to": [{"email": "[email protected]"}]}], ' + '"subject": "Hello World from the SendGrid Python Library"}' + ) + + self.assertTrue(isinstance(str(mail), str)) + def test_kitchenSink(self): self.maxDiff = None	text/plain must precede text/html content #### Issue Summary Requests to send mail with both plain text and HTML content fail if the HTML content is specified first. #### Code ``` sg = sendgrid.SendGridAPIClient(apikey=sendgrid_key) mail = Mail() from_email = Email("[email protected]") to_email = Email("[email protected]") subject = "Sending with SendGrid is Fun" per = Personalization() mail.from_email = from_email mail.subject = subject html_content = Content("text/html", "<html><body>some text here</body></html>") plain_content = Content("text/plain", "and easy to do anywhere, even with Python") ### Add plain content first mail.add_content(plain_content) ### Add HTML content next mail.add_content(html_content) per.add_to(to_email) mail.add_personalization(per) response = sg.client.mail.send.post(request_body=mail.get()) ``` #### Steps to Reproduce 1. The above code works properly, but if you reverse the order of the add_content lines, http-client throws a BadRequestsError #### Expected Result The library should sort content into the order that the API expects. (I'm not clear why the order should matter to the API—perhaps this should be fixed there instead.) #### Technical details: * sendgrid-python Version: master (latest commit: [b12728a53d4c997832c56289c7559f22acf1ff90]) * Python Version: 2.7.13	718ff6a1f91f7696b25c4ffd5b1dff9892e76f54	[ "test/test_mail.py::UnitTests::test_helloEmailAdditionalContent" ]	[ "test/test_mail.py::UnitTests::test_asm_display_group_limit", "test/test_mail.py::UnitTests::test_disable_tracking", "test/test_mail.py::UnitTests::test_helloEmail", "test/test_mail.py::UnitTests::test_kitchenSink", "test/test_mail.py::UnitTests::test_unicode_values_in_substitutions_helper" ]	{ "failed_lite_validators": [ "has_git_commit_hash" ], "has_test_patch": true, "is_lite": false }	2017-10-27 15:41:53+00:00	mit	5,467
sendgrid__sendgrid-python-583	diff --git a/examples/helpers/mail/mail_example.py b/examples/helpers/mail/mail_example.py index 93b3fb6..b2de7f0 100644 --- a/examples/helpers/mail/mail_example.py +++ b/examples/helpers/mail/mail_example.py @@ -30,7 +30,7 @@ def build_personalization(personalization): mock_personalization.add_to(cc_addr) for bcc_addr in personalization['bcc_list']: - mock_personalization.add_bc(bcc_addr) + mock_personalization.add_bcc(bcc_addr) for header in personalization['headers']: mock_personalization.add_header(header) @@ -216,4 +216,4 @@ def send_kitchen_sink(): send_hello_email() # this will only send an email if you set SandBox Mode to False -send_kitchen_sink() \ No newline at end of file +send_kitchen_sink() diff --git a/sendgrid/helpers/mail/personalization.py b/sendgrid/helpers/mail/personalization.py index e49432c..8bb4bed 100644 --- a/sendgrid/helpers/mail/personalization.py +++ b/sendgrid/helpers/mail/personalization.py @@ -116,7 +116,7 @@ class Personalization(object): @substitutions.setter def substitutions(self, value): - self.substitutions = value + self._substitutions = value def add_substitution(self, substitution): """Add a new Substitution to this Personalization.	sendgrid/sendgrid-python	86708c7908102b171a9dbc92d31c5740aa218423	diff --git a/test/test_mail.py b/test/test_mail.py index 86f21c0..7721b52 100644 --- a/test/test_mail.py +++ b/test/test_mail.py @@ -558,3 +558,7 @@ class UnitTests(unittest.TestCase): tracking_settings.get(), {'click_tracking': {'enable': False, 'enable_text': False}} ) + + def test_directly_setting_substitutions(self): + personalization = Personalization() + personalization.substitutions = [{'a': 0}]	Attempting to set substitutions on Personalization helper causes infinite regress #### Issue Summary Attempting to set substitutions on a `Personalization` helper directly (rather than with `add_substitution`) throws a `RecursionError`. #### Steps to Reproduce ```python from sendgrid.helpers.mail import Personalization p = Personalization() p.substitutions = [{'a': 0}, {'b': 1}] ``` This throws a `RecursionError`. The offending line is [personalization.py#L119](https://github.com/sendgrid/sendgrid-python/blob/master/sendgrid/helpers/mail/personalization.py#L119). I will open a PR as this is an easy fix. #### Technical details: * sendgrid-python Version: `5.3.0` * Python Version: 3.6	86708c7908102b171a9dbc92d31c5740aa218423	[ "test/test_mail.py::UnitTests::test_directly_setting_substitutions" ]	[ "test/test_mail.py::UnitTests::test_asm_display_group_limit", "test/test_mail.py::UnitTests::test_disable_tracking", "test/test_mail.py::UnitTests::test_helloEmail", "test/test_mail.py::UnitTests::test_helloEmailAdditionalContent", "test/test_mail.py::UnitTests::test_kitchenSink", "test/test_mail.py::UnitTests::test_sendgridAPIKey", "test/test_mail.py::UnitTests::test_unicode_values_in_substitutions_helper" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2018-06-08 14:00:59+00:00	mit	5,468
sendgrid__sendgrid-python-593	diff --git a/examples/helpers/mail/mail_example.py b/examples/helpers/mail_example.py similarity index 91% rename from examples/helpers/mail/mail_example.py rename to examples/helpers/mail_example.py index b2de7f0..0a5b868 100644 --- a/examples/helpers/mail/mail_example.py +++ b/examples/helpers/mail_example.py @@ -1,8 +1,6 @@ -import json -import os -import urllib2 +from sendgrid import SendGridAPIClient from sendgrid.helpers.mail import * -from sendgrid import * + # NOTE: you will need move this file to the root # directory of this project to execute properly. @@ -217,3 +215,27 @@ send_hello_email() # this will only send an email if you set SandBox Mode to False send_kitchen_sink() + + +def dynamic_template_usage(): + """ + Sample usage of dynamic (handlebars) transactional templates. + To make this work, you should have dynamic template created within your + SendGrid account. For this particular example, template may be like:: + + <p>Hello, {{name}}! Your current balance is {{balance}}<p> + + """ + mail = Mail() + mail.from_email = '[email protected]' + mail.template_id = 'd-your-dynamic-template-uid' + p = Personalization() + p.add_to(Email('[email protected]')) + p.dynamic_template_data = { + 'name': 'Bob', + 'balance': 42 + } + mail.add_personalization(p) + + sg = SendGridAPIClient(apikey='SG.your-api-key') + sg.client.mail.send.post(request_body=mail.get()) diff --git a/sendgrid/helpers/mail/personalization.py b/sendgrid/helpers/mail/personalization.py index 8bb4bed..8032af9 100644 --- a/sendgrid/helpers/mail/personalization.py +++ b/sendgrid/helpers/mail/personalization.py @@ -1,6 +1,10 @@ class Personalization(object): """A Personalization defines who should receive an individual message and how that message should be handled. + + :var dynamic_template_data: data for dynamic transactional template. + Should be JSON-serializeable structure. No pre-processing sill be done + prior to sending this via http client. """ def __init__(self): @@ -13,6 +17,7 @@ class Personalization(object): self._substitutions = [] self._custom_args = [] self._send_at = None + self.dynamic_template_data = None @property def tos(self): @@ -198,4 +203,8 @@ class Personalization(object): if self.send_at is not None: personalization["send_at"] = self.send_at + + if self.dynamic_template_data is not None: + personalization['dynamic_template_data'] = self.dynamic_template_data + return personalization diff --git a/use_cases/transational_templates.md b/use_cases/transational_templates.md index d3e3a00..2d74f92 100644 --- a/use_cases/transational_templates.md +++ b/use_cases/transational_templates.md @@ -66,6 +66,38 @@ print(response.body) print(response.headers) ``` +### With dynamic templates + +Sendgrid dynamic templates let you leverage power of [handlebars](https://handlebarsjs.com/) +syntax to easily manage complex dynamic content in transactional emails. + +To check this example snippet, create +[transactional email template](https://sendgrid.com/dynamic_templates) with code like +```html +<p>Hello, {{name}}! Your current balance is {{balance}}<p> +``` + +Than send email based on it, providing context for substitutions: +```python +from sendgrid import SendGridAPIClient +from sendgrid.helpers.mail import Email, Personalization + + +sg = SendGridAPIClient(apikey='SG.your-api-key') + +mail = Mail() +mail.from_email='[email protected]' +mail.template_id = 'd-your-dynamic-template-uid' +p = Personalization() +p.add_to(Email('[email protected]')) +p.dynamic_template_data = {'name': 'Bob', 'balance': 42} +mail.add_personalization(p) + +sg.client.mail.send.post(request_body=mail.get()) +``` + +Read more about dynamic templates in [docs](https://sendgrid.com/docs/User_Guide/Transactional_Templates/how_to_send_an_email_with_transactional_templates.html) + ## Without Mail Helper Class ```python @@ -113,4 +145,4 @@ except urllib.HTTPError as e: print(response.status_code) print(response.body) print(response.headers) -``` \ No newline at end of file +```	sendgrid/sendgrid-python	1ac58c6fc491554bc24573393ae6242e579dbabb	diff --git a/test/test_mail.py b/test/test_mail.py index 7721b52..08d0feb 100644 --- a/test/test_mail.py +++ b/test/test_mail.py @@ -80,7 +80,6 @@ class UnitTests(unittest.TestCase): else: self.fail("Should have failed as SendGrid API key included") - def test_helloEmail(self): self.max_diff = None @@ -130,7 +129,7 @@ class UnitTests(unittest.TestCase): personalization = Personalization() personalization.add_to(Email("[email protected]")) mail.add_personalization(personalization) - + mail.add_content(Content("text/html", "<html><body>some text here</body></html>")) mail.add_content(Content("text/plain", "some text here")) @@ -562,3 +561,26 @@ class UnitTests(unittest.TestCase): def test_directly_setting_substitutions(self): personalization = Personalization() personalization.substitutions = [{'a': 0}] + + def test_dynamic_template_data(self): + p = Personalization() + p.add_to(Email('[email protected]')) + p.dynamic_template_data = { + 'customer': { + 'name': 'Bob', + 'returning': True + }, + 'total': 42 + } + + expected = { + 'to': [{'email': '[email protected]'}], + 'dynamic_template_data': { + 'customer': { + 'name': 'Bob', + 'returning': True + }, + 'total': 42 + } + } + self.assertDictEqual(p.get(), expected)	Add Dynamic Template Support #### Issue Summary On 7/24/2018, our team publicly launched dynamic content for transactional templates. It is now available for all customers sending over v3 of our Mail Send API. Iterate over lists, handle conditionals and more, thanks to native support for a subset of Handlebars syntax! More information can be found in our [blog post announcement](https://sendgrid.com/blog/how-to-use-sendgrids-dynamic-templates-for-your-transactional-emails/). You can currently use this feature by manually creating the request body as [shown here](https://github.com/sendgrid/sendgrid-python/blob/master/USAGE.md#v3-mail-send). Now, we need to create helper code and examples for this SDK. #### Acceptance Criteria * [Implement a helper similar to what we have for the legacy templates](https://github.com/sendgrid/sendgrid-python/blob/master/use_cases/transational_templates.md) * Update the [transactional_templates.md](https://github.com/sendgrid/sendgrid-python/blob/master/use_cases/transational_templates.md) example to demonstrate the new Dynamic Templates using the helper and re-name the current example to Legacy #### Documentation - [Reference Implementation](https://github.com/sendgrid/sendgrid-nodejs/pull/691#issuecomment-407490342) - [How to Send an Email With Dynamic Transactional Templates](https://sendgrid.com/docs/User_Guide/Transactional_Templates/how_to_send_an_email_with_transactional_templates.html) - [Using Handlebars](https://sendgrid.com/docs/User_Guide/Transactional_Templates/Using_handlebars.html) - [Interactive API Docs](https://dynamic-templates.api-docs.io/3.0/mail-send-with-dynamic-transactional-templates/v3-mail-send)	1ac58c6fc491554bc24573393ae6242e579dbabb	[ "test/test_mail.py::UnitTests::test_dynamic_template_data" ]	[ "test/test_mail.py::UnitTests::test_asm_display_group_limit", "test/test_mail.py::UnitTests::test_directly_setting_substitutions", "test/test_mail.py::UnitTests::test_disable_tracking", "test/test_mail.py::UnitTests::test_helloEmail", "test/test_mail.py::UnitTests::test_helloEmailAdditionalContent", "test/test_mail.py::UnitTests::test_kitchenSink", "test/test_mail.py::UnitTests::test_sendgridAPIKey", "test/test_mail.py::UnitTests::test_unicode_values_in_substitutions_helper" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2018-08-01 17:31:20+00:00	mit	5,469
sensein__cmixf-2	diff --git a/README.md b/README.md index 3788677..5958bbb 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,10 @@ A library to parse [CMIXF-12](https://people.csail.mit.edu/jaffer/MIXF/CMIXF-12). +This will install a CLI `cmixf` when installed. + +At present this assumes that a number is provided before any unit. + ## For developers: After cloning the repo do: diff --git a/cmixf/parser.py b/cmixf/parser.py index 209e82f..db429d4 100644 --- a/cmixf/parser.py +++ b/cmixf/parser.py @@ -2,13 +2,17 @@ from sly import Lexer, Parser decimalsubmultiple = r"(a\|c\|d\|f\|m\|n\|p\|u\|y\|z)" decimalmultiple = r"(E\|G\|M\|P\|T\|Y\|Z\|da\|h\|k)" -unitb = ( - r"([A-Z][A-Z][A-Z]\|A\|Bq\|C\|F\|Gy\|H\|Hz\|J\|K\|N\|Ohm\|Pa\|Sv\|S\|T\|V\|W\|Wb" - r"\|bit\|cd\|eV\|g\|kat\|lm\|lx\|mol\|m\|s)" -) -unitn = r"(L\|Np\|oC\|o\|rad\|sr)" -unitp = r"(Bd\|B\|r\|t)" binary = r"(Ei\|Gi\|Ki\|Mi\|Pi\|Ti)" +unitc = [r"[A-Z][A-Z][A-Z]\|A\|Bq\|C", + r"dB\|d\|h\|min\|u", + r"F\|Gy\|Hz\|H\|J\|K\|Np\|N\|(Ohm\|Ω)\|Pa\|Sv\|S\|T\|V\|W\|Wb", + r"L\|(oC\|°C)\|o\|rad\|sr", + r"bit\|cd\|eV\|g\|kat\|lm\|lx\|mol\|m\|s\|µ", + r"Bd\|B\|r\|t"] +unitb = r"(" + r'\|'.join([unitc[0], unitc[2], unitc[4]]) + r")" +unitn = r"(" + unitc[3] + r")" +unitp = r"(" + unitc[5] + r")" +units = r"(" + unitc[2] + r")" class CMIXFLexer(Lexer): @@ -19,10 +23,7 @@ class CMIXFLexer(Lexer): SUBMULTIN, MULTIB, SUBMULTIB, - UNITP, - UNITN, - UNITB, - UNITS, + UNITC, DOT, DIV, LPAREN, @@ -40,16 +41,13 @@ class CMIXFLexer(Lexer): EXP = r"\^" REAL = r"-?\d*\.?\d+(?:[eE][-+]?\d+)?" DOT = r"\." + BIT = binary + r"bit" + BYTE = binary + r"B" + UNITC = r'\|'.join(unitc) MULTIP = decimalmultiple + unitp SUBMULTIN = decimalsubmultiple + unitn MULTIB = decimalmultiple + unitb SUBMULTIB = decimalsubmultiple + unitb - BIT = binary + r"bit" - BYTE = binary + r"B" - UNITS = r"(dB\|d\|h\|min\|u)" - UNITB = unitb - UNITN = unitn - UNITP = unitp def error(self, t): raise ValueError("Line %d: Bad character %r" % (self.lineno, t.value[0])) @@ -193,21 +191,9 @@ class CMIXFParser(Parser): def punit(self, p): return p.BIT - @_("UNITP") - def punit(self, p): - return p.UNITP - - @_("UNITN") - def punit(self, p): - return p.UNITN - - @_("UNITB") - def punit(self, p): - return p.UNITB - - @_("UNITS") + @_("UNITC") def punit(self, p): - return p.UNITS + return p.UNITC @_("REAL") def real(self, p):	sensein/cmixf	3e2e9d713584dda9bc3e9f7cb7a82e38a22f76c3	diff --git a/cmixf/tests/test_cmixf.py b/cmixf/tests/test_cmixf.py index 11f51f7..4541261 100644 --- a/cmixf/tests/test_cmixf.py +++ b/cmixf/tests/test_cmixf.py @@ -73,6 +73,13 @@ def test_real(text, exception): "1EUR/kg", "1JPY/USD", "1", + "1mol/m^3", + "1W/sr", + "1W/(m^2.sr)", + "1J/mol", + "1J/(mol.K)", + "1nV/Hz^(1/2)", + "1Mibit/s", ], ) def test_cmixf_examples(text): @@ -81,20 +88,15 @@ def test_cmixf_examples(text): assert isinstance(parser.parse(lexer.tokenize(text)), str) [email protected]() @pytest.mark.parametrize( "text", [ - "1mol/m^3", - "1W/sr", - "1W/(m^2.sr)", - "1J/mol", - "1J/(mol.K)", - "1nV/Hz^(1/2)", - "1Mib/s", + "1µ", + "1°C", + "1Ω", ], ) -def test_cmixf_failures(text): +def test_bids_chars(text): lexer = CMIXFLexer() parser = CMIXFParser() assert isinstance(parser.parse(lexer.tokenize(text)), str)	fix corner cases that depend on ordering of tokens the use of sly makes tokenizing dependent on order of tokens. this results in a set of units to be not parsed correctly. https://github.com/sensein/cmixf/blob/master/cmixf/tests/test_cmixf.py#L84	3e2e9d713584dda9bc3e9f7cb7a82e38a22f76c3	[ "cmixf/tests/test_cmixf.py::test_cmixf_examples[1mol/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/sr]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m^2.sr)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/mol]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(mol.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1nV/Hz^(1/2)]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb5]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb0C]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\u2126]" ]	[ "cmixf/tests/test_cmixf.py::test_real[12E-True]", "cmixf/tests/test_cmixf.py::test_real[12E+-True]", "cmixf/tests/test_cmixf.py::test_real[.-True]", "cmixf/tests/test_cmixf.py::test_real[12-False]", "cmixf/tests/test_cmixf.py::test_real[-12-False]", "cmixf/tests/test_cmixf.py::test_real[12.1-False]", "cmixf/tests/test_cmixf.py::test_real[-.1-False]", "cmixf/tests/test_cmixf.py::test_real[.1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[24.h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1s^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[6.283185307179586.rad]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kg/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1cd/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Pa.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N.m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/K]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(kg.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1V/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1F/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1H/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Gy/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1r/min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kat/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1USD/h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1EUR/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1JPY/USD]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Mibit/s]" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-05-23 22:25:47+00:00	mit	5,470
sensein__cmixf-4	diff --git a/cmixf/parser.py b/cmixf/parser.py index db429d4..516a614 100644 --- a/cmixf/parser.py +++ b/cmixf/parser.py @@ -1,18 +1,19 @@ from sly import Lexer, Parser -decimalsubmultiple = r"(a\|c\|d\|f\|m\|n\|p\|u\|y\|z)" +decimalsubmultiple = r"(a\|c\|d\|f\|m\|n\|p\|(u\|µ)\|y\|z)" decimalmultiple = r"(E\|G\|M\|P\|T\|Y\|Z\|da\|h\|k)" binary = r"(Ei\|Gi\|Ki\|Mi\|Pi\|Ti)" -unitc = [r"[A-Z][A-Z][A-Z]\|A\|Bq\|C", - r"dB\|d\|h\|min\|u", - r"F\|Gy\|Hz\|H\|J\|K\|Np\|N\|(Ohm\|Ω)\|Pa\|Sv\|S\|T\|V\|W\|Wb", - r"L\|(oC\|°C)\|o\|rad\|sr", - r"bit\|cd\|eV\|g\|kat\|lm\|lx\|mol\|m\|s\|µ", - r"Bd\|B\|r\|t"] -unitb = r"(" + r'\|'.join([unitc[0], unitc[2], unitc[4]]) + r")" -unitn = r"(" + unitc[3] + r")" -unitp = r"(" + unitc[5] + r")" -units = r"(" + unitc[2] + r")" +unitc = {"unitb1": r"[A-Z][A-Z][A-Z]\|A\|Bq\|C", + "units": r"dB\|d\|h\|min\|u", + "unitb2": r"F\|Gy\|Hz\|H\|J\|K\|Np\|N\|(Ohm\|Ω)\|Pa\|Sv\|S\|T\|V\|W\|Wb", + "unitn": r"L\|(oC\|°C)\|(°\|o)\|rad\|sr", + "unitb3": r"bit\|cd\|eV\|g\|kat\|lm\|lx\|mol\|m\|s", + "unitp": r"Bd\|B\|r\|t"} +unitb = r"(" + r'\|'.join([unitc["unitb1"], unitc["unitb2"], + unitc["unitb3"]]) + r")" +unitn = r"(" + unitc["unitn"] + r")" +unitp = r"(" + unitc["unitp"] + r")" +units = r"(" + unitc["units"] + r")" class CMIXFLexer(Lexer): @@ -43,11 +44,11 @@ class CMIXFLexer(Lexer): DOT = r"\." BIT = binary + r"bit" BYTE = binary + r"B" - UNITC = r'\|'.join(unitc) - MULTIP = decimalmultiple + unitp - SUBMULTIN = decimalsubmultiple + unitn MULTIB = decimalmultiple + unitb SUBMULTIB = decimalsubmultiple + unitb + MULTIP = decimalmultiple + unitp + UNITC = r'\|'.join([val for val in unitc.values()]) + SUBMULTIN = decimalsubmultiple + unitn def error(self, t): raise ValueError("Line %d: Bad character %r" % (self.lineno, t.value[0]))	sensein/cmixf	69bafbd5de6a2a1a1fe676b36a2b6d253a741c35	diff --git a/cmixf/tests/test_cmixf.py b/cmixf/tests/test_cmixf.py index 4541261..e519fa7 100644 --- a/cmixf/tests/test_cmixf.py +++ b/cmixf/tests/test_cmixf.py @@ -91,7 +91,7 @@ def test_cmixf_examples(text): @pytest.mark.parametrize( "text", [ - "1µ", + "1µm", "1°C", "1Ω", ], @@ -100,3 +100,18 @@ def test_bids_chars(text): lexer = CMIXFLexer() parser = CMIXFParser() assert isinstance(parser.parse(lexer.tokenize(text)), str) + + [email protected]( + "text", + [ + "1µV", + "1uV", + "1ms", + "1kBq", + ], +) +def test_new_errors(text): + lexer = CMIXFLexer() + parser = CMIXFParser() + assert isinstance(parser.parse(lexer.tokenize(text)), str)	fails on units like "ms" Hey @satra thanks for such a clean package! 1. I installed the dev version as described in the README 1. I ran `cmixf` from the CLI to start the program 1. I entered `1ms` which should be 1 millisecond Traceback: ``` cmixf > 1ms type='REAL', value='1' type='UNITC', value='m' type='UNITC', value='s' sly: Syntax error at line 1, token=UNITC Traceback (most recent call last): File "/home/stefanappelhoff/miniconda3/bin/cmixf", line 11, in <module> load_entry_point('cmixf', 'console_scripts', 'cmixf')() File "/home/stefanappelhoff/Desktop/bids/cmixf/cmixf/parser.py", line 218, in main print(parser.parse(lexer.tokenize(text))) File "/home/stefanappelhoff/miniconda3/lib/python3.7/site-packages/sly/yacc.py", line 2119, in parse tok = self.error(errtoken) File "/home/stefanappelhoff/Desktop/bids/cmixf/cmixf/parser.py", line 204, in error raise RuntimeError(f"Could not parse {t}") RuntimeError: Could not parse Token(type='UNITC', value='s', lineno=1, index=2) ``` Similar errors for: - 1uV - 1µV - 1kBq (and probably more)	69bafbd5de6a2a1a1fe676b36a2b6d253a741c35	[ "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb5m]", "cmixf/tests/test_cmixf.py::test_new_errors[1\\xb5V]", "cmixf/tests/test_cmixf.py::test_new_errors[1uV]", "cmixf/tests/test_cmixf.py::test_new_errors[1ms]", "cmixf/tests/test_cmixf.py::test_new_errors[1kBq]" ]	[ "cmixf/tests/test_cmixf.py::test_real[12E-True]", "cmixf/tests/test_cmixf.py::test_real[12E+-True]", "cmixf/tests/test_cmixf.py::test_real[.-True]", "cmixf/tests/test_cmixf.py::test_real[12-False]", "cmixf/tests/test_cmixf.py::test_real[-12-False]", "cmixf/tests/test_cmixf.py::test_real[12.1-False]", "cmixf/tests/test_cmixf.py::test_real[-.1-False]", "cmixf/tests/test_cmixf.py::test_real[.1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[24.h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1s^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[6.283185307179586.rad]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kg/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1cd/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Pa.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N.m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/K]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(kg.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1V/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1F/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1H/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Gy/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1r/min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kat/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1USD/h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1EUR/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1JPY/USD]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1mol/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/sr]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m^2.sr)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/mol]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(mol.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1nV/Hz^(1/2)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Mibit/s]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb0C]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\u2126]" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2020-05-25 13:03:54+00:00	mit	5,471
sensein__cmixf-7	diff --git a/README.md b/README.md index 70f56a0..8227578 100644 --- a/README.md +++ b/README.md @@ -4,43 +4,50 @@ A library to parse [CMIXF-12](https://people.csail.mit.edu/jaffer/MIXF/CMIXF-12). -This will install a CLI `cmixf` when installed. +## For users: -At present this assumes that a number is provided before any unit. +To install from PyPi. -## For users: +``` +$ pip install cmixf +``` + +This will install a command line interface called `cmixf`. + +``` +$ cmixf --help +Usage: cmixf [OPTIONS] [TEXT]... + +Options: + -d, --debug Turn on token debugging + --help Show this message and exit. +``` + +At present this assumes that a number is provided before any unit. To better +understand which characters are erroneous you can turn on the debug flag. + +1. Without debugging on: ``` -$ pip install cmixf # requires a python 3 environment $ cmixf -cmixf > 1mV -type='REAL', value='1' -type='SUBMULTIB', value='mV' +cmixf (Ctrl+d to quit) > 1mV 1mV -cmixf > 1oC -type='REAL', value='1' -type='UNITC', value='oC' +cmixf (Ctrl+d to quit) > 1oC 1oC -cmixf > <Ctrl+D to exit> +cmixf (Ctrl+d to quit) > 1mM +FAILED: Line 1: Bad character 'M' +cmixf (Ctrl+d to quit) > ``` -If it fails it will raise an error and exit. +2. With debugging turned on: ``` -$ cmixf -cmixf > 1mM +$ cmixf --debug +cmixf (Ctrl+d to quit) > 1mM type='REAL', value='1' type='UNITC', value='m' -Traceback (most recent call last): - File "/Users/satra/software/miniconda3/envs/mixf/bin/cmixf", line 11, in <module> - load_entry_point('cmixf', 'console_scripts', 'cmixf')() - File "/Users/satra/software/sensein/cmixf/cmixf/parser.py", line 217, in main - for tok in lexer.tokenize(text): - File "/Users/satra/software/miniconda3/envs/mixf/lib/python3.8/site-packages/sly/lex.py", line 443, in tokenize - tok = self.error(tok) - File "/Users/satra/software/sensein/cmixf/cmixf/parser.py", line 54, in error - raise ValueError("Line %d: Bad character %r" % (self.lineno, t.value[0])) -ValueError: Line 1: Bad character 'M' +FAILED: Line 1: Bad character 'M' +cmixf (Ctrl+d to quit) > ``` ## For developers: diff --git a/cmixf/parser.py b/cmixf/parser.py index 516a614..dd929be 100644 --- a/cmixf/parser.py +++ b/cmixf/parser.py @@ -1,19 +1,72 @@ +import click from sly import Lexer, Parser -decimalsubmultiple = r"(a\|c\|d\|f\|m\|n\|p\|(u\|µ)\|y\|z)" -decimalmultiple = r"(E\|G\|M\|P\|T\|Y\|Z\|da\|h\|k)" -binary = r"(Ei\|Gi\|Ki\|Mi\|Pi\|Ti)" -unitc = {"unitb1": r"[A-Z][A-Z][A-Z]\|A\|Bq\|C", - "units": r"dB\|d\|h\|min\|u", - "unitb2": r"F\|Gy\|Hz\|H\|J\|K\|Np\|N\|(Ohm\|Ω)\|Pa\|Sv\|S\|T\|V\|W\|Wb", - "unitn": r"L\|(oC\|°C)\|(°\|o)\|rad\|sr", - "unitb3": r"bit\|cd\|eV\|g\|kat\|lm\|lx\|mol\|m\|s", - "unitp": r"Bd\|B\|r\|t"} -unitb = r"(" + r'\|'.join([unitc["unitb1"], unitc["unitb2"], - unitc["unitb3"]]) + r")" -unitn = r"(" + unitc["unitn"] + r")" -unitp = r"(" + unitc["unitp"] + r")" -units = r"(" + unitc["units"] + r")" +decimal_multiple_prefix = ['E', 'G', 'M', 'P', 'T', 'Y', 'Z', 'da', 'h', 'k'] +decimal_submultiple_prefix = ['a', 'c', 'd', 'f', 'm', 'n', 'p', ['u', 'µ'], + 'y', 'z'] +binary_prefix = ['Ei', 'Gi', 'Ki', 'Mi', 'Pi', 'Ti'] +unit_p_symbol = ['Bd', 'B', 'r', 't'] +unit_n_symbol = ['L', 'Np', ['oC', '°C'], ['o', '°'], 'rad', 'sr'] +unit_b_symbol = ['A', 'Bq', 'C', 'F', 'Gy', 'Hz', 'H', 'J', 'K', 'N', + ['Ohm', 'Ω'], 'Pa', 'Sv', 'S', 'T', 'V', 'Wb', 'W', 'bit', + 'cd', 'eV', 'g', 'kat', 'lm', 'lx', 'mol', 'm', 's', + ] +unit_b_N_index = unit_b_symbol.index('N') +unit___symbol = ['dB', 'd', 'h', 'min', 'u'] +currency = ['[A-Z][A-Z][A-Z]'] + + +def encapsulate(value_list): + if all([isinstance(val, str) for val in value_list]): + return r'(' + r'\|'.join(value_list) + r')' + return encapsulate([val if isinstance(val, str) else encapsulate(val) for val in value_list]) + + +def to_regex(components): + if not isinstance(components, list): + components = [components] + return r''.join([encapsulate(comp) for comp in components]) + + +def to_list(unit_list): + out = [] + for val in unit_list: + if isinstance(val, str): + out.append(val) + else: + out.extend(val) + return out + + +def create_combos(): + """ + punit + : decimal_multiple_prefix unit_p_symbol + \| decimal_submultiple_prefix unit_n_symbol + \| decimal_multiple_prefix unit_b_symbol + \| decimal_submultiple_prefix unit_b_symbol + \| binary_prefix 'B' + \| binary_prefix 'bit' + \| unit_p_symbol + \| unit_n_symbol + \| unit_b_symbol + \| unit___symbol + ; + """ + def combine(list1, list2): + combos = [] + for val1 in to_list(list1): + for val2 in to_list(list2): + combos.append(val1 + val2) + return combos + combos = combine(decimal_multiple_prefix, unit_p_symbol) + \ + combine(decimal_submultiple_prefix, unit_n_symbol) + \ + combine(decimal_multiple_prefix, unit_b_symbol) + \ + combine(decimal_submultiple_prefix, unit_b_symbol) + \ + combine(binary_prefix, ["B", "bit"]) + \ + to_list(unit_p_symbol) + to_list(unit_n_symbol) + \ + to_list(unit_b_symbol) + to_list(unit___symbol) + return ["1"+val for val in combos] class CMIXFLexer(Lexer): @@ -42,13 +95,19 @@ class CMIXFLexer(Lexer): EXP = r"\^" REAL = r"-?\d*\.?\d+(?:[eE][-+]?\d+)?" DOT = r"\." - BIT = binary + r"bit" - BYTE = binary + r"B" - MULTIB = decimalmultiple + unitb - SUBMULTIB = decimalsubmultiple + unitb - MULTIP = decimalmultiple + unitp - UNITC = r'\|'.join([val for val in unitc.values()]) - SUBMULTIN = decimalsubmultiple + unitn + BIT = to_regex([binary_prefix, [r"bit"]]) + BYTE = to_regex([binary_prefix, [r"B"]]) + SUBMULTIN = r"mol\|" + to_regex([decimal_submultiple_prefix, unit_n_symbol]) + MULTIB = to_regex([decimal_multiple_prefix, currency + unit_b_symbol]) + SUBMULTIB = to_regex([decimal_submultiple_prefix, currency + unit_b_symbol]) + MULTIP = to_regex([decimal_multiple_prefix, unit_p_symbol]) + UNITC = r'\|'.join([encapsulate(val)[1:-1] for val in [currency + unit_b_symbol[:unit_b_N_index], + unit___symbol, + unit_n_symbol, + unit_b_symbol[unit_b_N_index:], + unit_p_symbol, + ] + ]) def error(self, t): raise ValueError("Line %d: Bad character %r" % (self.lineno, t.value[0])) @@ -205,15 +264,31 @@ class CMIXFParser(Parser): raise RuntimeError(f"Could not parse {t}") -def main(): +def parse(text, debug): lexer = CMIXFLexer() parser = CMIXFParser() + tokens = lexer.tokenize(text) + if debug: + for tok in tokens: + print("type=%r, value=%r" % (tok.type, tok.value)) + print(parser.parse(tokens)) + + [email protected]() [email protected]("-d", "--debug", is_flag=True, help="Turn on token debugging") [email protected]("text", nargs=-1) +def main(debug, text): + if text: + for val in text: + parse(val, debug) + return while True: try: - text = input("cmixf > ") + text = input("cmixf (Ctrl+d to quit) > ") except EOFError: break if text: - for tok in lexer.tokenize(text): - print("type=%r, value=%r" % (tok.type, tok.value)) - print(parser.parse(lexer.tokenize(text))) + try: + parse(text, debug) + except Exception as e: + print("FAILED: ", e)	sensein/cmixf	22f2f98d67380c1a6b92dcf53eb6ca7e4ffd364c	diff --git a/cmixf/tests/test_cmixf.py b/cmixf/tests/test_cmixf.py index e519fa7..26b65db 100644 --- a/cmixf/tests/test_cmixf.py +++ b/cmixf/tests/test_cmixf.py @@ -1,6 +1,6 @@ import pytest -from ..parser import CMIXFLexer, CMIXFParser +from ..parser import CMIXFLexer, CMIXFParser, create_combos @pytest.mark.parametrize( @@ -80,6 +80,9 @@ def test_real(text, exception): "1J/(mol.K)", "1nV/Hz^(1/2)", "1Mibit/s", + "1ms", + "1kBq", + "1mL", ], ) def test_cmixf_examples(text): @@ -94,6 +97,8 @@ def test_cmixf_examples(text): "1µm", "1°C", "1Ω", + "1µV", + "1uV", ], ) def test_bids_chars(text): @@ -104,14 +109,10 @@ def test_bids_chars(text): @pytest.mark.parametrize( "text", - [ - "1µV", - "1uV", - "1ms", - "1kBq", - ], + create_combos() ) -def test_new_errors(text): +def test_combos(text): lexer = CMIXFLexer() parser = CMIXFParser() assert isinstance(parser.parse(lexer.tokenize(text)), str) +	Liters are not validated when combined with prefix ``` # 1 Liter works cmixf > 1L type='REAL', value='1' type='UNITC', value='L' 1L # 1mL does not work cmixf > 1mL type='REAL', value='1' type='UNITC', value='m' type='UNITC', value='L' sly: Syntax error at line 1, token=UNITC Traceback (most recent call last): File "/home/stefanappelhoff/miniconda3/bin/cmixf", line 11, in <module> load_entry_point('cmixf', 'console_scripts', 'cmixf')() File "/home/stefanappelhoff/Desktop/bids/cmixf/cmixf/parser.py", line 219, in main print(parser.parse(lexer.tokenize(text))) File "/home/stefanappelhoff/miniconda3/lib/python3.7/site-packages/sly/yacc.py", line 2119, in parse tok = self.error(errtoken) File "/home/stefanappelhoff/Desktop/bids/cmixf/cmixf/parser.py", line 205, in error raise RuntimeError(f"Could not parse {t}") RuntimeError: Could not parse Token(type='UNITC', value='L', lineno=1, index=2) ```	22f2f98d67380c1a6b92dcf53eb6ca7e4ffd364c	[ "cmixf/tests/test_cmixf.py::test_real[12E-True]", "cmixf/tests/test_cmixf.py::test_real[12E+-True]", "cmixf/tests/test_cmixf.py::test_real[.-True]", "cmixf/tests/test_cmixf.py::test_real[12-False]", "cmixf/tests/test_cmixf.py::test_real[-12-False]", "cmixf/tests/test_cmixf.py::test_real[12.1-False]", "cmixf/tests/test_cmixf.py::test_real[-.1-False]", "cmixf/tests/test_cmixf.py::test_real[.1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1E+1-False]", "cmixf/tests/test_cmixf.py::test_real[12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_real[-12.1e+1-False]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[60.min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[24.h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1s^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[6.283185307179586.rad]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^-1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kg/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1m^3/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1A/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1cd/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1rad/s^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Pa.s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N.m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1N/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/K]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(kg.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1V/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/m^2]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1F/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1H/m]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1C/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Gy/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1r/min]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kat/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1USD/h]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1EUR/kg]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1JPY/USD]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1mol/m^3]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/sr]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1W/(m^2.sr)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/mol]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1J/(mol.K)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1nV/Hz^(1/2)]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1Mibit/s]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1ms]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1kBq]", "cmixf/tests/test_cmixf.py::test_cmixf_examples[1mL]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb5m]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb0C]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\u2126]", "cmixf/tests/test_cmixf.py::test_bids_chars[1\\xb5V]", "cmixf/tests/test_cmixf.py::test_bids_chars[1uV]", "cmixf/tests/test_cmixf.py::test_combos[1EBd]", "cmixf/tests/test_cmixf.py::test_combos[1EB]", "cmixf/tests/test_cmixf.py::test_combos[1Er]", "cmixf/tests/test_cmixf.py::test_combos[1Et]", "cmixf/tests/test_cmixf.py::test_combos[1GBd]", "cmixf/tests/test_cmixf.py::test_combos[1GB]", "cmixf/tests/test_cmixf.py::test_combos[1Gr]", "cmixf/tests/test_cmixf.py::test_combos[1Gt]", "cmixf/tests/test_cmixf.py::test_combos[1MBd]", "cmixf/tests/test_cmixf.py::test_combos[1MB]", "cmixf/tests/test_cmixf.py::test_combos[1Mr]", "cmixf/tests/test_cmixf.py::test_combos[1Mt]", "cmixf/tests/test_cmixf.py::test_combos[1PBd]", "cmixf/tests/test_cmixf.py::test_combos[1PB]", "cmixf/tests/test_cmixf.py::test_combos[1Pr]", "cmixf/tests/test_cmixf.py::test_combos[1Pt]", "cmixf/tests/test_cmixf.py::test_combos[1TBd]", "cmixf/tests/test_cmixf.py::test_combos[1TB]", "cmixf/tests/test_cmixf.py::test_combos[1Tr]", "cmixf/tests/test_cmixf.py::test_combos[1Tt]", "cmixf/tests/test_cmixf.py::test_combos[1YBd]", "cmixf/tests/test_cmixf.py::test_combos[1YB]", "cmixf/tests/test_cmixf.py::test_combos[1Yr]", "cmixf/tests/test_cmixf.py::test_combos[1Yt]", "cmixf/tests/test_cmixf.py::test_combos[1ZBd]", "cmixf/tests/test_cmixf.py::test_combos[1ZB]", "cmixf/tests/test_cmixf.py::test_combos[1Zr]", "cmixf/tests/test_cmixf.py::test_combos[1Zt]", "cmixf/tests/test_cmixf.py::test_combos[1daBd]", "cmixf/tests/test_cmixf.py::test_combos[1daB]", "cmixf/tests/test_cmixf.py::test_combos[1dar]", "cmixf/tests/test_cmixf.py::test_combos[1dat]", "cmixf/tests/test_cmixf.py::test_combos[1hBd]", "cmixf/tests/test_cmixf.py::test_combos[1hB]", "cmixf/tests/test_cmixf.py::test_combos[1hr]", "cmixf/tests/test_cmixf.py::test_combos[1ht]", "cmixf/tests/test_cmixf.py::test_combos[1kBd]", "cmixf/tests/test_cmixf.py::test_combos[1kB]", "cmixf/tests/test_cmixf.py::test_combos[1kr]", "cmixf/tests/test_cmixf.py::test_combos[1kt]", "cmixf/tests/test_cmixf.py::test_combos[1aL]", "cmixf/tests/test_cmixf.py::test_combos[1aNp]", "cmixf/tests/test_cmixf.py::test_combos[1aoC]", "cmixf/tests/test_cmixf.py::test_combos[1a\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1ao]", "cmixf/tests/test_cmixf.py::test_combos[1a\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1arad]", "cmixf/tests/test_cmixf.py::test_combos[1asr]", "cmixf/tests/test_cmixf.py::test_combos[1cL]", "cmixf/tests/test_cmixf.py::test_combos[1cNp]", "cmixf/tests/test_cmixf.py::test_combos[1coC]", "cmixf/tests/test_cmixf.py::test_combos[1c\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1co]", "cmixf/tests/test_cmixf.py::test_combos[1c\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1crad]", "cmixf/tests/test_cmixf.py::test_combos[1csr]", "cmixf/tests/test_cmixf.py::test_combos[1dL]", "cmixf/tests/test_cmixf.py::test_combos[1dNp]", "cmixf/tests/test_cmixf.py::test_combos[1doC]", "cmixf/tests/test_cmixf.py::test_combos[1d\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1do]", "cmixf/tests/test_cmixf.py::test_combos[1d\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1drad]", "cmixf/tests/test_cmixf.py::test_combos[1dsr]", "cmixf/tests/test_cmixf.py::test_combos[1fL]", "cmixf/tests/test_cmixf.py::test_combos[1fNp]", "cmixf/tests/test_cmixf.py::test_combos[1foC]", "cmixf/tests/test_cmixf.py::test_combos[1f\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1fo]", "cmixf/tests/test_cmixf.py::test_combos[1f\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1frad]", "cmixf/tests/test_cmixf.py::test_combos[1fsr]", "cmixf/tests/test_cmixf.py::test_combos[1mL]", "cmixf/tests/test_cmixf.py::test_combos[1mNp]", "cmixf/tests/test_cmixf.py::test_combos[1moC]", "cmixf/tests/test_cmixf.py::test_combos[1m\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1mo]", "cmixf/tests/test_cmixf.py::test_combos[1m\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1mrad]", "cmixf/tests/test_cmixf.py::test_combos[1msr]", "cmixf/tests/test_cmixf.py::test_combos[1nL]", "cmixf/tests/test_cmixf.py::test_combos[1nNp]", "cmixf/tests/test_cmixf.py::test_combos[1noC]", "cmixf/tests/test_cmixf.py::test_combos[1n\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1no]", "cmixf/tests/test_cmixf.py::test_combos[1n\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1nrad]", "cmixf/tests/test_cmixf.py::test_combos[1nsr]", "cmixf/tests/test_cmixf.py::test_combos[1pL]", "cmixf/tests/test_cmixf.py::test_combos[1pNp]", "cmixf/tests/test_cmixf.py::test_combos[1poC]", "cmixf/tests/test_cmixf.py::test_combos[1p\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1po]", "cmixf/tests/test_cmixf.py::test_combos[1p\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1prad]", "cmixf/tests/test_cmixf.py::test_combos[1psr]", "cmixf/tests/test_cmixf.py::test_combos[1uL]", "cmixf/tests/test_cmixf.py::test_combos[1uNp]", "cmixf/tests/test_cmixf.py::test_combos[1uoC]", "cmixf/tests/test_cmixf.py::test_combos[1u\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1uo]", "cmixf/tests/test_cmixf.py::test_combos[1u\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1urad]", "cmixf/tests/test_cmixf.py::test_combos[1usr]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5L]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Np]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5oC]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5o]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5rad]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5sr]", "cmixf/tests/test_cmixf.py::test_combos[1yL]", "cmixf/tests/test_cmixf.py::test_combos[1yNp]", "cmixf/tests/test_cmixf.py::test_combos[1yoC]", "cmixf/tests/test_cmixf.py::test_combos[1y\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1yo]", "cmixf/tests/test_cmixf.py::test_combos[1y\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1yrad]", "cmixf/tests/test_cmixf.py::test_combos[1ysr]", "cmixf/tests/test_cmixf.py::test_combos[1zL]", "cmixf/tests/test_cmixf.py::test_combos[1zNp]", "cmixf/tests/test_cmixf.py::test_combos[1zoC]", "cmixf/tests/test_cmixf.py::test_combos[1z\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1zo]", "cmixf/tests/test_cmixf.py::test_combos[1z\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1zrad]", "cmixf/tests/test_cmixf.py::test_combos[1zsr]", "cmixf/tests/test_cmixf.py::test_combos[1EA]", "cmixf/tests/test_cmixf.py::test_combos[1EBq]", "cmixf/tests/test_cmixf.py::test_combos[1EC]", "cmixf/tests/test_cmixf.py::test_combos[1EF]", "cmixf/tests/test_cmixf.py::test_combos[1EGy]", "cmixf/tests/test_cmixf.py::test_combos[1EHz]", "cmixf/tests/test_cmixf.py::test_combos[1EH]", "cmixf/tests/test_cmixf.py::test_combos[1EJ]", "cmixf/tests/test_cmixf.py::test_combos[1EK]", "cmixf/tests/test_cmixf.py::test_combos[1EN]", "cmixf/tests/test_cmixf.py::test_combos[1EOhm]", "cmixf/tests/test_cmixf.py::test_combos[1E\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1EPa]", "cmixf/tests/test_cmixf.py::test_combos[1ESv]", "cmixf/tests/test_cmixf.py::test_combos[1ES]", "cmixf/tests/test_cmixf.py::test_combos[1ET]", "cmixf/tests/test_cmixf.py::test_combos[1EV]", "cmixf/tests/test_cmixf.py::test_combos[1EWb]", "cmixf/tests/test_cmixf.py::test_combos[1EW]", "cmixf/tests/test_cmixf.py::test_combos[1Ebit]", "cmixf/tests/test_cmixf.py::test_combos[1Ecd]", "cmixf/tests/test_cmixf.py::test_combos[1EeV]", "cmixf/tests/test_cmixf.py::test_combos[1Eg]", "cmixf/tests/test_cmixf.py::test_combos[1Ekat]", "cmixf/tests/test_cmixf.py::test_combos[1Elm]", "cmixf/tests/test_cmixf.py::test_combos[1Elx]", "cmixf/tests/test_cmixf.py::test_combos[1Emol]", "cmixf/tests/test_cmixf.py::test_combos[1Em]", "cmixf/tests/test_cmixf.py::test_combos[1Es]", "cmixf/tests/test_cmixf.py::test_combos[1GA]", "cmixf/tests/test_cmixf.py::test_combos[1GBq]", "cmixf/tests/test_cmixf.py::test_combos[1GC]", "cmixf/tests/test_cmixf.py::test_combos[1GF]", "cmixf/tests/test_cmixf.py::test_combos[1GGy]", "cmixf/tests/test_cmixf.py::test_combos[1GHz]", "cmixf/tests/test_cmixf.py::test_combos[1GH]", "cmixf/tests/test_cmixf.py::test_combos[1GJ]", "cmixf/tests/test_cmixf.py::test_combos[1GK]", "cmixf/tests/test_cmixf.py::test_combos[1GN]", "cmixf/tests/test_cmixf.py::test_combos[1GOhm]", "cmixf/tests/test_cmixf.py::test_combos[1G\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1GPa]", "cmixf/tests/test_cmixf.py::test_combos[1GSv]", "cmixf/tests/test_cmixf.py::test_combos[1GS]", "cmixf/tests/test_cmixf.py::test_combos[1GT]", "cmixf/tests/test_cmixf.py::test_combos[1GV]", "cmixf/tests/test_cmixf.py::test_combos[1GWb]", "cmixf/tests/test_cmixf.py::test_combos[1GW]", "cmixf/tests/test_cmixf.py::test_combos[1Gbit]", "cmixf/tests/test_cmixf.py::test_combos[1Gcd]", "cmixf/tests/test_cmixf.py::test_combos[1GeV]", "cmixf/tests/test_cmixf.py::test_combos[1Gg]", "cmixf/tests/test_cmixf.py::test_combos[1Gkat]", "cmixf/tests/test_cmixf.py::test_combos[1Glm]", "cmixf/tests/test_cmixf.py::test_combos[1Glx]", "cmixf/tests/test_cmixf.py::test_combos[1Gmol]", "cmixf/tests/test_cmixf.py::test_combos[1Gm]", "cmixf/tests/test_cmixf.py::test_combos[1Gs]", "cmixf/tests/test_cmixf.py::test_combos[1MA]", "cmixf/tests/test_cmixf.py::test_combos[1MBq]", "cmixf/tests/test_cmixf.py::test_combos[1MC]", "cmixf/tests/test_cmixf.py::test_combos[1MF]", "cmixf/tests/test_cmixf.py::test_combos[1MGy]", "cmixf/tests/test_cmixf.py::test_combos[1MHz]", "cmixf/tests/test_cmixf.py::test_combos[1MH]", "cmixf/tests/test_cmixf.py::test_combos[1MJ]", "cmixf/tests/test_cmixf.py::test_combos[1MK]", "cmixf/tests/test_cmixf.py::test_combos[1MN]", "cmixf/tests/test_cmixf.py::test_combos[1MOhm]", "cmixf/tests/test_cmixf.py::test_combos[1M\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1MPa]", "cmixf/tests/test_cmixf.py::test_combos[1MSv]", "cmixf/tests/test_cmixf.py::test_combos[1MS]", "cmixf/tests/test_cmixf.py::test_combos[1MT]", "cmixf/tests/test_cmixf.py::test_combos[1MV]", "cmixf/tests/test_cmixf.py::test_combos[1MWb]", "cmixf/tests/test_cmixf.py::test_combos[1MW]", "cmixf/tests/test_cmixf.py::test_combos[1Mbit]", "cmixf/tests/test_cmixf.py::test_combos[1Mcd]", "cmixf/tests/test_cmixf.py::test_combos[1MeV]", "cmixf/tests/test_cmixf.py::test_combos[1Mg]", "cmixf/tests/test_cmixf.py::test_combos[1Mkat]", "cmixf/tests/test_cmixf.py::test_combos[1Mlm]", "cmixf/tests/test_cmixf.py::test_combos[1Mlx]", "cmixf/tests/test_cmixf.py::test_combos[1Mmol]", "cmixf/tests/test_cmixf.py::test_combos[1Mm]", "cmixf/tests/test_cmixf.py::test_combos[1Ms]", "cmixf/tests/test_cmixf.py::test_combos[1PA]", "cmixf/tests/test_cmixf.py::test_combos[1PBq]", "cmixf/tests/test_cmixf.py::test_combos[1PC]", "cmixf/tests/test_cmixf.py::test_combos[1PF]", "cmixf/tests/test_cmixf.py::test_combos[1PGy]", "cmixf/tests/test_cmixf.py::test_combos[1PHz]", "cmixf/tests/test_cmixf.py::test_combos[1PH]", "cmixf/tests/test_cmixf.py::test_combos[1PJ]", "cmixf/tests/test_cmixf.py::test_combos[1PK]", "cmixf/tests/test_cmixf.py::test_combos[1PN]", "cmixf/tests/test_cmixf.py::test_combos[1POhm]", "cmixf/tests/test_cmixf.py::test_combos[1P\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1PPa]", "cmixf/tests/test_cmixf.py::test_combos[1PSv]", "cmixf/tests/test_cmixf.py::test_combos[1PS]", "cmixf/tests/test_cmixf.py::test_combos[1PT]", "cmixf/tests/test_cmixf.py::test_combos[1PV]", "cmixf/tests/test_cmixf.py::test_combos[1PWb]", "cmixf/tests/test_cmixf.py::test_combos[1PW]", "cmixf/tests/test_cmixf.py::test_combos[1Pbit]", "cmixf/tests/test_cmixf.py::test_combos[1Pcd]", "cmixf/tests/test_cmixf.py::test_combos[1PeV]", "cmixf/tests/test_cmixf.py::test_combos[1Pg]", "cmixf/tests/test_cmixf.py::test_combos[1Pkat]", "cmixf/tests/test_cmixf.py::test_combos[1Plm]", "cmixf/tests/test_cmixf.py::test_combos[1Plx]", "cmixf/tests/test_cmixf.py::test_combos[1Pmol]", "cmixf/tests/test_cmixf.py::test_combos[1Pm]", "cmixf/tests/test_cmixf.py::test_combos[1Ps]", "cmixf/tests/test_cmixf.py::test_combos[1TA]", "cmixf/tests/test_cmixf.py::test_combos[1TBq]", "cmixf/tests/test_cmixf.py::test_combos[1TC]", "cmixf/tests/test_cmixf.py::test_combos[1TF]", "cmixf/tests/test_cmixf.py::test_combos[1TGy]", "cmixf/tests/test_cmixf.py::test_combos[1THz]", "cmixf/tests/test_cmixf.py::test_combos[1TH]", "cmixf/tests/test_cmixf.py::test_combos[1TJ]", "cmixf/tests/test_cmixf.py::test_combos[1TK]", "cmixf/tests/test_cmixf.py::test_combos[1TN]", "cmixf/tests/test_cmixf.py::test_combos[1TOhm]", "cmixf/tests/test_cmixf.py::test_combos[1T\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1TPa]", "cmixf/tests/test_cmixf.py::test_combos[1TSv]", "cmixf/tests/test_cmixf.py::test_combos[1TS]", "cmixf/tests/test_cmixf.py::test_combos[1TT]", "cmixf/tests/test_cmixf.py::test_combos[1TV]", "cmixf/tests/test_cmixf.py::test_combos[1TWb]", "cmixf/tests/test_cmixf.py::test_combos[1TW]", "cmixf/tests/test_cmixf.py::test_combos[1Tbit]", "cmixf/tests/test_cmixf.py::test_combos[1Tcd]", "cmixf/tests/test_cmixf.py::test_combos[1TeV]", "cmixf/tests/test_cmixf.py::test_combos[1Tg]", "cmixf/tests/test_cmixf.py::test_combos[1Tkat]", "cmixf/tests/test_cmixf.py::test_combos[1Tlm]", "cmixf/tests/test_cmixf.py::test_combos[1Tlx]", "cmixf/tests/test_cmixf.py::test_combos[1Tmol]", "cmixf/tests/test_cmixf.py::test_combos[1Tm]", "cmixf/tests/test_cmixf.py::test_combos[1Ts]", "cmixf/tests/test_cmixf.py::test_combos[1YA]", "cmixf/tests/test_cmixf.py::test_combos[1YBq]", "cmixf/tests/test_cmixf.py::test_combos[1YC]", "cmixf/tests/test_cmixf.py::test_combos[1YF]", "cmixf/tests/test_cmixf.py::test_combos[1YGy]", "cmixf/tests/test_cmixf.py::test_combos[1YHz]", "cmixf/tests/test_cmixf.py::test_combos[1YH]", "cmixf/tests/test_cmixf.py::test_combos[1YJ]", "cmixf/tests/test_cmixf.py::test_combos[1YK]", "cmixf/tests/test_cmixf.py::test_combos[1YN]", "cmixf/tests/test_cmixf.py::test_combos[1YOhm]", "cmixf/tests/test_cmixf.py::test_combos[1Y\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1YPa]", "cmixf/tests/test_cmixf.py::test_combos[1YSv]", "cmixf/tests/test_cmixf.py::test_combos[1YS]", "cmixf/tests/test_cmixf.py::test_combos[1YT]", "cmixf/tests/test_cmixf.py::test_combos[1YV]", "cmixf/tests/test_cmixf.py::test_combos[1YWb]", "cmixf/tests/test_cmixf.py::test_combos[1YW]", "cmixf/tests/test_cmixf.py::test_combos[1Ybit]", "cmixf/tests/test_cmixf.py::test_combos[1Ycd]", "cmixf/tests/test_cmixf.py::test_combos[1YeV]", "cmixf/tests/test_cmixf.py::test_combos[1Yg]", "cmixf/tests/test_cmixf.py::test_combos[1Ykat]", "cmixf/tests/test_cmixf.py::test_combos[1Ylm]", "cmixf/tests/test_cmixf.py::test_combos[1Ylx]", "cmixf/tests/test_cmixf.py::test_combos[1Ymol]", "cmixf/tests/test_cmixf.py::test_combos[1Ym]", "cmixf/tests/test_cmixf.py::test_combos[1Ys]", "cmixf/tests/test_cmixf.py::test_combos[1ZA]", "cmixf/tests/test_cmixf.py::test_combos[1ZBq]", "cmixf/tests/test_cmixf.py::test_combos[1ZC]", "cmixf/tests/test_cmixf.py::test_combos[1ZF]", "cmixf/tests/test_cmixf.py::test_combos[1ZGy]", "cmixf/tests/test_cmixf.py::test_combos[1ZHz]", "cmixf/tests/test_cmixf.py::test_combos[1ZH]", "cmixf/tests/test_cmixf.py::test_combos[1ZJ]", "cmixf/tests/test_cmixf.py::test_combos[1ZK]", "cmixf/tests/test_cmixf.py::test_combos[1ZN]", "cmixf/tests/test_cmixf.py::test_combos[1ZOhm]", "cmixf/tests/test_cmixf.py::test_combos[1Z\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1ZPa]", "cmixf/tests/test_cmixf.py::test_combos[1ZSv]", "cmixf/tests/test_cmixf.py::test_combos[1ZS]", "cmixf/tests/test_cmixf.py::test_combos[1ZT]", "cmixf/tests/test_cmixf.py::test_combos[1ZV]", "cmixf/tests/test_cmixf.py::test_combos[1ZWb]", "cmixf/tests/test_cmixf.py::test_combos[1ZW]", "cmixf/tests/test_cmixf.py::test_combos[1Zbit]", "cmixf/tests/test_cmixf.py::test_combos[1Zcd]", "cmixf/tests/test_cmixf.py::test_combos[1ZeV]", "cmixf/tests/test_cmixf.py::test_combos[1Zg]", "cmixf/tests/test_cmixf.py::test_combos[1Zkat]", "cmixf/tests/test_cmixf.py::test_combos[1Zlm]", "cmixf/tests/test_cmixf.py::test_combos[1Zlx]", "cmixf/tests/test_cmixf.py::test_combos[1Zmol]", "cmixf/tests/test_cmixf.py::test_combos[1Zm]", "cmixf/tests/test_cmixf.py::test_combos[1Zs]", "cmixf/tests/test_cmixf.py::test_combos[1daA]", "cmixf/tests/test_cmixf.py::test_combos[1daBq]", "cmixf/tests/test_cmixf.py::test_combos[1daC]", "cmixf/tests/test_cmixf.py::test_combos[1daF]", "cmixf/tests/test_cmixf.py::test_combos[1daGy]", "cmixf/tests/test_cmixf.py::test_combos[1daHz]", "cmixf/tests/test_cmixf.py::test_combos[1daH]", "cmixf/tests/test_cmixf.py::test_combos[1daJ]", "cmixf/tests/test_cmixf.py::test_combos[1daK]", "cmixf/tests/test_cmixf.py::test_combos[1daN]", "cmixf/tests/test_cmixf.py::test_combos[1daOhm]", "cmixf/tests/test_cmixf.py::test_combos[1da\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1daPa]", "cmixf/tests/test_cmixf.py::test_combos[1daSv]", "cmixf/tests/test_cmixf.py::test_combos[1daS]", "cmixf/tests/test_cmixf.py::test_combos[1daT]", "cmixf/tests/test_cmixf.py::test_combos[1daV]", "cmixf/tests/test_cmixf.py::test_combos[1daWb]", "cmixf/tests/test_cmixf.py::test_combos[1daW]", "cmixf/tests/test_cmixf.py::test_combos[1dabit]", "cmixf/tests/test_cmixf.py::test_combos[1dacd]", "cmixf/tests/test_cmixf.py::test_combos[1daeV]", "cmixf/tests/test_cmixf.py::test_combos[1dag]", "cmixf/tests/test_cmixf.py::test_combos[1dakat]", "cmixf/tests/test_cmixf.py::test_combos[1dalm]", "cmixf/tests/test_cmixf.py::test_combos[1dalx]", "cmixf/tests/test_cmixf.py::test_combos[1damol]", "cmixf/tests/test_cmixf.py::test_combos[1dam]", "cmixf/tests/test_cmixf.py::test_combos[1das]", "cmixf/tests/test_cmixf.py::test_combos[1hA]", "cmixf/tests/test_cmixf.py::test_combos[1hBq]", "cmixf/tests/test_cmixf.py::test_combos[1hC]", "cmixf/tests/test_cmixf.py::test_combos[1hF]", "cmixf/tests/test_cmixf.py::test_combos[1hGy]", "cmixf/tests/test_cmixf.py::test_combos[1hHz]", "cmixf/tests/test_cmixf.py::test_combos[1hH]", "cmixf/tests/test_cmixf.py::test_combos[1hJ]", "cmixf/tests/test_cmixf.py::test_combos[1hK]", "cmixf/tests/test_cmixf.py::test_combos[1hN]", "cmixf/tests/test_cmixf.py::test_combos[1hOhm]", "cmixf/tests/test_cmixf.py::test_combos[1h\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1hPa]", "cmixf/tests/test_cmixf.py::test_combos[1hSv]", "cmixf/tests/test_cmixf.py::test_combos[1hS]", "cmixf/tests/test_cmixf.py::test_combos[1hT]", "cmixf/tests/test_cmixf.py::test_combos[1hV]", "cmixf/tests/test_cmixf.py::test_combos[1hWb]", "cmixf/tests/test_cmixf.py::test_combos[1hW]", "cmixf/tests/test_cmixf.py::test_combos[1hbit]", "cmixf/tests/test_cmixf.py::test_combos[1hcd]", "cmixf/tests/test_cmixf.py::test_combos[1heV]", "cmixf/tests/test_cmixf.py::test_combos[1hg]", "cmixf/tests/test_cmixf.py::test_combos[1hkat]", "cmixf/tests/test_cmixf.py::test_combos[1hlm]", "cmixf/tests/test_cmixf.py::test_combos[1hlx]", "cmixf/tests/test_cmixf.py::test_combos[1hmol]", "cmixf/tests/test_cmixf.py::test_combos[1hm]", "cmixf/tests/test_cmixf.py::test_combos[1hs]", "cmixf/tests/test_cmixf.py::test_combos[1kA]", "cmixf/tests/test_cmixf.py::test_combos[1kBq]", "cmixf/tests/test_cmixf.py::test_combos[1kC]", "cmixf/tests/test_cmixf.py::test_combos[1kF]", "cmixf/tests/test_cmixf.py::test_combos[1kGy]", "cmixf/tests/test_cmixf.py::test_combos[1kHz]", "cmixf/tests/test_cmixf.py::test_combos[1kH]", "cmixf/tests/test_cmixf.py::test_combos[1kJ]", "cmixf/tests/test_cmixf.py::test_combos[1kK]", "cmixf/tests/test_cmixf.py::test_combos[1kN]", "cmixf/tests/test_cmixf.py::test_combos[1kOhm]", "cmixf/tests/test_cmixf.py::test_combos[1k\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1kPa]", "cmixf/tests/test_cmixf.py::test_combos[1kSv]", "cmixf/tests/test_cmixf.py::test_combos[1kS]", "cmixf/tests/test_cmixf.py::test_combos[1kT]", "cmixf/tests/test_cmixf.py::test_combos[1kV]", "cmixf/tests/test_cmixf.py::test_combos[1kWb]", "cmixf/tests/test_cmixf.py::test_combos[1kW]", "cmixf/tests/test_cmixf.py::test_combos[1kbit]", "cmixf/tests/test_cmixf.py::test_combos[1kcd]", "cmixf/tests/test_cmixf.py::test_combos[1keV]", "cmixf/tests/test_cmixf.py::test_combos[1kg]", "cmixf/tests/test_cmixf.py::test_combos[1kkat]", "cmixf/tests/test_cmixf.py::test_combos[1klm]", "cmixf/tests/test_cmixf.py::test_combos[1klx]", "cmixf/tests/test_cmixf.py::test_combos[1kmol]", "cmixf/tests/test_cmixf.py::test_combos[1km]", "cmixf/tests/test_cmixf.py::test_combos[1ks]", "cmixf/tests/test_cmixf.py::test_combos[1aA]", "cmixf/tests/test_cmixf.py::test_combos[1aBq]", "cmixf/tests/test_cmixf.py::test_combos[1aC]", "cmixf/tests/test_cmixf.py::test_combos[1aF]", "cmixf/tests/test_cmixf.py::test_combos[1aGy]", "cmixf/tests/test_cmixf.py::test_combos[1aHz]", "cmixf/tests/test_cmixf.py::test_combos[1aH]", "cmixf/tests/test_cmixf.py::test_combos[1aJ]", "cmixf/tests/test_cmixf.py::test_combos[1aK]", "cmixf/tests/test_cmixf.py::test_combos[1aN]", "cmixf/tests/test_cmixf.py::test_combos[1aOhm]", "cmixf/tests/test_cmixf.py::test_combos[1a\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1aPa]", "cmixf/tests/test_cmixf.py::test_combos[1aSv]", "cmixf/tests/test_cmixf.py::test_combos[1aS]", "cmixf/tests/test_cmixf.py::test_combos[1aT]", "cmixf/tests/test_cmixf.py::test_combos[1aV]", "cmixf/tests/test_cmixf.py::test_combos[1aWb]", "cmixf/tests/test_cmixf.py::test_combos[1aW]", "cmixf/tests/test_cmixf.py::test_combos[1abit]", "cmixf/tests/test_cmixf.py::test_combos[1acd]", "cmixf/tests/test_cmixf.py::test_combos[1aeV]", "cmixf/tests/test_cmixf.py::test_combos[1ag]", "cmixf/tests/test_cmixf.py::test_combos[1akat]", "cmixf/tests/test_cmixf.py::test_combos[1alm]", "cmixf/tests/test_cmixf.py::test_combos[1alx]", "cmixf/tests/test_cmixf.py::test_combos[1amol]", "cmixf/tests/test_cmixf.py::test_combos[1am]", "cmixf/tests/test_cmixf.py::test_combos[1as]", "cmixf/tests/test_cmixf.py::test_combos[1cA]", "cmixf/tests/test_cmixf.py::test_combos[1cBq]", "cmixf/tests/test_cmixf.py::test_combos[1cC]", "cmixf/tests/test_cmixf.py::test_combos[1cF]", "cmixf/tests/test_cmixf.py::test_combos[1cGy]", "cmixf/tests/test_cmixf.py::test_combos[1cHz]", "cmixf/tests/test_cmixf.py::test_combos[1cH]", "cmixf/tests/test_cmixf.py::test_combos[1cJ]", "cmixf/tests/test_cmixf.py::test_combos[1cK]", "cmixf/tests/test_cmixf.py::test_combos[1cN]", "cmixf/tests/test_cmixf.py::test_combos[1cOhm]", "cmixf/tests/test_cmixf.py::test_combos[1c\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1cPa]", "cmixf/tests/test_cmixf.py::test_combos[1cSv]", "cmixf/tests/test_cmixf.py::test_combos[1cS]", "cmixf/tests/test_cmixf.py::test_combos[1cT]", "cmixf/tests/test_cmixf.py::test_combos[1cV]", "cmixf/tests/test_cmixf.py::test_combos[1cWb]", "cmixf/tests/test_cmixf.py::test_combos[1cW]", "cmixf/tests/test_cmixf.py::test_combos[1cbit]", "cmixf/tests/test_cmixf.py::test_combos[1ccd]", "cmixf/tests/test_cmixf.py::test_combos[1ceV]", "cmixf/tests/test_cmixf.py::test_combos[1cg]", "cmixf/tests/test_cmixf.py::test_combos[1ckat]", "cmixf/tests/test_cmixf.py::test_combos[1clm]", "cmixf/tests/test_cmixf.py::test_combos[1clx]", "cmixf/tests/test_cmixf.py::test_combos[1cmol]", "cmixf/tests/test_cmixf.py::test_combos[1cm]", "cmixf/tests/test_cmixf.py::test_combos[1cs]", "cmixf/tests/test_cmixf.py::test_combos[1dA]", "cmixf/tests/test_cmixf.py::test_combos[1dBq]", "cmixf/tests/test_cmixf.py::test_combos[1dC]", "cmixf/tests/test_cmixf.py::test_combos[1dF]", "cmixf/tests/test_cmixf.py::test_combos[1dGy]", "cmixf/tests/test_cmixf.py::test_combos[1dHz]", "cmixf/tests/test_cmixf.py::test_combos[1dH]", "cmixf/tests/test_cmixf.py::test_combos[1dJ]", "cmixf/tests/test_cmixf.py::test_combos[1dK]", "cmixf/tests/test_cmixf.py::test_combos[1dN]", "cmixf/tests/test_cmixf.py::test_combos[1dOhm]", "cmixf/tests/test_cmixf.py::test_combos[1d\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1dPa]", "cmixf/tests/test_cmixf.py::test_combos[1dSv]", "cmixf/tests/test_cmixf.py::test_combos[1dS]", "cmixf/tests/test_cmixf.py::test_combos[1dT]", "cmixf/tests/test_cmixf.py::test_combos[1dV]", "cmixf/tests/test_cmixf.py::test_combos[1dWb]", "cmixf/tests/test_cmixf.py::test_combos[1dW]", "cmixf/tests/test_cmixf.py::test_combos[1dbit]", "cmixf/tests/test_cmixf.py::test_combos[1dcd]", "cmixf/tests/test_cmixf.py::test_combos[1deV]", "cmixf/tests/test_cmixf.py::test_combos[1dg]", "cmixf/tests/test_cmixf.py::test_combos[1dkat]", "cmixf/tests/test_cmixf.py::test_combos[1dlm]", "cmixf/tests/test_cmixf.py::test_combos[1dlx]", "cmixf/tests/test_cmixf.py::test_combos[1dmol]", "cmixf/tests/test_cmixf.py::test_combos[1dm]", "cmixf/tests/test_cmixf.py::test_combos[1ds]", "cmixf/tests/test_cmixf.py::test_combos[1fA]", "cmixf/tests/test_cmixf.py::test_combos[1fBq]", "cmixf/tests/test_cmixf.py::test_combos[1fC]", "cmixf/tests/test_cmixf.py::test_combos[1fF]", "cmixf/tests/test_cmixf.py::test_combos[1fGy]", "cmixf/tests/test_cmixf.py::test_combos[1fHz]", "cmixf/tests/test_cmixf.py::test_combos[1fH]", "cmixf/tests/test_cmixf.py::test_combos[1fJ]", "cmixf/tests/test_cmixf.py::test_combos[1fK]", "cmixf/tests/test_cmixf.py::test_combos[1fN]", "cmixf/tests/test_cmixf.py::test_combos[1fOhm]", "cmixf/tests/test_cmixf.py::test_combos[1f\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1fPa]", "cmixf/tests/test_cmixf.py::test_combos[1fSv]", "cmixf/tests/test_cmixf.py::test_combos[1fS]", "cmixf/tests/test_cmixf.py::test_combos[1fT]", "cmixf/tests/test_cmixf.py::test_combos[1fV]", "cmixf/tests/test_cmixf.py::test_combos[1fWb]", "cmixf/tests/test_cmixf.py::test_combos[1fW]", "cmixf/tests/test_cmixf.py::test_combos[1fbit]", "cmixf/tests/test_cmixf.py::test_combos[1fcd]", "cmixf/tests/test_cmixf.py::test_combos[1feV]", "cmixf/tests/test_cmixf.py::test_combos[1fg]", "cmixf/tests/test_cmixf.py::test_combos[1fkat]", "cmixf/tests/test_cmixf.py::test_combos[1flm]", "cmixf/tests/test_cmixf.py::test_combos[1flx]", "cmixf/tests/test_cmixf.py::test_combos[1fmol]", "cmixf/tests/test_cmixf.py::test_combos[1fm]", "cmixf/tests/test_cmixf.py::test_combos[1fs]", "cmixf/tests/test_cmixf.py::test_combos[1mA]", "cmixf/tests/test_cmixf.py::test_combos[1mBq]", "cmixf/tests/test_cmixf.py::test_combos[1mC]", "cmixf/tests/test_cmixf.py::test_combos[1mF]", "cmixf/tests/test_cmixf.py::test_combos[1mGy]", "cmixf/tests/test_cmixf.py::test_combos[1mHz]", "cmixf/tests/test_cmixf.py::test_combos[1mH]", "cmixf/tests/test_cmixf.py::test_combos[1mJ]", "cmixf/tests/test_cmixf.py::test_combos[1mK]", "cmixf/tests/test_cmixf.py::test_combos[1mN]", "cmixf/tests/test_cmixf.py::test_combos[1mOhm]", "cmixf/tests/test_cmixf.py::test_combos[1m\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1mPa]", "cmixf/tests/test_cmixf.py::test_combos[1mSv]", "cmixf/tests/test_cmixf.py::test_combos[1mS]", "cmixf/tests/test_cmixf.py::test_combos[1mT]", "cmixf/tests/test_cmixf.py::test_combos[1mV]", "cmixf/tests/test_cmixf.py::test_combos[1mWb]", "cmixf/tests/test_cmixf.py::test_combos[1mW]", "cmixf/tests/test_cmixf.py::test_combos[1mbit]", "cmixf/tests/test_cmixf.py::test_combos[1mcd]", "cmixf/tests/test_cmixf.py::test_combos[1meV]", "cmixf/tests/test_cmixf.py::test_combos[1mg]", "cmixf/tests/test_cmixf.py::test_combos[1mkat]", "cmixf/tests/test_cmixf.py::test_combos[1mlm]", "cmixf/tests/test_cmixf.py::test_combos[1mlx]", "cmixf/tests/test_cmixf.py::test_combos[1mmol]", "cmixf/tests/test_cmixf.py::test_combos[1mm]", "cmixf/tests/test_cmixf.py::test_combos[1ms]", "cmixf/tests/test_cmixf.py::test_combos[1nA]", "cmixf/tests/test_cmixf.py::test_combos[1nBq]", "cmixf/tests/test_cmixf.py::test_combos[1nC]", "cmixf/tests/test_cmixf.py::test_combos[1nF]", "cmixf/tests/test_cmixf.py::test_combos[1nGy]", "cmixf/tests/test_cmixf.py::test_combos[1nHz]", "cmixf/tests/test_cmixf.py::test_combos[1nH]", "cmixf/tests/test_cmixf.py::test_combos[1nJ]", "cmixf/tests/test_cmixf.py::test_combos[1nK]", "cmixf/tests/test_cmixf.py::test_combos[1nN]", "cmixf/tests/test_cmixf.py::test_combos[1nOhm]", "cmixf/tests/test_cmixf.py::test_combos[1n\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1nPa]", "cmixf/tests/test_cmixf.py::test_combos[1nSv]", "cmixf/tests/test_cmixf.py::test_combos[1nS]", "cmixf/tests/test_cmixf.py::test_combos[1nT]", "cmixf/tests/test_cmixf.py::test_combos[1nV]", "cmixf/tests/test_cmixf.py::test_combos[1nWb]", "cmixf/tests/test_cmixf.py::test_combos[1nW]", "cmixf/tests/test_cmixf.py::test_combos[1nbit]", "cmixf/tests/test_cmixf.py::test_combos[1ncd]", "cmixf/tests/test_cmixf.py::test_combos[1neV]", "cmixf/tests/test_cmixf.py::test_combos[1ng]", "cmixf/tests/test_cmixf.py::test_combos[1nkat]", "cmixf/tests/test_cmixf.py::test_combos[1nlm]", "cmixf/tests/test_cmixf.py::test_combos[1nlx]", "cmixf/tests/test_cmixf.py::test_combos[1nmol]", "cmixf/tests/test_cmixf.py::test_combos[1nm]", "cmixf/tests/test_cmixf.py::test_combos[1ns]", "cmixf/tests/test_cmixf.py::test_combos[1pA]", "cmixf/tests/test_cmixf.py::test_combos[1pBq]", "cmixf/tests/test_cmixf.py::test_combos[1pC]", "cmixf/tests/test_cmixf.py::test_combos[1pF]", "cmixf/tests/test_cmixf.py::test_combos[1pGy]", "cmixf/tests/test_cmixf.py::test_combos[1pHz]", "cmixf/tests/test_cmixf.py::test_combos[1pH]", "cmixf/tests/test_cmixf.py::test_combos[1pJ]", "cmixf/tests/test_cmixf.py::test_combos[1pK]", "cmixf/tests/test_cmixf.py::test_combos[1pN]", "cmixf/tests/test_cmixf.py::test_combos[1pOhm]", "cmixf/tests/test_cmixf.py::test_combos[1p\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1pPa]", "cmixf/tests/test_cmixf.py::test_combos[1pSv]", "cmixf/tests/test_cmixf.py::test_combos[1pS]", "cmixf/tests/test_cmixf.py::test_combos[1pT]", "cmixf/tests/test_cmixf.py::test_combos[1pV]", "cmixf/tests/test_cmixf.py::test_combos[1pWb]", "cmixf/tests/test_cmixf.py::test_combos[1pW]", "cmixf/tests/test_cmixf.py::test_combos[1pbit]", "cmixf/tests/test_cmixf.py::test_combos[1pcd]", "cmixf/tests/test_cmixf.py::test_combos[1peV]", "cmixf/tests/test_cmixf.py::test_combos[1pg]", "cmixf/tests/test_cmixf.py::test_combos[1pkat]", "cmixf/tests/test_cmixf.py::test_combos[1plm]", "cmixf/tests/test_cmixf.py::test_combos[1plx]", "cmixf/tests/test_cmixf.py::test_combos[1pmol]", "cmixf/tests/test_cmixf.py::test_combos[1pm]", "cmixf/tests/test_cmixf.py::test_combos[1ps]", "cmixf/tests/test_cmixf.py::test_combos[1uA]", "cmixf/tests/test_cmixf.py::test_combos[1uBq]", "cmixf/tests/test_cmixf.py::test_combos[1uC]", "cmixf/tests/test_cmixf.py::test_combos[1uF]", "cmixf/tests/test_cmixf.py::test_combos[1uGy]", "cmixf/tests/test_cmixf.py::test_combos[1uHz]", "cmixf/tests/test_cmixf.py::test_combos[1uH]", "cmixf/tests/test_cmixf.py::test_combos[1uJ]", "cmixf/tests/test_cmixf.py::test_combos[1uK]", "cmixf/tests/test_cmixf.py::test_combos[1uN]", "cmixf/tests/test_cmixf.py::test_combos[1uOhm]", "cmixf/tests/test_cmixf.py::test_combos[1u\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1uPa]", "cmixf/tests/test_cmixf.py::test_combos[1uSv]", "cmixf/tests/test_cmixf.py::test_combos[1uS]", "cmixf/tests/test_cmixf.py::test_combos[1uT]", "cmixf/tests/test_cmixf.py::test_combos[1uV]", "cmixf/tests/test_cmixf.py::test_combos[1uWb]", "cmixf/tests/test_cmixf.py::test_combos[1uW]", "cmixf/tests/test_cmixf.py::test_combos[1ubit]", "cmixf/tests/test_cmixf.py::test_combos[1ucd]", "cmixf/tests/test_cmixf.py::test_combos[1ueV]", "cmixf/tests/test_cmixf.py::test_combos[1ug]", "cmixf/tests/test_cmixf.py::test_combos[1ukat]", "cmixf/tests/test_cmixf.py::test_combos[1ulm]", "cmixf/tests/test_cmixf.py::test_combos[1ulx]", "cmixf/tests/test_cmixf.py::test_combos[1umol]", "cmixf/tests/test_cmixf.py::test_combos[1um]", "cmixf/tests/test_cmixf.py::test_combos[1us]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5A]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Bq]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5C]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5F]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Gy]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Hz]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5H]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5J]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5K]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5N]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Ohm]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Pa]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Sv]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5S]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5T]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5V]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5Wb]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5W]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5bit]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5cd]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5eV]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5g]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5kat]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5lm]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5lx]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5mol]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5m]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb5s]", "cmixf/tests/test_cmixf.py::test_combos[1yA]", "cmixf/tests/test_cmixf.py::test_combos[1yBq]", "cmixf/tests/test_cmixf.py::test_combos[1yC]", "cmixf/tests/test_cmixf.py::test_combos[1yF]", "cmixf/tests/test_cmixf.py::test_combos[1yGy]", "cmixf/tests/test_cmixf.py::test_combos[1yHz]", "cmixf/tests/test_cmixf.py::test_combos[1yH]", "cmixf/tests/test_cmixf.py::test_combos[1yJ]", "cmixf/tests/test_cmixf.py::test_combos[1yK]", "cmixf/tests/test_cmixf.py::test_combos[1yN]", "cmixf/tests/test_cmixf.py::test_combos[1yOhm]", "cmixf/tests/test_cmixf.py::test_combos[1y\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1yPa]", "cmixf/tests/test_cmixf.py::test_combos[1ySv]", "cmixf/tests/test_cmixf.py::test_combos[1yS]", "cmixf/tests/test_cmixf.py::test_combos[1yT]", "cmixf/tests/test_cmixf.py::test_combos[1yV]", "cmixf/tests/test_cmixf.py::test_combos[1yWb]", "cmixf/tests/test_cmixf.py::test_combos[1yW]", "cmixf/tests/test_cmixf.py::test_combos[1ybit]", "cmixf/tests/test_cmixf.py::test_combos[1ycd]", "cmixf/tests/test_cmixf.py::test_combos[1yeV]", "cmixf/tests/test_cmixf.py::test_combos[1yg]", "cmixf/tests/test_cmixf.py::test_combos[1ykat]", "cmixf/tests/test_cmixf.py::test_combos[1ylm]", "cmixf/tests/test_cmixf.py::test_combos[1ylx]", "cmixf/tests/test_cmixf.py::test_combos[1ymol]", "cmixf/tests/test_cmixf.py::test_combos[1ym]", "cmixf/tests/test_cmixf.py::test_combos[1ys]", "cmixf/tests/test_cmixf.py::test_combos[1zA]", "cmixf/tests/test_cmixf.py::test_combos[1zBq]", "cmixf/tests/test_cmixf.py::test_combos[1zC]", "cmixf/tests/test_cmixf.py::test_combos[1zF]", "cmixf/tests/test_cmixf.py::test_combos[1zGy]", "cmixf/tests/test_cmixf.py::test_combos[1zHz]", "cmixf/tests/test_cmixf.py::test_combos[1zH]", "cmixf/tests/test_cmixf.py::test_combos[1zJ]", "cmixf/tests/test_cmixf.py::test_combos[1zK]", "cmixf/tests/test_cmixf.py::test_combos[1zN]", "cmixf/tests/test_cmixf.py::test_combos[1zOhm]", "cmixf/tests/test_cmixf.py::test_combos[1z\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1zPa]", "cmixf/tests/test_cmixf.py::test_combos[1zSv]", "cmixf/tests/test_cmixf.py::test_combos[1zS]", "cmixf/tests/test_cmixf.py::test_combos[1zT]", "cmixf/tests/test_cmixf.py::test_combos[1zV]", "cmixf/tests/test_cmixf.py::test_combos[1zWb]", "cmixf/tests/test_cmixf.py::test_combos[1zW]", "cmixf/tests/test_cmixf.py::test_combos[1zbit]", "cmixf/tests/test_cmixf.py::test_combos[1zcd]", "cmixf/tests/test_cmixf.py::test_combos[1zeV]", "cmixf/tests/test_cmixf.py::test_combos[1zg]", "cmixf/tests/test_cmixf.py::test_combos[1zkat]", "cmixf/tests/test_cmixf.py::test_combos[1zlm]", "cmixf/tests/test_cmixf.py::test_combos[1zlx]", "cmixf/tests/test_cmixf.py::test_combos[1zmol]", "cmixf/tests/test_cmixf.py::test_combos[1zm]", "cmixf/tests/test_cmixf.py::test_combos[1zs]", "cmixf/tests/test_cmixf.py::test_combos[1EiB]", "cmixf/tests/test_cmixf.py::test_combos[1Eibit]", "cmixf/tests/test_cmixf.py::test_combos[1GiB]", "cmixf/tests/test_cmixf.py::test_combos[1Gibit]", "cmixf/tests/test_cmixf.py::test_combos[1KiB]", "cmixf/tests/test_cmixf.py::test_combos[1Kibit]", "cmixf/tests/test_cmixf.py::test_combos[1MiB]", "cmixf/tests/test_cmixf.py::test_combos[1Mibit]", "cmixf/tests/test_cmixf.py::test_combos[1PiB]", "cmixf/tests/test_cmixf.py::test_combos[1Pibit]", "cmixf/tests/test_cmixf.py::test_combos[1TiB]", "cmixf/tests/test_cmixf.py::test_combos[1Tibit]", "cmixf/tests/test_cmixf.py::test_combos[1Bd]", "cmixf/tests/test_cmixf.py::test_combos[1B]", "cmixf/tests/test_cmixf.py::test_combos[1r]", "cmixf/tests/test_cmixf.py::test_combos[1t]", "cmixf/tests/test_cmixf.py::test_combos[1L]", "cmixf/tests/test_cmixf.py::test_combos[1Np]", "cmixf/tests/test_cmixf.py::test_combos[1oC]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb0C]", "cmixf/tests/test_cmixf.py::test_combos[1o]", "cmixf/tests/test_cmixf.py::test_combos[1\\xb0]", "cmixf/tests/test_cmixf.py::test_combos[1rad]", "cmixf/tests/test_cmixf.py::test_combos[1sr]", "cmixf/tests/test_cmixf.py::test_combos[1A]", "cmixf/tests/test_cmixf.py::test_combos[1Bq]", "cmixf/tests/test_cmixf.py::test_combos[1C]", "cmixf/tests/test_cmixf.py::test_combos[1F]", "cmixf/tests/test_cmixf.py::test_combos[1Gy]", "cmixf/tests/test_cmixf.py::test_combos[1Hz]", "cmixf/tests/test_cmixf.py::test_combos[1H]", "cmixf/tests/test_cmixf.py::test_combos[1J]", "cmixf/tests/test_cmixf.py::test_combos[1K]", "cmixf/tests/test_cmixf.py::test_combos[1N]", "cmixf/tests/test_cmixf.py::test_combos[1Ohm]", "cmixf/tests/test_cmixf.py::test_combos[1\\u2126]", "cmixf/tests/test_cmixf.py::test_combos[1Pa]", "cmixf/tests/test_cmixf.py::test_combos[1Sv]", "cmixf/tests/test_cmixf.py::test_combos[1S]", "cmixf/tests/test_cmixf.py::test_combos[1T]", "cmixf/tests/test_cmixf.py::test_combos[1V]", "cmixf/tests/test_cmixf.py::test_combos[1Wb]", "cmixf/tests/test_cmixf.py::test_combos[1W]", "cmixf/tests/test_cmixf.py::test_combos[1bit]", "cmixf/tests/test_cmixf.py::test_combos[1cd]", "cmixf/tests/test_cmixf.py::test_combos[1eV]", "cmixf/tests/test_cmixf.py::test_combos[1g]", "cmixf/tests/test_cmixf.py::test_combos[1kat]", "cmixf/tests/test_cmixf.py::test_combos[1lm]", "cmixf/tests/test_cmixf.py::test_combos[1lx]", "cmixf/tests/test_cmixf.py::test_combos[1mol]", "cmixf/tests/test_cmixf.py::test_combos[1m]", "cmixf/tests/test_cmixf.py::test_combos[1s]", "cmixf/tests/test_cmixf.py::test_combos[1dB]", "cmixf/tests/test_cmixf.py::test_combos[1d]", "cmixf/tests/test_cmixf.py::test_combos[1h]", "cmixf/tests/test_cmixf.py::test_combos[1min]", "cmixf/tests/test_cmixf.py::test_combos[1u]" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-05-25 20:48:05+00:00	mit	5,472
sepandhaghighi__pyrgg-74	diff --git a/AUTHORS.md b/AUTHORS.md index 6cf988f..1c4ab2d 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -7,4 +7,4 @@ # Other Contributors # ---------- - [ivanovmg](https://github.com/ivanovmg) - +- Ahmad Salimi - Sharif University of Technology ([@ahmadsalimi](https://github.com/ahmadsalimi)) ([[email protected]](mailto:[email protected])) diff --git a/CHANGELOG.md b/CHANGELOG.md index d06a231..174d61d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). ## [Unreleased] +### Changed +- The `logger` function enhanced. +- Time format in the `logger` changed to `%Y-%m-%d %H:%M:%S` + ## [0.9] - 2020-10-07 ### Added - GEXF format diff --git a/pyrgg/__main__.py b/pyrgg/__main__.py index 60b34f1..329d6aa 100644 --- a/pyrgg/__main__.py +++ b/pyrgg/__main__.py @@ -35,6 +35,7 @@ def run(): input_dict = get_input() first_time = time.perf_counter() file_name = input_dict["file_name"] + weight = input_dict["weight"] min_weight = input_dict["min_weight"] max_weight = input_dict["max_weight"] vertices_number = input_dict["vertices"] @@ -68,9 +69,18 @@ def run(): print("Graph Generated in " + elapsed_time_format) print("Where --> " + SOURCE_DIR) logger( + file_name + ".gr", vertices_number, edge_number, - file_name + ".gr", + max_edge, + min_edge, + direct, + sign, + multigraph, + self_loop, + weight, + max_weight, + min_weight, elapsed_time_format) diff --git a/pyrgg/functions.py b/pyrgg/functions.py index 0ba22e8..d023182 100644 --- a/pyrgg/functions.py +++ b/pyrgg/functions.py @@ -120,28 +120,68 @@ def filesize(fileaddr): # pragma: no cover print("Graph File Size : " + convert_bytes(file_size)) -def logger(vertices_number, edge_number, file_name, elapsed_time): +def logger( + file_name, + vertices_number, + edge_number, + max_edge, + min_edge, + directed, + signed, + multigraph, + self_loop, + weighted, + max_weight, + min_weight, + elapsed_time): """ Save generated graphs log. + :param file_name: file name + :type file_name: str :param vertices_number: number of vertices :type vertices_number:int :param edge_number: number of edges :type edge_number: int - :param file_name: file name - :type file_name: str + :param max_edge: maximum number of edges + :type max_edge: int + :param min_edge: minimum number of edges + :type min_edge: int + :param directed: directed + :type directed: int + :param signed: weight sign flag + :type signed: int + :param multigraph: multigraph flag + :type multigraph: int + :param self_loop: self loop flag + :type self_loop: int + :param weighted: weighted flag + :type weighted: int + :param max_weight: maximum weight + :type max_weight: int + :param min_weight: minimum weight + :type min_weight: int :param elapsed_time: elapsed time :type elapsed_time : str :return: None """ try: with open("logfile.log", "a") as file: - file.write(str(datetime.datetime.now()) + "\n") - file.write("Filename : " + file_name + "\n") - file.write("Vertices : " + str(vertices_number) + "\n") - file.write("Edges : " + str(edge_number) + "\n") - file.write("Elapsed Time : " + str(elapsed_time) + "\n") - file.write("-------------------------------\n") + file.write(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') + "\n" + + "Filename : " + file_name + "\n" + + "Vertices : " + str(vertices_number) + "\n" + + "Total Edges : " + str(edge_number) + "\n" + + "Max Edge : " + str(max_edge) + "\n" + + "Min Edge : " + str(min_edge) + "\n" + + "Directed : " + str(bool(directed)) + "\n" + + "Signed : " + str(bool(signed)) + "\n" + + "Multigraph : " + str(bool(multigraph)) + "\n" + + "Self Loop : " + str(bool(self_loop)) + "\n" + + "Weighted : " + str(bool(weighted)) + "\n" + + "Max Weight : " + str(max_weight) + "\n" + + "Min Weight : " + str(min_weight) + "\n" + + "Elapsed Time : " + elapsed_time + "\n" + + "-------------------------------\n") except Exception: print(PYRGG_LOGGER_ERROR_MESSAGE)	sepandhaghighi/pyrgg	35906852a56e2ff81e485b60cb731db85510dfbb	diff --git a/pyrgg/test.py b/pyrgg/test.py index ef15bc1..7084bb3 100644 --- a/pyrgg/test.py +++ b/pyrgg/test.py @@ -25,7 +25,7 @@ False True >>> is_float(None) False ->>> logger(2,2,2,2) +>>> logger(2,2,2,2,2,2,2,2,2,2,2,2,2) [Error] Logger Failed! >>> result = input_filter({"file_name": "test","vertices": 5,"max_weight": 1000,"min_weight":455,"min_edge": -45,"max_edge": -11,"sign": 5,"output_format": 19, "direct": 2,"self_loop": 1,"multigraph":1}) >>> result == {'output_format': 1, 'min_weight': 455, 'min_edge': 5, 'max_edge': 5, 'file_name': 'test', 'vertices': 5, 'max_weight': 1000, 'sign': 2, "direct": 2,"self_loop": 1,"multigraph":1} @@ -39,7 +39,22 @@ True >>> result = input_filter({"file_name": "test2","vertices": 23,"max_weight": 2,"min_weight": 80,"min_edge": 23,"max_edge": 1,"sign": 1,"output_format": 1, "direct": 2,"self_loop": 10,"multigraph":10}) >>> result == {'min_weight': 2, 'vertices': 23, 'file_name': 'test2', 'max_edge': 23, 'min_edge': 1, 'max_weight': 80, 'output_format': 1, 'sign': 1, "direct": 2,"self_loop": 1,"multigraph":1} True ->>> logger(100,50,'test','2min') +>>> logger('test',100,50,1000,10,1,0,0,1,1,20,1,'2min') +>>> file=open('logfile.log','r') +>>> print("\n".join(file.read().splitlines()[1:-1])) +Filename : test +Vertices : 100 +Total Edges : 50 +Max Edge : 1000 +Min Edge : 10 +Directed : True +Signed : False +Multigraph : False +Self Loop : True +Weighted : True +Max Weight : 20 +Min Weight : 1 +Elapsed Time : 2min >>> convert_bytes(200) '200.0 bytes' >>> convert_bytes(6000) diff --git a/test/functions_test.py b/test/functions_test.py index 446d310..a8df990 100644 --- a/test/functions_test.py +++ b/test/functions_test.py @@ -2,7 +2,7 @@ """ >>> from pyrgg.functions import * >>> import random ->>> logger(2,2,2,2) +>>> logger(2,2,2,2,2,2,2,2,2,2,2,2,2) [Error] Logger Failed! >>> description_print() Webpage : https://www.pyrgg.ir @@ -37,7 +37,22 @@ True >>> result = input_filter({"file_name": "test2","vertices": 23,"max_weight": 2,"min_weight": 80,"min_edge": 23,"max_edge": 1,"sign": 1,"output_format": 1, "direct": 2,"self_loop": 10,"multigraph":10}) >>> result == {'min_weight': 2, 'vertices': 23, 'file_name': 'test2', 'max_edge': 23, 'min_edge': 1, 'max_weight': 80, 'output_format': 1, 'sign': 1, "direct": 2,"self_loop": 1,"multigraph":1} True ->>> logger(100,50,'test','2min') +>>> logger('test',100,50,1000,10,1,0,0,1,1,20,1,'2min') +>>> file=open('logfile.log','r') +>>> print("\\n".join(file.read().splitlines()[1:-1])) +Filename : test +Vertices : 100 +Total Edges : 50 +Max Edge : 1000 +Min Edge : 10 +Directed : True +Signed : False +Multigraph : False +Self Loop : True +Weighted : True +Max Weight : 20 +Min Weight : 1 +Elapsed Time : 2min >>> convert_bytes(200) '200.0 bytes' >>> convert_bytes(6000)	Logger enhancement #### Description Optimize logger function #### Expected Behavior ``` 2020-09-09 16:58:02 Filename : test2.gr Vertices : 2 Total Edges : 4 Max Edge: x Min Edge: x Directed: True/False Signed: True/False Multigraph: True/False Self Loop: True/False Weighted: True/False Max Weight: x Min Weight: x Elapsed Time : 00 days, 00 hour, 00 minutes, 20 seconds ``` #### Actual Behavior ``` 2020-09-09 16:58:02.103878 Filename : test2.gr Vertices : 2 Edges : 4 Elapsed Time : 00 days, 00 hour, 00 minutes, 20 seconds ``` #### Operating System Windows 10 #### Python Version 3.5.2 #### Pyrgg Version 0.8	35906852a56e2ff81e485b60cb731db85510dfbb	[ "test/functions_test.py::functions_test" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-10-11 10:40:39+00:00	mit	5,473
seperman__deepdiff-239	diff --git a/deepdiff/search.py b/deepdiff/search.py index 4226a6a..5233b10 100644 --- a/deepdiff/search.py +++ b/deepdiff/search.py @@ -40,6 +40,8 @@ class DeepSearch(dict): If True, the value of the object or its children have to exactly match the item. If False, the value of the item can be a part of the value of the object or its children + use_regexp: Boolean, default = False + Returns A DeepSearch object that has the matched paths and matched values. @@ -83,6 +85,7 @@ class DeepSearch(dict): verbose_level=1, case_sensitive=False, match_string=False, + use_regexp=False, **kwargs): if kwargs: raise ValueError(( @@ -104,6 +107,9 @@ class DeepSearch(dict): matched_paths=self.__set_or_dict(), matched_values=self.__set_or_dict(), unprocessed=[]) + self.use_regexp = use_regexp + if self.use_regexp: + self.search_regexp = re.compile(item) # Cases where user wants to match exact string item self.match_string = match_string @@ -135,7 +141,7 @@ class DeepSearch(dict): if obj == item: found = True # We report the match but also continue inside the match to see if there are - # furthur matches inside the `looped` object. + # further matches inside the `looped` object. self.__report(report_key='matched_values', key=parent, value=obj) try: @@ -205,7 +211,8 @@ class DeepSearch(dict): str_item = str(item) if (self.match_string and str_item == new_parent_cased) or\ - (not self.match_string and str_item in new_parent_cased): + (not self.match_string and str_item in new_parent_cased) or\ + (self.use_regexp and self.search_regexp.search(new_parent_cased)): self.__report( report_key='matched_paths', key=new_parent, @@ -233,7 +240,9 @@ class DeepSearch(dict): else: thing_cased = thing.lower() - if thing_cased == item: + if thing_cased == item or \ + (isinstance(thing_cased, str) and isinstance(item, str) and \ + self.use_regexp and self.search_regexp.search(thing_cased)): self.__report( report_key='matched_values', key=new_parent, value=thing) else: @@ -248,7 +257,9 @@ class DeepSearch(dict): """Compare strings""" obj_text = obj if self.case_sensitive else obj.lower() - if (self.match_string and item == obj_text) or (not self.match_string and item in obj_text): + if (self.match_string and item == obj_text) or \ + (not self.match_string and item in obj_text) or \ + (self.use_regexp and self.search_regexp.search(obj_text)): self.__report(report_key='matched_values', key=parent, value=obj) def __search_numbers(self, obj, item, parent):	seperman/deepdiff	f1429a03a040f01f7807b074172fdfea0f805a4b	diff --git a/tests/test_search.py b/tests/test_search.py index 247e648..51150bb 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -336,6 +336,89 @@ class TestDeepSearch: result = {'matched_values': {'root.a'}} assert DeepSearch(obj, item, verbose_level=1) == result + def test_dont_use_regex_by_default(self): + obj = "long string somewhere" + item = "some." + result = {} + assert DeepSearch(obj, item, verbose_level=1) == result + + def test_regex_in_string(self): + obj = "long string somewhere" + item = "some." + result = {"matched_values": {"root"}} + assert DeepSearch(obj, item, verbose_level=1, use_regexp=True) == result + + def test_regex_in_string_in_tuple(self): + obj = ("long", "string", 0, "somewhere") + item = "some." + result = {"matched_values": {"root[3]"}} + assert DeepSearch(obj, item, verbose_level=1, use_regexp=True) == result + + def test_regex_in_string_in_list(self): + obj = ["long", "string", 0, "somewhere"] + item = "some." + result = {"matched_values": {"root[3]"}} + assert DeepSearch(obj, item, verbose_level=1, use_regexp=True) == result + + def test_regex_in_string_in_dictionary(self): + obj = {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"} + result = { + "matched_paths": {"root['somewhere']"}, + "matched_values": {"root['long']"}, + } + item = "some." + ds = DeepSearch(obj, item, verbose_level=1, use_regexp=True) + assert ds == result + + def test_regex_in_string_in_dictionary_in_list_verbose(self): + obj = [ + "something somewhere", + {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"}, + ] + result = { + "matched_paths": {"root[1]['somewhere']": "around"}, + "matched_values": { + "root[1]['long']": "somewhere", + "root[0]": "something somewhere", + }, + } + item = "some." + ds = DeepSearch(obj, item, verbose_level=2, use_regexp=True) + assert ds == result + + def test_regex_in_custom_object(self): + obj = CustomClass("here, something", "somewhere") + result = {"matched_values": {"root.b"}} + item = "somew." + ds = DeepSearch(obj, item, verbose_level=1, use_regexp=True) + assert ds == result + + def test_regex_in_custom_object_in_dictionary_verbose(self): + obj = {1: CustomClass("here, something", "somewhere out there")} + result = {"matched_values": {"root[1].b": "somewhere out there"}} + item = "somew." + ds = DeepSearch(obj, item, verbose_level=2, use_regexp=True) + assert ds == result + + def test_regex_in_named_tuples_verbose(self): + from collections import namedtuple + + Point = namedtuple("Point", ["x", "somewhere_good"]) + obj = Point(x="my keys are somewhere", somewhere_good=22) + item = "some." + ds = DeepSearch(obj, item, verbose_level=2, use_regexp=True) + result = { + "matched_values": {"root.x": "my keys are somewhere"}, + "matched_paths": {"root.somewhere_good": 22}, + } + assert ds == result + + def test_regex_in_string_in_set_verbose(self): + obj = {"long", "string", 0, "somewhere"} + # result = {"matched_values": {'root[3]': "somewhere"}} + item = "some." + ds = DeepSearch(obj, item, verbose_level=2, use_regexp=True) + assert list(ds["matched_values"].values())[0] == "somewhere" class TestGrep:	Support searching with regular expressions I'd like to use regular expressions to find elements of a dictionary with `grep`. ```python (Pdb) entity_attributes {'alone': {'id_': 'alone', 'name': 'Timothy', 'last_name': 'Jackson', 'country': 'Korea', 'rating': 5491}, 'film': {'id_': 'film', 'name': 'David', 'last_name': 'Howell', 'country': 'Moldova', 'rating': 9731}, 'thought': {'id_': 'thought' , 'name': 'Jason', 'last_name': 'Roberts', 'country': 'Western Sahara', 'rating': 5484}} (Pdb) entity_attributes \| grep('Da') {'matched_values': ["root['film']['name']"]} (Pdb) entity_attributes \| grep('Da.*') {} ``` If you give me some guidance on how to do it, I can make a PR	f1429a03a040f01f7807b074172fdfea0f805a4b	[ "tests/test_search.py::TestDeepSearch::test_regex_in_string", "tests/test_search.py::TestDeepSearch::test_regex_in_string_in_tuple", "tests/test_search.py::TestDeepSearch::test_regex_in_string_in_list", "tests/test_search.py::TestDeepSearch::test_regex_in_string_in_dictionary", "tests/test_search.py::TestDeepSearch::test_regex_in_string_in_dictionary_in_list_verbose", "tests/test_search.py::TestDeepSearch::test_regex_in_custom_object", "tests/test_search.py::TestDeepSearch::test_regex_in_custom_object_in_dictionary_verbose", "tests/test_search.py::TestDeepSearch::test_regex_in_named_tuples_verbose", "tests/test_search.py::TestDeepSearch::test_regex_in_string_in_set_verbose" ]	[ "tests/test_search.py::TestDeepSearch::test_number_in_list", "tests/test_search.py::TestDeepSearch::test_number_in_list2", "tests/test_search.py::TestDeepSearch::test_number_in_list3", "tests/test_search.py::TestDeepSearch::test_string_in_root", "tests/test_search.py::TestDeepSearch::test_string_in_root_verbose", "tests/test_search.py::TestDeepSearch::test_string_in_tuple", "tests/test_search.py::TestDeepSearch::test_string_in_list", "tests/test_search.py::TestDeepSearch::test_string_in_list_verbose", "tests/test_search.py::TestDeepSearch::test_string_in_list_verbose2", "tests/test_search.py::TestDeepSearch::test_string_in_list_verbose3", "tests/test_search.py::TestDeepSearch::test_int_in_dictionary", "tests/test_search.py::TestDeepSearch::test_string_in_dictionary", "tests/test_search.py::TestDeepSearch::test_string_in_dictionary_case_insensitive", "tests/test_search.py::TestDeepSearch::test_string_in_dictionary_key_case_insensitive_partial", "tests/test_search.py::TestDeepSearch::test_string_in_dictionary_verbose", "tests/test_search.py::TestDeepSearch::test_string_in_dictionary_in_list_verbose", "tests/test_search.py::TestDeepSearch::test_custom_object", "tests/test_search.py::TestDeepSearch::test_custom_object_verbose", "tests/test_search.py::TestDeepSearch::test_custom_object_in_dictionary_verbose", "tests/test_search.py::TestDeepSearch::test_named_tuples_verbose", "tests/test_search.py::TestDeepSearch::test_string_in_set_verbose", "tests/test_search.py::TestDeepSearch::test_loop", "tests/test_search.py::TestDeepSearch::test_loop_in_lists", "tests/test_search.py::TestDeepSearch::test_skip_path1", "tests/test_search.py::TestDeepSearch::test_custom_object_skip_path", "tests/test_search.py::TestDeepSearch::test_skip_list_path", "tests/test_search.py::TestDeepSearch::test_skip_dictionary_path", "tests/test_search.py::TestDeepSearch::test_skip_type_str", "tests/test_search.py::TestDeepSearch::test_skip_regexp", "tests/test_search.py::TestDeepSearch::test_skip_regexp2", "tests/test_search.py::TestDeepSearch::test_unknown_parameters", "tests/test_search.py::TestDeepSearch::test_bad_attribute", "tests/test_search.py::TestDeepSearch::test_case_insensitive_of_str_in_list", "tests/test_search.py::TestDeepSearch::test_case_sensitive_of_str_in_list", "tests/test_search.py::TestDeepSearch::test_case_sensitive_of_str_in_one_liner", "tests/test_search.py::TestDeepSearch::test_case_insensitive_of_str_in_one_liner", "tests/test_search.py::TestDeepSearch::test_none", "tests/test_search.py::TestDeepSearch::test_complex_obj", "tests/test_search.py::TestDeepSearch::test_keep_searching_after_obj_match", "tests/test_search.py::TestDeepSearch::test_search_inherited_attributes", "tests/test_search.py::TestDeepSearch::test_dont_use_regex_by_default", "tests/test_search.py::TestGrep::test_grep_dict", "tests/test_search.py::TestGrep::test_grep_dict_in_dict", "tests/test_search.py::TestGrep::test_grep_with_non_utf8_chars" ]	{ "failed_lite_validators": [ "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-04-06 13:49:16+00:00	mit	5,474
seperman__deepdiff-76	diff --git a/AUTHORS b/AUTHORS index 163de47..6250384 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,13 +1,15 @@ Authors: - * Seperman - * Victor Hahn Castell @ Flexoptix +- Seperman +- Victor Hahn Castell @ Flexoptix Also thanks to: - * nfvs for Travis-CI setup script. - * brbsix for initial Py3 porting. - * WangFenjin for unicode support. - * timoilya for comparing list of sets when ignoring order. - * Bernhard10 for significant digits comparison. - * b-jazz for PEP257 cleanup, Standardize on full names, fixing line endings. - * finnhughes for fixing __slots__ - * moloney for Unicode vs. Bytes default +- nfvs for Travis-CI setup script. +- brbsix for initial Py3 porting. +- WangFenjin for unicode support. +- timoilya for comparing list of sets when ignoring order. +- Bernhard10 for significant digits comparison. +- b-jazz for PEP257 cleanup, Standardize on full names, fixing line endings. +- finnhughes for fixing __slots__ +- moloney for Unicode vs. Bytes default +- serv-inc for adding help(deepdiff) +- movermeyer for updating docs diff --git a/README.md b/README.md index 8f5b62f..104b040 100644 --- a/README.md +++ b/README.md @@ -165,7 +165,7 @@ Let's say you have a huge nested object and want to see if any item with the wor ```py from deepdiff import DeepSearch obj = {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"} -ds = DeepSearch(obj, item, verbose_level=2) +ds = DeepSearch(obj, "somewhere", verbose_level=2) print(ds) ``` @@ -187,7 +187,7 @@ Just grep through your objects as you would in shell! ```py from deepdiff import grep obj = {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"} -ds = obj \| grep(item) +ds = obj \| grep("somewhere") print(ds) ``` @@ -788,12 +788,13 @@ I was honored to give a talk about how DeepDiff does what it does at Pycon 2016. And here is more info: <http://zepworks.com/blog/diff-it-to-digg-it/> -##Documentation +## Documentation <http://deepdiff.readthedocs.io/en/latest/> -##Changelog +## Change log +- v3-2-2: Adding help(deepdiff) - v3-2-1: Fixing hash of None - v3-2-0: Adding grep for search: object \| grep(item) - v3-1-3: Unicode vs. Bytes default fix @@ -845,3 +846,5 @@ Also thanks to: - b-jazz for PEP257 cleanup, Standardize on full names, fixing line endings. - finnhughes for fixing __slots__ - moloney for Unicode vs. Bytes default +- serv-inc for adding help(deepdiff) +- movermeyer for updating docs diff --git a/README.txt b/README.txt index d33f293..a5c2329 100644 --- a/README.txt +++ b/README.txt @@ -240,6 +240,7 @@ http://zepworks.com/blog/diff-it-to-digg-it/ Changelog +- v3-2-2: Adding help(deepdiff) - v3-2-1: Fixing hash of None - v3-2-0: Adding grep for search: object \| grep(item) - v3-1-3: Unicode vs. Bytes default fix @@ -291,3 +292,5 @@ Also thanks to: - b-jazz for PEP257 cleanup, Standardize on full names, fixing line endings. - finnhughes for fixing __slots__ - moloney for Unicode vs. Bytes default +- serv-inc for adding help(deepdiff) +- movermeyer for updating docs diff --git a/deepdiff/__init__.py b/deepdiff/__init__.py index 6e608d0..95ad688 100644 --- a/deepdiff/__init__.py +++ b/deepdiff/__init__.py @@ -1,3 +1,4 @@ +"""This module offers the DeepDiff, DeepSearch, grep and DeepHash classes.""" import logging if __name__ == '__main__': diff --git a/deepdiff/search.py b/deepdiff/search.py index 26ba882..8c826d8 100644 --- a/deepdiff/search.py +++ b/deepdiff/search.py @@ -127,6 +127,11 @@ class DeepSearch(dict): parents_ids=frozenset({}), is_namedtuple=False): """Search objects""" + found = False + if obj == item: + found = True + self.__report(report_key='matched_values', key=parent, value=obj) + try: if is_namedtuple: obj = obj._asdict() @@ -136,7 +141,9 @@ class DeepSearch(dict): try: obj = {i: getattr(obj, i) for i in obj.__slots__} except AttributeError: - self['unprocessed'].append("%s" % parent) + if not found: + self['unprocessed'].append("%s" % parent) + return self.__search_dict( diff --git a/docs/index.rst b/docs/index.rst index 269932a..43b1a1d 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -346,6 +346,7 @@ Indices and tables Changelog ========= +- v3-2-2: Adding help(deepdiff) - v3-2-1: Fixing hash of None - v3-2-0: Adding grep for search: object \| grep(item) - v3-1-3: Unicode vs. Bytes default fix	seperman/deepdiff	d4918e17c555df1b46827f865c5c105097199f80	diff --git a/tests/test_search.py b/tests/test_search.py index 49929c6..3f56ceb 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -15,6 +15,7 @@ To run a specific test, run this from the root of repo: """ import unittest from deepdiff import DeepSearch, grep +from datetime import datetime import logging logging.disable(logging.CRITICAL) @@ -286,6 +287,30 @@ class DeepSearchTestCase(unittest.TestCase): result = {'matched_values': {'root'}} self.assertEqual(DeepSearch(obj, item, verbose_level=1, case_sensitive=False), result) + def test_none(self): + obj = item = None + result = {'matched_values': {'root'}} + self.assertEqual(DeepSearch(obj, item, verbose_level=1), result) + + def test_complex_obj(self): + obj = datetime(2017, 5, 4, 1, 1, 1) + item = datetime(2017, 5, 4, 1, 1, 1) + result = {'matched_values': {'root'}} + self.assertEqual(DeepSearch(obj, item, verbose_level=1), result) + + def test_keep_searching_after_obj_match(self): + class AlwaysEqual: + def __init__(self, recurse=True): + if recurse: + self.some_attr = AlwaysEqual(recurse=False) + def __eq__(self, other): + return True + + obj = AlwaysEqual() + item = AlwaysEqual() + result = {'matched_values': {'root', 'root.some_attr'}} + self.assertEqual(DeepSearch(obj, item, verbose_level=1), result) + class GrepTestCase(unittest.TestCase):	Feature: Search for types/objects Currently when encountering an object, `DeepSearch` examines that object's `__dict__` without testing whether the object is what's being searched for. By example: ``` >>> from deepdiff import DeepSearch >>> from uuid import uuid4() >>> foo = uuid4() >>> DeepSearch({1: foo}, foo) {} ``` This would also allow global singletons like `None` and functions to be searched for. This seems like it'd be a fairly small change, just an `if item == obj` check at the top of `DeepSearch.__search_obj`. If you think this a good idea, I'm happy to make a PR.	d4918e17c555df1b46827f865c5c105097199f80	[ "tests/test_search.py::DeepSearchTestCase::test_keep_searching_after_obj_match", "tests/test_search.py::DeepSearchTestCase::test_none" ]	[ "tests/test_search.py::DeepSearchTestCase::test_bad_attribute", "tests/test_search.py::DeepSearchTestCase::test_case_insensitive_of_str_in_list", "tests/test_search.py::DeepSearchTestCase::test_case_insensitive_of_str_in_one_liner", "tests/test_search.py::DeepSearchTestCase::test_case_sensitive_of_str_in_list", "tests/test_search.py::DeepSearchTestCase::test_case_sensitive_of_str_in_one_liner", "tests/test_search.py::DeepSearchTestCase::test_complex_obj", "tests/test_search.py::DeepSearchTestCase::test_custom_object", "tests/test_search.py::DeepSearchTestCase::test_custom_object_in_dictionary_verbose", "tests/test_search.py::DeepSearchTestCase::test_custom_object_skip_path", "tests/test_search.py::DeepSearchTestCase::test_custom_object_verbose", "tests/test_search.py::DeepSearchTestCase::test_int_in_dictionary", "tests/test_search.py::DeepSearchTestCase::test_loop", "tests/test_search.py::DeepSearchTestCase::test_loop_in_lists", "tests/test_search.py::DeepSearchTestCase::test_named_tuples_verbose", "tests/test_search.py::DeepSearchTestCase::test_number_in_list", "tests/test_search.py::DeepSearchTestCase::test_skip_dictionary_path", "tests/test_search.py::DeepSearchTestCase::test_skip_list_path", "tests/test_search.py::DeepSearchTestCase::test_skip_path1", "tests/test_search.py::DeepSearchTestCase::test_skip_type_str", "tests/test_search.py::DeepSearchTestCase::test_string_in_dictionary", "tests/test_search.py::DeepSearchTestCase::test_string_in_dictionary_case_insensitive", "tests/test_search.py::DeepSearchTestCase::test_string_in_dictionary_in_list_verbose", "tests/test_search.py::DeepSearchTestCase::test_string_in_dictionary_key_case_insensitive_partial", "tests/test_search.py::DeepSearchTestCase::test_string_in_dictionary_verbose", "tests/test_search.py::DeepSearchTestCase::test_string_in_list", "tests/test_search.py::DeepSearchTestCase::test_string_in_list_verbose", "tests/test_search.py::DeepSearchTestCase::test_string_in_list_verbose2", "tests/test_search.py::DeepSearchTestCase::test_string_in_list_verbose3", "tests/test_search.py::DeepSearchTestCase::test_string_in_root", "tests/test_search.py::DeepSearchTestCase::test_string_in_root_verbose", "tests/test_search.py::DeepSearchTestCase::test_string_in_set_verbose", "tests/test_search.py::DeepSearchTestCase::test_string_in_tuple", "tests/test_search.py::DeepSearchTestCase::test_unknown_parameters", "tests/test_search.py::GrepTestCase::test_grep_dict" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2017-06-19 19:34:25+00:00	mit	5,475
serge-sans-paille__beniget-50	diff --git a/beniget/beniget.py b/beniget/beniget.py index 6b2cc20..dd77efc 100644 --- a/beniget/beniget.py +++ b/beniget/beniget.py @@ -173,7 +173,6 @@ class CollectLocals(ast.NodeVisitor): def visit_FunctionDef(self, node): self.Locals.add(node.name) - # no recursion visit_AsyncFunctionDef = visit_FunctionDef @@ -208,6 +207,11 @@ class CollectLocals(ast.NodeVisitor): def collect_locals(node): + ''' + Compute the set of identifiers local to a given node. + + This is meant to emulate a call to locals() + ''' visitor = CollectLocals() visitor.generic_visit(node) return visitor.Locals @@ -271,11 +275,12 @@ class DefUseChains(ast.NodeVisitor): self._breaks = [] self._continues = [] - # dead code levels - self.deadcode = 0 - - # helpers + # dead code levels, it's non null for code that cannot be executed + self._deadcode = 0 + # + ## helpers + # def dump_definitions(self, node, ignore_builtins=True): if isinstance(node, ast.Module) and not ignore_builtins: builtins = {d for d in self._builtins.values()} @@ -305,12 +310,35 @@ class DefUseChains(ast.NodeVisitor): location = self.location(node) print("W: unbound identifier '{}'{}".format(name, location)) - def maybe_unbound_identifier(self, name, node): - location = self.location(node) - print("W: identifier '{}' may be unbound at runtime{}".format(name, location)) + def invalid_name_lookup(self, name, scope, precomputed_locals, local_defs): + # We may hit the situation where we refer to a local variable which is + # not bound yet. This is a runtime error in Python, so we try to detec + # it statically. + # not a local variable => fine + if name not in precomputed_locals: + return + + # It's meant to be a local, but can we resolve it by a local lookup? + islocal = any((name in defs or '' in defs) for defs in local_defs) + + # At class scope, it's ok to refer to a global even if we also have a + # local definition for that variable. Stated other wise + # + # >>> a = 1 + # >>> def foo(): a = a + # >>> foo() # fails, a is a local referenced before being assigned + # >>> class bar: a = a + # >>> bar() # ok, and `bar.a is a` + if isinstance(scope, ast.ClassDef): + top_level_definitions = self._definitions[0:-self._scope_depths[0]] + isglobal = any((name in top_lvl_def or '' in top_lvl_def) + for top_lvl_def in top_level_definitions) + return not islocal and not isglobal + else: + return not islocal - def defs(self, node): + def defs(self, node, quiet=False): ''' Performs an actual lookup of node's id in current context, returning the list of def linked to that use. @@ -320,7 +348,7 @@ class DefUseChains(ast.NodeVisitor): # If the `global` keyword has been used, honor it if any(name in _globals for _globals in self._globals): - looked_up_definitions = self._definitions[0:1] + looked_up_definitions = self._definitions[0:-self._scope_depths[0]] else: # List of definitions to check. This includes all non-class # definitions and the last definition. Class definitions are not @@ -329,25 +357,34 @@ class DefUseChains(ast.NodeVisitor): scopes_iter = iter(reversed(self._scopes)) depths_iter = iter(reversed(self._scope_depths)) + precomputed_locals_iter = iter(reversed(self._precomputed_locals)) # Keep the last scope because we could be in class scope, in which # case we don't need fully qualified access. lvl = depth = next(depths_iter) - looked_up_definitions.extend(reversed(self._definitions[depth:])) - _ = next(scopes_iter) - - # Iterate over scopes, filtering out class scopes. - for scope, depth in zip(scopes_iter, depths_iter): - if not isinstance(scope, ast.ClassDef): - looked_up_definitions.extend( - reversed(self._definitions[lvl + depth: lvl])) - lvl += depth - - for d in looked_up_definitions: - if name in d: - return d[name] if not stars else stars + list(d[name]) - if "" in d: - stars.extend(d[""]) + precomputed_locals = next(precomputed_locals_iter) + base_scope = next(scopes_iter) + defs = self._definitions[depth:] + if not self.invalid_name_lookup(name, base_scope, precomputed_locals, defs): + looked_up_definitions.extend(reversed(defs)) + + # Iterate over scopes, filtering out class scopes. + for scope, depth, precomputed_locals in zip(scopes_iter, + depths_iter, + precomputed_locals_iter): + if not isinstance(scope, ast.ClassDef): + defs = self._definitions[lvl + depth: lvl] + if self.invalid_name_lookup(name, base_scope, precomputed_locals, defs): + looked_up_definitions.clear() + break + looked_up_definitions.extend(reversed(defs)) + lvl += depth + + for defs in looked_up_definitions: + if name in defs: + return defs[name] if not stars else stars + list(defs[name]) + if "" in defs: + stars.extend(defs[""]) d = self.chains.setdefault(node, Def(node)) @@ -357,7 +394,7 @@ class DefUseChains(ast.NodeVisitor): if stars: return stars + [d] else: - if not self._undefs: + if not self._undefs and not quiet: self.unbound_identifier(name, node) return [d] @@ -367,10 +404,10 @@ class DefUseChains(ast.NodeVisitor): if isinstance(stmt, (ast.Break, ast.Continue, ast.Raise)): if not deadcode: deadcode = True - self.deadcode += 1 + self._deadcode += 1 self.visit(stmt) if deadcode: - self.deadcode -= 1 + self._deadcode -= 1 def process_undefs(self): for undef_name, _undefs in self._undefs[-1].items(): @@ -385,6 +422,7 @@ class DefUseChains(ast.NodeVisitor): self.unbound_identifier(undef_name, undef.node) self._undefs.pop() + @contextmanager def ScopeContext(self, node): self._scopes.append(node) @@ -415,14 +453,16 @@ class DefUseChains(ast.NodeVisitor): self._definitions.pop() @contextmanager - def SwitchScopeContext(self, defs, scopes, scope_depths): + def SwitchScopeContext(self, defs, scopes, scope_depths, precomputed_locals): scope_depths, self._scope_depths = self._scope_depths, scope_depths scopes, self._scopes = self._scopes, scopes defs, self._definitions = self._definitions, defs + precomputed_locals, self._precomputed_locals = self._precomputed_locals, precomputed_locals yield self._definitions = defs self._scopes = scopes self._scope_depths = scope_depths + self._precomputed_locals = precomputed_locals # stmt @@ -437,10 +477,11 @@ class DefUseChains(ast.NodeVisitor): self.process_body(node.body) # handle function bodies - for fnode, defs, scopes, scope_depths in self._defered: + for fnode, defs, scopes, scope_depths, precomputed_locals in self._defered: visitor = getattr(self, "visit_{}".format(type(fnode).__name__)) - with self.SwitchScopeContext(defs, scopes, scope_depths): + with self.SwitchScopeContext(defs, scopes, scope_depths, + precomputed_locals): visitor(fnode, step=DefinitionStep) # various sanity checks @@ -461,9 +502,10 @@ class DefUseChains(ast.NodeVisitor): assert not self._definitions assert not self._scopes assert not self._scope_depths + assert not self._precomputed_locals def set_definition(self, name, dnode_or_dnodes): - if self.deadcode: + if self._deadcode: return if isinstance(dnode_or_dnodes, Def): self._definitions[-1][name] = ordered_set((dnode_or_dnodes,)) @@ -478,19 +520,19 @@ class DefUseChains(ast.NodeVisitor): definition[name].update(dnode_or_dnodes) def extend_definition(self, name, dnode_or_dnodes): - if self.deadcode: + if self._deadcode: return DefUseChains.add_to_definition(self._definitions[-1], name, dnode_or_dnodes) def extend_global(self, name, dnode_or_dnodes): - if self.deadcode: + if self._deadcode: return DefUseChains.add_to_definition(self._definitions[0], name, dnode_or_dnodes) def set_or_extend_global(self, name, dnode): - if self.deadcode: + if self._deadcode: return if name not in self._definitions[0]: self.locals[self.module].append(dnode) @@ -537,7 +579,8 @@ class DefUseChains(ast.NodeVisitor): self._defered.append((node, list(self._definitions), list(self._scopes), - list(self._scope_depths))) + list(self._scope_depths), + list(self._precomputed_locals))) elif step is DefinitionStep: with self.ScopeContext(node): for arg in node.args.args: @@ -617,7 +660,8 @@ class DefUseChains(ast.NodeVisitor): if any(node.target.id in _globals for _globals in self._globals): self.extend_global(node.target.id, dtarget) else: - loaded_from = [d.name() for d in self.defs(node.target)] + loaded_from = [d.name() for d in self.defs(node.target, + quiet=True)] self.set_definition(node.target.id, dtarget) # If we augassign from a value that comes from '', let's use # this node as the definition point. @@ -996,25 +1040,15 @@ class DefUseChains(ast.NodeVisitor): self.visit(node.annotation) elif isinstance(node.ctx, (ast.Load, ast.Del)): - # We hit the situation where we refer to a local variable that's not - # bound yet. This is a runtime error in Python, so we issue a warning. - # Note that because we may be in a condition, it's just a may* and it - # may be fine to ignore this warning. - current_locals = self._precomputed_locals[-1] - if node.id in current_locals and not self.is_in_current_scope(node.id): - self.maybe_unbound_identifier(node.id, node) + node_in_chains = node in self.chains + if node_in_chains: + dnode = self.chains[node] + else: dnode = Def(node) + for d in self.defs(node): + d.add_user(dnode) + if not node_in_chains: self.chains[node] = dnode - else: - node_in_chains = node in self.chains - if node_in_chains: - dnode = self.chains[node] - else: - dnode = Def(node) - for d in self.defs(node): - d.add_user(dnode) - if not node_in_chains: - self.chains[node] = dnode # currently ignore the effect of a del else: raise NotImplementedError()	serge-sans-paille/beniget	1f063aa472e96db8db14503f7b9f2bdb87118ebe	diff --git a/tests/chains.py b/tests/chains.py index c477328..f82abc1 100644 --- a/tests/chains.py +++ b/tests/chains.py @@ -94,6 +94,12 @@ class TestDefUseChains(TestCase): code = "a = 1; a += 2; a" self.checkChains(code, ['a -> (a -> (a -> ()))']) + def test_read_global_from_branch(self): + code = "if 1: a = 1\ndef foo():\n def bar(): global a; return a" + self.checkChains(code, ['a -> (a -> ())', + 'foo -> ()']) + + def test_expanded_augassign(self): code = "a = 1; a = a + 2" self.checkChains(code, ["a -> (a -> (BinOp -> ()))", "a -> ()"]) @@ -344,10 +350,17 @@ while done: code = "from some import decorator\n@decorator\nclass C:pass" self.checkChains(code, ["decorator -> (decorator -> (C -> ()))", "C -> ()"]) + def test_class_base(self): + code = "class A:...\nclass B(A):..." + self.checkChains(code, ["A -> (A -> (B -> ()))", "B -> ()"]) + @skipIf(sys.version_info.major < 3, "Python 3 syntax") def test_def_used_in_self_default(self): code = "def foo(x:foo): return foo" - self.checkChains(code, ["foo -> (foo -> ())"]) + c = beniget.DefUseChains() + node = ast.parse(code) + c.visit(node) + self.assertEqual(c.dump_chains(node), ["foo -> (foo -> ())"]) def test_unbound_class_variable(self): code = ''' @@ -361,7 +374,7 @@ def middle(): node = ast.parse(code) c.visit(node) self.assertEqual(c.dump_chains(node.body[0]), ['x -> (x -> ())', 'mytype -> ()']) - + def test_unbound_class_variable2(self): code = '''class A:\n a = 10\n def f(self):\n return a # a is not defined''' c = beniget.DefUseChains() @@ -375,7 +388,7 @@ def middle(): node = ast.parse(code) c.visit(node) self.assertEqual(c.dump_chains(node.body[0]), ['a -> ()', 'I -> ()']) - + def test_unbound_class_variable4(self): code = '''class A:\n a = 10\n f = lambda: a # a is not defined''' c = beniget.DefUseChains() @@ -400,7 +413,7 @@ def middle(): self.checkChains(code, ['x -> (x -> ())', 'foo -> ()']) @skipIf(sys.version_info.major < 3, "Python 3 syntax") - def test_class_annotation(self): + def test_arg_annotation(self): code = "type_ = int\ndef foo(bar: type_): pass" self.checkChains(code, ["type_ -> (type_ -> ())", "foo -> ()"]) @@ -454,22 +467,97 @@ def outer(): def test_maybe_unbound_identifier_message_format(self): code = "x = 1\ndef foo(): y = x; x = 2" self.check_message(code, - ["'x' may be unbound at runtime at <unknown>:2"]) + ["unbound identifier 'x' at <unknown>:2"]) def test_unbound_local_identifier_in_func(self): code = "def A():\n x = 1\n class B: x = x" self.check_message(code, - ["'x' may be unbound at runtime at <unknown>:3"]) + ["unbound identifier 'x' at <unknown>:3"]) + + @skipIf(sys.version_info < (3, 0), 'Python 3 syntax') + def test_unbound_local_identifier_in_method(self): + code = "class A:pass\nclass B:\n def A(self) -> A:pass" + self.check_message(code, []) @skipIf(sys.version_info < (3, 0), 'Python 3 syntax') def test_unbound_local_identifier_nonlocal(self): code = "def A():\n x = 1\n class B: nonlocal x; x = x" self.check_message(code, []) + + def test_assign_uses_class_level_name(self): + code = ''' +visit_Name = object +class Visitor: + def visit_Name(self, node):... + visit_Attribute = visit_Name +''' + node = ast.parse(code) + c = beniget.DefUseChains() + c.visit(node) + self.assertEqual(c.dump_chains(node), ['visit_Name -> ()', + 'Visitor -> ()']) + self.assertEqual(c.dump_chains(node.body[-1]), + ['visit_Name -> (visit_Name -> ())', + 'visit_Attribute -> ()']) + + + def test_base_class_uses_class_level_same_name(self): + code = ''' +class Attr(object):... +class Visitor: + class Attr(Attr):... + ''' + node = ast.parse(code) + c = beniget.DefUseChains() + c.visit(node) + self.assertEqual(c.dump_chains(node), + ['Attr -> (Attr -> (Attr -> ()))', + 'Visitor -> ()']) + self.assertEqual(c.dump_chains(node.body[-1]), ['Attr -> ()']) + + + @skipIf(sys.version_info < (3, 0), 'Python 3 syntax') + def test_annotation_uses_class_level_name(self): + code = ''' +Thing = object +def f():... +class Visitor: + Thing = bytes + def f(): return f() + def visit_Name(self, node:Thing, fn:f):... +''' + node = ast.parse(code) + c = beniget.DefUseChains() + c.visit(node) + self.assertEqual(c.dump_chains(node), + ['Thing -> ()', + 'f -> (f -> (Call -> ()))', + 'Visitor -> ()']) + self.assertEqual(c.dump_chains(node.body[-1]), + ['Thing -> (Thing -> ())', + 'f -> (f -> ())', + 'visit_Name -> ()']) + + def test_assign_uses_class_level_same_name(self): + code = ''' +def visit_Attribute(self, node):... +class Visitor: + visit_Attribute = visit_Attribute +''' + node = ast.parse(code) + c = beniget.DefUseChains() + c.visit(node) + self.assertEqual(c.dump_chains(node), + ['visit_Attribute -> (visit_Attribute -> ())', + 'Visitor -> ()']) + self.assertEqual(c.dump_chains(node.body[-1]), + ['visit_Attribute -> ()']) + def test_unbound_local_identifier_in_augassign(self): code = "def A():\n x = 1\n class B: x += 1" self.check_message(code, - ["'x' may be unbound at runtime at <unknown>:3"]) + ["unbound identifier 'x' at <unknown>:3"]) def test_star_import_with_conditional_redef(self): code = '''	Scoping rule not correctly honored for type annotation There is no ambiguity in the following code: ``` class Attr:... class Cls: def Attr(self) -> Attr:... ``` but beniget issues a warning about `-> Attr` being potentially unbound at runtime.	1f063aa472e96db8db14503f7b9f2bdb87118ebe	[ "tests/chains.py::TestDefUseChains::test_assign_uses_class_level_same_name", "tests/chains.py::TestDefUseChains::test_base_class_uses_class_level_same_name", "tests/chains.py::TestDefUseChains::test_maybe_unbound_identifier_message_format", "tests/chains.py::TestDefUseChains::test_unbound_local_identifier_in_augassign", "tests/chains.py::TestDefUseChains::test_unbound_local_identifier_in_func", "tests/chains.py::TestDefUseChains::test_unbound_local_identifier_in_method" ]	[ "tests/chains.py::TestDefUseChains::test_annotation_inner_class", "tests/chains.py::TestDefUseChains::test_annotation_uses_class_level_name", "tests/chains.py::TestDefUseChains::test_arg_annotation", "tests/chains.py::TestDefUseChains::test_assign_in_loop", "tests/chains.py::TestDefUseChains::test_assign_in_loop_in_conditional", "tests/chains.py::TestDefUseChains::test_assign_in_while_in_conditional", "tests/chains.py::TestDefUseChains::test_assign_uses_class_level_name", "tests/chains.py::TestDefUseChains::test_attr", "tests/chains.py::TestDefUseChains::test_augassign", "tests/chains.py::TestDefUseChains::test_augassign_in_loop", "tests/chains.py::TestDefUseChains::test_break_in_loop", "tests/chains.py::TestDefUseChains::test_class_base", "tests/chains.py::TestDefUseChains::test_class_decorator", "tests/chains.py::TestDefUseChains::test_complex_for_orelse", "tests/chains.py::TestDefUseChains::test_complex_while_orelse", "tests/chains.py::TestDefUseChains::test_continue_in_loop", "tests/chains.py::TestDefUseChains::test_def_used_in_self_default", "tests/chains.py::TestDefUseChains::test_expanded_augassign", "tests/chains.py::TestDefUseChains::test_expression_chain", "tests/chains.py::TestDefUseChains::test_for_break", "tests/chains.py::TestDefUseChains::test_for_pass", "tests/chains.py::TestDefUseChains::test_functiondef_returns", "tests/chains.py::TestDefUseChains::test_if_both_branch", "tests/chains.py::TestDefUseChains::test_if_false_branch", "tests/chains.py::TestDefUseChains::test_if_in_loop", "tests/chains.py::TestDefUseChains::test_if_true_branch", "tests/chains.py::TestDefUseChains::test_ifexp_chain", "tests/chains.py::TestDefUseChains::test_import_from", "tests/chains.py::TestDefUseChains::test_import_from_as", "tests/chains.py::TestDefUseChains::test_method_function_conflict", "tests/chains.py::TestDefUseChains::test_multiple_import_as", "tests/chains.py::TestDefUseChains::test_multiple_import_from_as", "tests/chains.py::TestDefUseChains::test_named_expr_complex", "tests/chains.py::TestDefUseChains::test_named_expr_simple", "tests/chains.py::TestDefUseChains::test_named_expr_with_rename", "tests/chains.py::TestDefUseChains::test_nested_if", "tests/chains.py::TestDefUseChains::test_nested_if_else", "tests/chains.py::TestDefUseChains::test_nested_while", "tests/chains.py::TestDefUseChains::test_no_unbound_local_identifier_in_comp", "tests/chains.py::TestDefUseChains::test_read_global_from_branch", "tests/chains.py::TestDefUseChains::test_reassign_in_loop", "tests/chains.py::TestDefUseChains::test_redef_try_except", "tests/chains.py::TestDefUseChains::test_simple_except", "tests/chains.py::TestDefUseChains::test_simple_expression", "tests/chains.py::TestDefUseChains::test_simple_for", "tests/chains.py::TestDefUseChains::test_simple_for_orelse", "tests/chains.py::TestDefUseChains::test_simple_import", "tests/chains.py::TestDefUseChains::test_simple_import_as", "tests/chains.py::TestDefUseChains::test_simple_print", "tests/chains.py::TestDefUseChains::test_simple_redefinition", "tests/chains.py::TestDefUseChains::test_simple_try", "tests/chains.py::TestDefUseChains::test_simple_try_except", "tests/chains.py::TestDefUseChains::test_simple_while", "tests/chains.py::TestDefUseChains::test_star_import_with_conditional_redef", "tests/chains.py::TestDefUseChains::test_try_except", "tests/chains.py::TestDefUseChains::test_type_destructuring_for", "tests/chains.py::TestDefUseChains::test_type_destructuring_list", "tests/chains.py::TestDefUseChains::test_type_destructuring_tuple", "tests/chains.py::TestDefUseChains::test_unbound_class_variable", "tests/chains.py::TestDefUseChains::test_unbound_class_variable2", "tests/chains.py::TestDefUseChains::test_unbound_class_variable3", "tests/chains.py::TestDefUseChains::test_unbound_class_variable4", "tests/chains.py::TestDefUseChains::test_unbound_class_variable5", "tests/chains.py::TestDefUseChains::test_unbound_class_variable_reference_message_format", "tests/chains.py::TestDefUseChains::test_unbound_identifier_message_format", "tests/chains.py::TestDefUseChains::test_unbound_local_identifier_nonlocal", "tests/chains.py::TestDefUseChains::test_while_break", "tests/chains.py::TestDefUseChains::test_while_cond_break", "tests/chains.py::TestDefUseChains::test_while_cond_continue", "tests/chains.py::TestDefUseChains::test_while_nested_break", "tests/chains.py::TestDefUseChains::test_while_orelse_break", "tests/chains.py::TestDefUseChains::test_with_handler", "tests/chains.py::TestUseDefChains::test_call", "tests/chains.py::TestUseDefChains::test_simple_expression" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-04-05 06:02:14+00:00	bsd-3-clause	5,476
serge-sans-paille__beniget-70	diff --git a/beniget/beniget.py b/beniget/beniget.py index 50f035b..c964c50 100644 --- a/beniget/beniget.py +++ b/beniget/beniget.py @@ -1025,11 +1025,19 @@ class DefUseChains(ast.NodeVisitor): def visit_Lambda(self, node, step=DeclarationStep): if step is DeclarationStep: dnode = self.chains.setdefault(node, Def(node)) + for default in node.args.defaults: + self.visit(default).add_user(dnode) + self._defered.append((node, + list(self._definitions), + list(self._scopes), + list(self._scope_depths), + list(self._precomputed_locals))) return dnode elif step is DefinitionStep: dnode = self.chains[node] with self.ScopeContext(node): - self.visit(node.args) + for a in node.args.args: + self.visit(a) self.visit(node.body).add_user(dnode) return dnode else:	serge-sans-paille/beniget	c1c6ae396b54b593f9566861ae9197a7e104c585	diff --git a/tests/test_chains.py b/tests/test_chains.py index e9d33f8..288ccc6 100644 --- a/tests/test_chains.py +++ b/tests/test_chains.py @@ -332,6 +332,22 @@ while done: def test_simple_import_as(self): code = "import x as y; y()" self.checkChains(code, ["y -> (y -> (Call -> ()))"]) + + def test_simple_lambda(self): + node, c = self.checkChains( "lambda y: True", []) + self.assertEqual(c.dump_chains(node.body[0].value), ['y -> ()']) + + def test_lambda_defaults(self): + node, c = self.checkChains( "x=y=1;(lambda y, x=x: (True, x, y, z)); x=y=z=2", + ['x -> (x -> (Lambda -> ()))', + 'y -> ()', + 'x -> ()', + 'y -> ()', + 'z -> (z -> (Tuple -> (Lambda -> ())))']) + self.assertEqual(c.dump_chains(node.body[1].value), [ + 'y -> (y -> (Tuple -> (Lambda -> ())))', + 'x -> (x -> (Tuple -> (Lambda -> ())))', + ]) def test_multiple_import_as(self): code = "import x as y, z; y"	Regression in Lambda functions This new test was passing in version 0.4.1 and now shows nothing ```python def test_simple_lambda(self): code = "lambda y: True" node = ast.parse(code) c = beniget.DefUseChains() c.visit(node) self.assertEqual(c.dump_chains(node), []) self.assertEqual(c.dump_chains(node.body[0].value), ['y -> ()']) ```	c1c6ae396b54b593f9566861ae9197a7e104c585	[ "tests/test_chains.py::TestDefUseChains::test_lambda_defaults", "tests/test_chains.py::TestDefUseChains::test_simple_lambda" ]	[ "tests/test_chains.py::TestDefUseChains::test_annotation_in_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_in_inner_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_class", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_inner_fn", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_annotation_use_upper_scope_variables", "tests/test_chains.py::TestDefUseChains::test_annotation_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_annotation_very_nested", "tests/test_chains.py::TestDefUseChains::test_arg_annotation", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_in_while_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_attr", "tests/test_chains.py::TestDefUseChains::test_augassign", "tests/test_chains.py::TestDefUseChains::test_augassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_base_class_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_break_in_loop", "tests/test_chains.py::TestDefUseChains::test_class_base", "tests/test_chains.py::TestDefUseChains::test_class_decorator", "tests/test_chains.py::TestDefUseChains::test_complex_for_orelse", "tests/test_chains.py::TestDefUseChains::test_complex_while_orelse", "tests/test_chains.py::TestDefUseChains::test_continue_in_loop", "tests/test_chains.py::TestDefUseChains::test_def_used_in_self_default", "tests/test_chains.py::TestDefUseChains::test_expanded_augassign", "tests/test_chains.py::TestDefUseChains::test_expression_chain", "tests/test_chains.py::TestDefUseChains::test_for_break", "tests/test_chains.py::TestDefUseChains::test_for_pass", "tests/test_chains.py::TestDefUseChains::test_functiondef_returns", "tests/test_chains.py::TestDefUseChains::test_future_annotation_class_var", "tests/test_chains.py::TestDefUseChains::test_if_both_branch", "tests/test_chains.py::TestDefUseChains::test_if_false_branch", "tests/test_chains.py::TestDefUseChains::test_if_in_loop", "tests/test_chains.py::TestDefUseChains::test_if_true_branch", "tests/test_chains.py::TestDefUseChains::test_ifexp_chain", "tests/test_chains.py::TestDefUseChains::test_import_dotted_name_binds_first_name", "tests/test_chains.py::TestDefUseChains::test_import_from", "tests/test_chains.py::TestDefUseChains::test_import_from_as", "tests/test_chains.py::TestDefUseChains::test_lookup_scopes", "tests/test_chains.py::TestDefUseChains::test_maybe_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_method_function_conflict", "tests/test_chains.py::TestDefUseChains::test_multiple_import_as", "tests/test_chains.py::TestDefUseChains::test_multiple_import_from_as", "tests/test_chains.py::TestDefUseChains::test_multiple_wildcards_may_bind", "tests/test_chains.py::TestDefUseChains::test_named_expr_complex", "tests/test_chains.py::TestDefUseChains::test_named_expr_simple", "tests/test_chains.py::TestDefUseChains::test_named_expr_with_rename", "tests/test_chains.py::TestDefUseChains::test_nested_if", "tests/test_chains.py::TestDefUseChains::test_nested_if_else", "tests/test_chains.py::TestDefUseChains::test_nested_while", "tests/test_chains.py::TestDefUseChains::test_no_unbound_local_identifier_in_comp", "tests/test_chains.py::TestDefUseChains::test_pep0563_annotations", "tests/test_chains.py::TestDefUseChains::test_pep563_self_referential_annotation", "tests/test_chains.py::TestDefUseChains::test_pep563_type_alias_override_class", "tests/test_chains.py::TestDefUseChains::test_read_global_from_branch", "tests/test_chains.py::TestDefUseChains::test_reassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_redef_try_except", "tests/test_chains.py::TestDefUseChains::test_redefinition_in_comp", "tests/test_chains.py::TestDefUseChains::test_simple_except", "tests/test_chains.py::TestDefUseChains::test_simple_expression", "tests/test_chains.py::TestDefUseChains::test_simple_for", "tests/test_chains.py::TestDefUseChains::test_simple_for_orelse", "tests/test_chains.py::TestDefUseChains::test_simple_import", "tests/test_chains.py::TestDefUseChains::test_simple_import_as", "tests/test_chains.py::TestDefUseChains::test_simple_print", "tests/test_chains.py::TestDefUseChains::test_simple_redefinition", "tests/test_chains.py::TestDefUseChains::test_simple_try", "tests/test_chains.py::TestDefUseChains::test_simple_try_except", "tests/test_chains.py::TestDefUseChains::test_simple_while", "tests/test_chains.py::TestDefUseChains::test_star_import_with_conditional_redef", "tests/test_chains.py::TestDefUseChains::test_straight_raise", "tests/test_chains.py::TestDefUseChains::test_try_except", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_for", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_list", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_tuple", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable2", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable3", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable4", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable5", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable_reference_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_augassign", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_func", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_method", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_nonlocal", "tests/test_chains.py::TestDefUseChains::test_while_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_continue", "tests/test_chains.py::TestDefUseChains::test_while_nested_break", "tests/test_chains.py::TestDefUseChains::test_while_orelse_break", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation_and_global_scope", "tests/test_chains.py::TestDefUseChains::test_wildcard_may_override", "tests/test_chains.py::TestDefUseChains::test_with_handler", "tests/test_chains.py::TestUseDefChains::test_call", "tests/test_chains.py::TestUseDefChains::test_simple_expression" ]	{ "failed_lite_validators": [ "has_short_problem_statement" ], "has_test_patch": true, "is_lite": false }	2023-08-07 18:29:26+00:00	bsd-3-clause	5,477
serge-sans-paille__beniget-78	diff --git a/beniget/beniget.py b/beniget/beniget.py index 4faa64d..fe38b13 100644 --- a/beniget/beniget.py +++ b/beniget/beniget.py @@ -665,6 +665,14 @@ class DefUseChains(ast.NodeVisitor): def extend_global(self, name, dnode_or_dnodes): if self._deadcode: return + # `name` should be in self._definitions[0] because we extend the + # globals. Yet the original code maybe faulty and we need to cope with + # it. + if name not in self._definitions[0]: + if isinstance(dnode_or_dnodes, Def): + self.locals[self.module].append(dnode_or_dnodes) + else: + self.locals[self.module].extend(dnode_or_dnodes) DefUseChains.add_to_definition(self._definitions[0], name, dnode_or_dnodes)	serge-sans-paille/beniget	dbca2f88948adb19bfcdd5111059b25fc9af5cdf	diff --git a/tests/test_chains.py b/tests/test_chains.py index 1e9bdaa..d2fa72c 100644 --- a/tests/test_chains.py +++ b/tests/test_chains.py @@ -111,6 +111,9 @@ class TestDefUseChains(TestCase): self.checkChains(code, ['a -> (a -> ())', 'foo -> ()']) + def test_augassign_undefined_global(self): + code = "def foo():\n def bar():\n global x\n x+=1; x" + self.checkChains(code, ['foo -> ()', 'x -> (x -> ())'], strict=False) def test_expanded_augassign(self): code = "a = 1; a = a + 2"	AssertionError in the __debug__ sanity checks when parsing idlelib.config It can be reproduced as follows, but I don't have a minimal reproducer at the moment. ``` % curl --silent https://raw.githubusercontent.com/python/cpython/3.12/Lib/idlelib/config.py > test.py % python3 -m beniget test.py W: unbound identifier 'line' at test.py:885:8 W: unbound identifier 'crc' at test.py:886:50 [...] File "beniget/beniget.py", line 616, in visit_Module assert nb_defs == nb_heads + nb_bltns - nb_overloaded_bltns ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ AssertionError ```	dbca2f88948adb19bfcdd5111059b25fc9af5cdf	[ "tests/test_chains.py::TestDefUseChains::test_augassign_undefined_global" ]	[ "tests/test_chains.py::TestDefUseChains::test_annotation_in_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_in_inner_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_class", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_inner_fn", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_annotation_use_upper_scope_variables", "tests/test_chains.py::TestDefUseChains::test_annotation_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_annotation_very_nested", "tests/test_chains.py::TestDefUseChains::test_arg_annotation", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_in_while_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_attr", "tests/test_chains.py::TestDefUseChains::test_attribute_assignment", "tests/test_chains.py::TestDefUseChains::test_augassign", "tests/test_chains.py::TestDefUseChains::test_augassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_base_class_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_break_in_loop", "tests/test_chains.py::TestDefUseChains::test_call_assignment", "tests/test_chains.py::TestDefUseChains::test_class_base", "tests/test_chains.py::TestDefUseChains::test_class_decorator", "tests/test_chains.py::TestDefUseChains::test_class_scope_comprehension", "tests/test_chains.py::TestDefUseChains::test_class_scope_comprehension_invalid", "tests/test_chains.py::TestDefUseChains::test_complex_for_orelse", "tests/test_chains.py::TestDefUseChains::test_complex_while_orelse", "tests/test_chains.py::TestDefUseChains::test_continue_in_loop", "tests/test_chains.py::TestDefUseChains::test_def_used_in_self_default", "tests/test_chains.py::TestDefUseChains::test_expanded_augassign", "tests/test_chains.py::TestDefUseChains::test_expression_chain", "tests/test_chains.py::TestDefUseChains::test_for_break", "tests/test_chains.py::TestDefUseChains::test_for_pass", "tests/test_chains.py::TestDefUseChains::test_functiondef_returns", "tests/test_chains.py::TestDefUseChains::test_future_annotation_class_var", "tests/test_chains.py::TestDefUseChains::test_if_both_branch", "tests/test_chains.py::TestDefUseChains::test_if_false_branch", "tests/test_chains.py::TestDefUseChains::test_if_in_loop", "tests/test_chains.py::TestDefUseChains::test_if_true_branch", "tests/test_chains.py::TestDefUseChains::test_ifexp_chain", "tests/test_chains.py::TestDefUseChains::test_import_dotted_name_binds_first_name", "tests/test_chains.py::TestDefUseChains::test_import_from", "tests/test_chains.py::TestDefUseChains::test_import_from_as", "tests/test_chains.py::TestDefUseChains::test_lambda_defaults", "tests/test_chains.py::TestDefUseChains::test_lookup_scopes", "tests/test_chains.py::TestDefUseChains::test_maybe_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_method_function_conflict", "tests/test_chains.py::TestDefUseChains::test_multiple_import_as", "tests/test_chains.py::TestDefUseChains::test_multiple_import_from_as", "tests/test_chains.py::TestDefUseChains::test_multiple_wildcards_may_bind", "tests/test_chains.py::TestDefUseChains::test_named_expr_complex", "tests/test_chains.py::TestDefUseChains::test_named_expr_comprehension", "tests/test_chains.py::TestDefUseChains::test_named_expr_comprehension_invalid", "tests/test_chains.py::TestDefUseChains::test_named_expr_simple", "tests/test_chains.py::TestDefUseChains::test_named_expr_with_rename", "tests/test_chains.py::TestDefUseChains::test_nested_if", "tests/test_chains.py::TestDefUseChains::test_nested_if_else", "tests/test_chains.py::TestDefUseChains::test_nested_while", "tests/test_chains.py::TestDefUseChains::test_no_unbound_local_identifier_in_comp", "tests/test_chains.py::TestDefUseChains::test_pep0563_annotations", "tests/test_chains.py::TestDefUseChains::test_pep563_self_referential_annotation", "tests/test_chains.py::TestDefUseChains::test_pep563_type_alias_override_class", "tests/test_chains.py::TestDefUseChains::test_read_global_from_branch", "tests/test_chains.py::TestDefUseChains::test_reassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_redef_try_except", "tests/test_chains.py::TestDefUseChains::test_redefinition_in_comp", "tests/test_chains.py::TestDefUseChains::test_simple_except", "tests/test_chains.py::TestDefUseChains::test_simple_expression", "tests/test_chains.py::TestDefUseChains::test_simple_for", "tests/test_chains.py::TestDefUseChains::test_simple_for_orelse", "tests/test_chains.py::TestDefUseChains::test_simple_import", "tests/test_chains.py::TestDefUseChains::test_simple_import_as", "tests/test_chains.py::TestDefUseChains::test_simple_lambda", "tests/test_chains.py::TestDefUseChains::test_simple_print", "tests/test_chains.py::TestDefUseChains::test_simple_redefinition", "tests/test_chains.py::TestDefUseChains::test_simple_try", "tests/test_chains.py::TestDefUseChains::test_simple_try_except", "tests/test_chains.py::TestDefUseChains::test_simple_while", "tests/test_chains.py::TestDefUseChains::test_star_assignment", "tests/test_chains.py::TestDefUseChains::test_star_assignment_nested", "tests/test_chains.py::TestDefUseChains::test_star_import_with_conditional_redef", "tests/test_chains.py::TestDefUseChains::test_straight_raise", "tests/test_chains.py::TestDefUseChains::test_try_except", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_for", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_list", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_starred", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_tuple", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable2", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable3", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable4", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable5", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable_reference_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_augassign", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_func", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_method", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_nonlocal", "tests/test_chains.py::TestDefUseChains::test_while_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_continue", "tests/test_chains.py::TestDefUseChains::test_while_nested_break", "tests/test_chains.py::TestDefUseChains::test_while_orelse_break", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation_and_global_scope", "tests/test_chains.py::TestDefUseChains::test_wildcard_may_override", "tests/test_chains.py::TestDefUseChains::test_with_handler", "tests/test_chains.py::TestUseDefChains::test_call", "tests/test_chains.py::TestUseDefChains::test_simple_expression" ]	{ "failed_lite_validators": [ "has_hyperlinks" ], "has_test_patch": true, "is_lite": false }	2023-09-18 19:44:13+00:00	bsd-3-clause	5,478
serge-sans-paille__beniget-80	diff --git a/beniget/beniget.py b/beniget/beniget.py index fe38b13..efe40bb 100644 --- a/beniget/beniget.py +++ b/beniget/beniget.py @@ -1058,6 +1058,7 @@ class DefUseChains(ast.NodeVisitor): dnode = self.chains.setdefault(node, Def(node)) for default in node.args.defaults: self.visit(default).add_user(dnode) + # a lambda never has kw_defaults self._defered.append((node, list(self._definitions), list(self._scopes), @@ -1067,7 +1068,7 @@ class DefUseChains(ast.NodeVisitor): elif step is DefinitionStep: dnode = self.chains[node] with self.ScopeContext(node): - for a in node.args.args: + for a in _iter_arguments(node.args): self.visit(a) self.visit(node.body).add_user(dnode) return dnode	serge-sans-paille/beniget	3b3f4498476a136ecedbb954f31d71767d0ae5cc	diff --git a/tests/test_chains.py b/tests/test_chains.py index d2fa72c..ff309e7 100644 --- a/tests/test_chains.py +++ b/tests/test_chains.py @@ -357,6 +357,14 @@ while done: 'x -> (x -> (Tuple -> (Lambda -> ())))', ]) + def test_lambda_varargs(self): + node, c = self.checkChains( "lambda args: args", []) + self.assertEqual(c.dump_chains(node.body[0].value), ['args -> (args -> (Lambda -> ()))']) + + def test_lambda_kwargs(self): + node, c = self.checkChains( "lambda *kwargs: kwargs", []) + self.assertEqual(c.dump_chains(node.body[0].value), ['kwargs -> (kwargs -> (Lambda -> ()))']) + def test_multiple_import_as(self): code = "import x as y, z; y" self.checkChains(code, ["y -> (y -> ())", "z -> ()"])	Variable lenght arguments in lambda are ignored ```python lambda *args: args ``` The code above generates the following warning: ``` W: unbound identifier 'args' at ./test.py:1:14 ```	3b3f4498476a136ecedbb954f31d71767d0ae5cc	[ "tests/test_chains.py::TestDefUseChains::test_lambda_kwargs", "tests/test_chains.py::TestDefUseChains::test_lambda_varargs" ]	[ "tests/test_chains.py::TestDefUseChains::test_annotation_in_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_in_inner_functions_locals", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_class", "tests/test_chains.py::TestDefUseChains::test_annotation_inner_inner_fn", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_annotation_use_upper_scope_variables", "tests/test_chains.py::TestDefUseChains::test_annotation_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_annotation_very_nested", "tests/test_chains.py::TestDefUseChains::test_arg_annotation", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop", "tests/test_chains.py::TestDefUseChains::test_assign_in_loop_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_in_while_in_conditional", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_name", "tests/test_chains.py::TestDefUseChains::test_assign_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_attr", "tests/test_chains.py::TestDefUseChains::test_attribute_assignment", "tests/test_chains.py::TestDefUseChains::test_augassign", "tests/test_chains.py::TestDefUseChains::test_augassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_augassign_undefined_global", "tests/test_chains.py::TestDefUseChains::test_base_class_uses_class_level_same_name", "tests/test_chains.py::TestDefUseChains::test_break_in_loop", "tests/test_chains.py::TestDefUseChains::test_call_assignment", "tests/test_chains.py::TestDefUseChains::test_class_base", "tests/test_chains.py::TestDefUseChains::test_class_decorator", "tests/test_chains.py::TestDefUseChains::test_class_scope_comprehension", "tests/test_chains.py::TestDefUseChains::test_class_scope_comprehension_invalid", "tests/test_chains.py::TestDefUseChains::test_complex_for_orelse", "tests/test_chains.py::TestDefUseChains::test_complex_while_orelse", "tests/test_chains.py::TestDefUseChains::test_continue_in_loop", "tests/test_chains.py::TestDefUseChains::test_def_used_in_self_default", "tests/test_chains.py::TestDefUseChains::test_expanded_augassign", "tests/test_chains.py::TestDefUseChains::test_expression_chain", "tests/test_chains.py::TestDefUseChains::test_for_break", "tests/test_chains.py::TestDefUseChains::test_for_pass", "tests/test_chains.py::TestDefUseChains::test_functiondef_returns", "tests/test_chains.py::TestDefUseChains::test_future_annotation_class_var", "tests/test_chains.py::TestDefUseChains::test_if_both_branch", "tests/test_chains.py::TestDefUseChains::test_if_false_branch", "tests/test_chains.py::TestDefUseChains::test_if_in_loop", "tests/test_chains.py::TestDefUseChains::test_if_true_branch", "tests/test_chains.py::TestDefUseChains::test_ifexp_chain", "tests/test_chains.py::TestDefUseChains::test_import_dotted_name_binds_first_name", "tests/test_chains.py::TestDefUseChains::test_import_from", "tests/test_chains.py::TestDefUseChains::test_import_from_as", "tests/test_chains.py::TestDefUseChains::test_lambda_defaults", "tests/test_chains.py::TestDefUseChains::test_lookup_scopes", "tests/test_chains.py::TestDefUseChains::test_maybe_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound", "tests/test_chains.py::TestDefUseChains::test_method_annotation_unbound_pep563", "tests/test_chains.py::TestDefUseChains::test_method_function_conflict", "tests/test_chains.py::TestDefUseChains::test_multiple_import_as", "tests/test_chains.py::TestDefUseChains::test_multiple_import_from_as", "tests/test_chains.py::TestDefUseChains::test_multiple_wildcards_may_bind", "tests/test_chains.py::TestDefUseChains::test_named_expr_complex", "tests/test_chains.py::TestDefUseChains::test_named_expr_comprehension", "tests/test_chains.py::TestDefUseChains::test_named_expr_comprehension_invalid", "tests/test_chains.py::TestDefUseChains::test_named_expr_simple", "tests/test_chains.py::TestDefUseChains::test_named_expr_with_rename", "tests/test_chains.py::TestDefUseChains::test_nested_if", "tests/test_chains.py::TestDefUseChains::test_nested_if_else", "tests/test_chains.py::TestDefUseChains::test_nested_while", "tests/test_chains.py::TestDefUseChains::test_no_unbound_local_identifier_in_comp", "tests/test_chains.py::TestDefUseChains::test_pep0563_annotations", "tests/test_chains.py::TestDefUseChains::test_pep563_self_referential_annotation", "tests/test_chains.py::TestDefUseChains::test_pep563_type_alias_override_class", "tests/test_chains.py::TestDefUseChains::test_read_global_from_branch", "tests/test_chains.py::TestDefUseChains::test_reassign_in_loop", "tests/test_chains.py::TestDefUseChains::test_redef_try_except", "tests/test_chains.py::TestDefUseChains::test_redefinition_in_comp", "tests/test_chains.py::TestDefUseChains::test_simple_except", "tests/test_chains.py::TestDefUseChains::test_simple_expression", "tests/test_chains.py::TestDefUseChains::test_simple_for", "tests/test_chains.py::TestDefUseChains::test_simple_for_orelse", "tests/test_chains.py::TestDefUseChains::test_simple_import", "tests/test_chains.py::TestDefUseChains::test_simple_import_as", "tests/test_chains.py::TestDefUseChains::test_simple_lambda", "tests/test_chains.py::TestDefUseChains::test_simple_print", "tests/test_chains.py::TestDefUseChains::test_simple_redefinition", "tests/test_chains.py::TestDefUseChains::test_simple_try", "tests/test_chains.py::TestDefUseChains::test_simple_try_except", "tests/test_chains.py::TestDefUseChains::test_simple_while", "tests/test_chains.py::TestDefUseChains::test_star_assignment", "tests/test_chains.py::TestDefUseChains::test_star_assignment_nested", "tests/test_chains.py::TestDefUseChains::test_star_import_with_conditional_redef", "tests/test_chains.py::TestDefUseChains::test_straight_raise", "tests/test_chains.py::TestDefUseChains::test_try_except", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_for", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_list", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_starred", "tests/test_chains.py::TestDefUseChains::test_type_destructuring_tuple", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable2", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable3", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable4", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable5", "tests/test_chains.py::TestDefUseChains::test_unbound_class_variable_reference_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_identifier_message_format", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_augassign", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_func", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_in_method", "tests/test_chains.py::TestDefUseChains::test_unbound_local_identifier_nonlocal", "tests/test_chains.py::TestDefUseChains::test_while_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_break", "tests/test_chains.py::TestDefUseChains::test_while_cond_continue", "tests/test_chains.py::TestDefUseChains::test_while_nested_break", "tests/test_chains.py::TestDefUseChains::test_while_orelse_break", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation", "tests/test_chains.py::TestDefUseChains::test_wilcard_import_annotation_and_global_scope", "tests/test_chains.py::TestDefUseChains::test_wildcard_may_override", "tests/test_chains.py::TestDefUseChains::test_with_handler", "tests/test_chains.py::TestUseDefChains::test_call", "tests/test_chains.py::TestUseDefChains::test_simple_expression" ]	{ "failed_lite_validators": [ "has_short_problem_statement" ], "has_test_patch": true, "is_lite": false }	2023-09-24 14:56:42+00:00	bsd-3-clause	5,479
serge-sans-paille__gast-50	diff --git a/gast/ast2.py b/gast/ast2.py index 0e0a8ed..8968b5b 100644 --- a/gast/ast2.py +++ b/gast/ast2.py @@ -40,6 +40,17 @@ class Ast2ToGAst(AstToGAst): new_node.end_lineno = new_node.end_col_offset = None return new_node + def visit_Assign(self, node): + new_node = gast.Assign( + self._visit(node.targets), + self._visit(node.value), + None, # type_comment + ) + + gast.copy_location(new_node, node) + new_node.end_lineno = new_node.end_col_offset = None + return new_node + def visit_For(self, node): new_node = gast.For( self._visit(node.target), @@ -278,6 +289,15 @@ class GAstToAst2(GAstToAst): ast.copy_location(new_node, node) return new_node + def visit_Assign(self, node): + new_node = ast.Assign( + self._visit(node.targets), + self._visit(node.value), + ) + + ast.copy_location(new_node, node) + return new_node + def visit_For(self, node): new_node = ast.For( self._visit(node.target), diff --git a/gast/ast3.py b/gast/ast3.py index 2d56fca..d0f0d39 100644 --- a/gast/ast3.py +++ b/gast/ast3.py @@ -15,6 +15,17 @@ class Ast3ToGAst(AstToGAst): def visit_Index(self, node): return self._visit(node.value) + def visit_Assign(self, node): + new_node = gast.Assign( + self._visit(node.targets), + self._visit(node.value), + None, # type_comment + ) + + gast.copy_location(new_node, node) + new_node.end_lineno = new_node.end_col_offset = None + return new_node + if sys.version_info.minor < 8: def visit_Module(self, node): new_node = gast.Module( @@ -247,6 +258,15 @@ class GAstToAst3(GAstToAst): ast.copy_location(new_node, node) return new_node + def visit_Assign(self, node): + new_node = ast.Assign( + self._visit(node.targets), + self._visit(node.value), + ) + + ast.copy_location(new_node, node) + return new_node + if sys.version_info.minor < 8: def visit_Module(self, node): diff --git a/gast/gast.py b/gast/gast.py index 317d4b1..00150ca 100644 --- a/gast/gast.py +++ b/gast/gast.py @@ -61,7 +61,7 @@ _nodes = ( ('Delete', (('targets',), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (stmt,))), - ('Assign', (('targets', 'value',), + ('Assign', (('targets', 'value', 'type_comment'), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (stmt,))), ('AugAssign', (('target', 'op', 'value',),	serge-sans-paille/gast	365fa06e88f38c14cdff53d1ae437851a411e7a6	diff --git a/tests/test_compat.py b/tests/test_compat.py index e944647..c04c433 100644 --- a/tests/test_compat.py +++ b/tests/test_compat.py @@ -61,7 +61,8 @@ class CompatTestCase(unittest.TestCase): compile(gast.gast_to_ast(tree), '<test>', 'exec') norm = ("Module(body=[Assign(targets=[Name(id='e', ctx=Store()" ", annotation=None, type_comment=None" - ")], value=Constant(value=1, kind=None)), Expr(value=" + ")], value=Constant(value=1, kind=None), " + "type_comment=None), Expr(value=" "JoinedStr(values=[FormattedValue(value=Name(id='e', " "ctx=Load(), annotation=None, type_comment=None), " "conversion=-1, format_spec=None)]))], " @@ -74,7 +75,8 @@ class CompatTestCase(unittest.TestCase): compile(gast.gast_to_ast(tree), '<test>', 'exec') norm = ("Module(body=[Assign(targets=[Name(id='e', ctx=Store()" ", annotation=None, type_comment=None" - ")], value=Constant(value=1, kind=None)), Expr(value=" + ")], value=Constant(value=1, kind=None), " + "type_comment=None), Expr(value=" "JoinedStr(values=[Constant(value='e = ', kind=None), " "FormattedValue(value=Name(id='e', ctx=Load(), " "annotation=None, type_comment=None), "	ast.Assign need type_comment in Python3.8 In python3.8.5，I use gast to modify ast_node then convert back into ast by`gast_to_ast`. But the result is different with original `ast`. It works in Python3.5 and Python2.7 The example code: ```python import ast import gast import textwrap import unittest def code_gast_ast(source): """ Transform source_code into gast.Node and modify it, then back to ast.Node. """ source = textwrap.dedent(source) root = gast.parse(source) new_root = GastNodeTransformer(root).apply() ast_root = gast.gast_to_ast(new_root) return ast.dump(ast_root) def code_ast(source): """ Transform source_code into ast.Node, then dump it. """ source = textwrap.dedent(source) root = ast.parse(source) return ast.dump(root) class GastNodeTransformer(gast.NodeTransformer): def __init__(self, root): self.root = root def apply(self): return self.generic_visit(self.root) def visit_Name(self, node): """ Param in func is ast.Name in PY2, but ast.arg in PY3. It will be generally represented by gast.Name in gast. """ if isinstance(node.ctx, gast.Param) and node.id != "self": node.id += '_new' return node class TestPythonCompatibility(unittest.TestCase): def _check_compatibility(self, source, target): source_dump = code_gast_ast(source) target_dump = code_ast(target) self.assertEqual(source_dump, target_dump) def test_call(self): source = """ y = foo(arg) """ target = """ y = foo(arg_new) """ self._check_compatibility(source, target) # source_dump gast-> ast # Module(body=[Assign(targets=[Name(id='y', ctx=Store())], value=Call(func=Name(id='foo', ctx=Load()), args=[Starred(value=Name(id='arg_new', ctx=Load()), ctx=Load())], keywords=[]))], type_ignores=[]) # target_dump ast # Module(body=[Assign(targets=[Name(id='y', ctx=Store())], value=Call(func=Name(id='foo', ctx=Load()), args=[Starred(value=Name(id='arg_new', ctx=Load()), ctx=Load())], keywords=[]), type_comment=None)], type_ignores=[]) ``` After I modified the defination in `gast.py`, it works in python3.8 from ``` ('Assign', (('targets', 'value',), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (stmt,))), ``` into ``` ('Assign', (('targets', 'value','type_comment'), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (stmt,))), ```	365fa06e88f38c14cdff53d1ae437851a411e7a6	[ "tests/test_compat.py::CompatTestCase::test_FormattedValue", "tests/test_compat.py::CompatTestCase::test_JoinedStr" ]	[ "tests/test_compat.py::CompatTestCase::test_ArgAnnotation", "tests/test_compat.py::CompatTestCase::test_Call", "tests/test_compat.py::CompatTestCase::test_Ellipsis", "tests/test_compat.py::CompatTestCase::test_ExtSlice", "tests/test_compat.py::CompatTestCase::test_ExtSliceEllipsis", "tests/test_compat.py::CompatTestCase::test_ExtSlices", "tests/test_compat.py::CompatTestCase::test_Index", "tests/test_compat.py::CompatTestCase::test_KeywordOnlyArgument", "tests/test_compat.py::CompatTestCase::test_PosonlyArgs", "tests/test_compat.py::CompatTestCase::test_Raise", "tests/test_compat.py::CompatTestCase::test_TryExcept", "tests/test_compat.py::CompatTestCase::test_TryExceptNamed", "tests/test_compat.py::CompatTestCase::test_TryFinally", "tests/test_compat.py::CompatTestCase::test_TypeIgnore", "tests/test_compat.py::CompatTestCase::test_With", "tests/test_compat.py::CompatTestCase::test_keyword_argument", "tests/test_compat.py::CompatTestCase::test_star_argument" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-09-05 20:10:22+00:00	bsd-3-clause	5,480
serge-sans-paille__gast-59	diff --git a/README.rst b/README.rst index d26f2d7..0fead9d 100644 --- a/README.rst +++ b/README.rst @@ -186,6 +186,7 @@ ASDL -- BoolOp() can use left & right? expr = BoolOp(boolop op, expr* values) + \| NamedExpr(expr target, expr value) \| BinOp(expr left, operator op, expr right) \| UnaryOp(unaryop op, expr operand) \| Lambda(arguments args, expr body) diff --git a/gast/gast.py b/gast/gast.py index 11b248a..a745858 100644 --- a/gast/gast.py +++ b/gast/gast.py @@ -133,6 +133,9 @@ _nodes = ( ('BoolOp', (('op', 'values',), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (expr,))), + ('NamedExpr', (('target', 'value',), + ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), + (expr,))), ('BinOp', (('left', 'op', 'right',), ('lineno', 'col_offset', 'end_lineno', 'end_col_offset',), (expr,))),	serge-sans-paille/gast	2271bc2a5a6d675ab8e32d39baffc64a8d8c6b3d	diff --git a/tests/test_compat.py b/tests/test_compat.py index c04c433..bca7683 100644 --- a/tests/test_compat.py +++ b/tests/test_compat.py @@ -112,6 +112,16 @@ class CompatTestCase(unittest.TestCase): "], type_ignores=[])") self.assertEqual(gast.dump(tree), norm) + def test_NamedExpr(self): + code = '(x := 1) ' + tree = gast.parse(code) + compile(gast.gast_to_ast(tree), '<test>', 'exec') + norm = ("Module(body=[Expr(value=NamedExpr(target=Name(id='x'," + " ctx=Store(), annotation=None, type_comment=None), " + "value=Constant(value=1, kind=None)))], type_ignores=" + "[])") + self.assertEqual(gast.dump(tree), norm) + else: def test_Bytes(self):	gast doesn't seem to parse assignment expressions correctly It looks like `gast` doesn't correctly parse [assignment expressions](https://docs.python.org/3/whatsnew/3.8.html#assignment-expressions) (the `:=` operator): `ast`: ``` In [1]: import ast In [2]: expr = "(x := 1)" In [3]: ast.dump(ast.parse(expr)) Out[3]: "Module(body=[Expr(value=NamedExpr(target=Name(id='x', ctx=Store()), value=Constant(value=1, kind=None)))], type_ignores=[])" ``` `gast`: ``` In [4]: import gast In [5]: expr = "(x := 1)" In [6]: gast.dump(gast.parse(expr)) Out[6]: 'Module(body=[Expr(value=None)], type_ignores=[])' ```	2271bc2a5a6d675ab8e32d39baffc64a8d8c6b3d	[ "tests/test_compat.py::CompatTestCase::test_NamedExpr" ]	[ "tests/test_compat.py::CompatTestCase::test_ArgAnnotation", "tests/test_compat.py::CompatTestCase::test_Call", "tests/test_compat.py::CompatTestCase::test_Ellipsis", "tests/test_compat.py::CompatTestCase::test_ExtSlice", "tests/test_compat.py::CompatTestCase::test_ExtSliceEllipsis", "tests/test_compat.py::CompatTestCase::test_ExtSlices", "tests/test_compat.py::CompatTestCase::test_FormattedValue", "tests/test_compat.py::CompatTestCase::test_Index", "tests/test_compat.py::CompatTestCase::test_JoinedStr", "tests/test_compat.py::CompatTestCase::test_KeywordOnlyArgument", "tests/test_compat.py::CompatTestCase::test_PosonlyArgs", "tests/test_compat.py::CompatTestCase::test_Raise", "tests/test_compat.py::CompatTestCase::test_TryExcept", "tests/test_compat.py::CompatTestCase::test_TryExceptNamed", "tests/test_compat.py::CompatTestCase::test_TryFinally", "tests/test_compat.py::CompatTestCase::test_TypeIgnore", "tests/test_compat.py::CompatTestCase::test_With", "tests/test_compat.py::CompatTestCase::test_keyword_argument", "tests/test_compat.py::CompatTestCase::test_star_argument" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2021-07-23 08:19:35+00:00	bsd-3-clause	5,481
seung-lab__cloud-volume-362	diff --git a/cloudvolume/frontends/precomputed.py b/cloudvolume/frontends/precomputed.py index 807561d..6717c5e 100644 --- a/cloudvolume/frontends/precomputed.py +++ b/cloudvolume/frontends/precomputed.py @@ -522,6 +522,7 @@ class CloudVolumePrecomputed(object): slices = self.meta.bbox(self.mip).reify_slices(slices, bounded=self.bounded) steps = Vec(*[ slc.step for slc in slices ]) + slices = [ slice(slc.start, slc.stop) for slc in slices ] channel_slice = slices.pop() requested_bbox = Bbox.from_slices(slices) diff --git a/cloudvolume/lib.py b/cloudvolume/lib.py index e3d00fb..2fae1f0 100644 --- a/cloudvolume/lib.py +++ b/cloudvolume/lib.py @@ -403,9 +403,13 @@ class Bbox(object): slices, bounded=bounded, autocrop=autocrop ) + for slc in slices: + if slc.step not in (None, 1): + raise ValueError("Non-unitary steps are unsupported. Got: " + str(slc.step)) + return Bbox( [ slc.start for slc in slices ], - [ slc.stop for slc in slices ] + [ (slc.start if slc.stop < slc.start else slc.stop) for slc in slices ] ) @classmethod	seung-lab/cloud-volume	9395505a1d7baca9a1cd78b5150fec579120569b	diff --git a/test/test_lib.py b/test/test_lib.py index c175b5b..0813598 100644 --- a/test/test_lib.py +++ b/test/test_lib.py @@ -101,6 +101,21 @@ def test_bbox_division(): bbox /= 3.0 assert np.all(x == point333) +def test_bbox_slicing(): + bbx_rect = Bbox.from_slices(np.s_[1:10,1:10,1:10]) + bbx_plane = Bbox.from_slices(np.s_[1:10,10:1,1:10]) + + assert bbx_rect == Bbox((1,1,1), (10,10,10)) + assert bbx_plane == Bbox((1,10,1), (10, 10, 10)) + + try: + bbx_plane = Bbox.from_slices(np.s_[1:10,10:1:-1,1:10]) + assert False + except ValueError: + pass + + bbx_plane = Bbox.from_slices(np.s_[1:10,10:1:1,1:10]) + assert bbx_plane == Bbox((1,10,1), (10, 10, 10)) def test_bbox_intersection():	Writing to volume (by slicing notation) is not properly checking slice.start < slice.stop cv[(slice(0,1),slice(0,1),slice(779,344))] = 0 appears to clear out 344:779 rather than the expected behavior of not writing anything because the effective range is empty.	9395505a1d7baca9a1cd78b5150fec579120569b	[ "test/test_lib.py::test_bbox_slicing" ]	[ "test/test_lib.py::test_divisors", "test/test_lib.py::test_find_closest_divisor", "test/test_lib.py::test_bbox_subvoxel", "test/test_lib.py::test_vec_division", "test/test_lib.py::test_bbox_division", "test/test_lib.py::test_bbox_intersect", "test/test_lib.py::test_bbox_intersection", "test/test_lib.py::test_bbox_hashing", "test/test_lib.py::test_bbox_serialize", "test/test_lib.py::test_bbox_volume", "test/test_lib.py::test_jsonify", "test/test_lib.py::test_bbox_from_filename" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2020-07-14 18:41:12+00:00	bsd-3-clause	5,482
seznam__flexp-11	diff --git a/flexp/flexp/core.py b/flexp/flexp/core.py index 0c4d474..6a14022 100644 --- a/flexp/flexp/core.py +++ b/flexp/flexp/core.py @@ -3,6 +3,7 @@ from __future__ import print_function from __future__ import absolute_import from __future__ import division +import shutil from datetime import datetime from shutil import copyfile, copystat import io @@ -222,8 +223,38 @@ class ExperimentHandler(object): self._metadata[key] = value +def clean_experiment_dir(override_dir): + """ + Cleans experiment folder. + :param bool override_dir: If true, clean the folder, if false, check it's empty or doesn't exists + :return: + """ + experiment_dir = get_file_path("") + # Check experiment_dir is empty or doesn't exists + if not override_dir: + if not os.path.exists(experiment_dir) or not os.listdir(experiment_dir): + return + else: + raise FileExistsError( + "Directory '{}' already exists and is not empty! " + "Use override_dir=True to clean the directory." + .format(name()) + ) + else: + # Dir doesn't exists, so everything's fine. + if not os.path.exists(experiment_dir): + return + # Remove all files in the directory + for the_file in os.listdir(experiment_dir): + file_path = os.path.join(experiment_dir, the_file) + if os.path.isfile(file_path): + os.unlink(file_path) + elif os.path.isdir(file_path): + shutil.rmtree(file_path) + + def setup(root_dir, exp_name=None, with_date=False, backup=True, default_rights=RWXRWS, loglevel=logging.DEBUG, - log_filename='log.txt', disable_stderr=False): + log_filename='log.txt', disable_stderr=False, override_dir=False): """Set up Experiment handler. :param root_dir: Path to experiments root directory. New directories will be created in the folder. @@ -234,11 +265,17 @@ def setup(root_dir, exp_name=None, with_date=False, backup=True, default_rights= :param loglevel: Loglevel, DEBUG by default, can be overriden by FLEXP_LOGLEVEL environment variable. :param log_filename: Filename of log in experiment dir. 'log.txt' by default. If None, logging to file is disabled. :param disable_stderr: Enable/disable logging on stderr. False by default. + :param bool override_dir: If True, remove all contents of the directory. + If False and there is any file in the directory, raise an exception. """ if "experiment" in _eh: raise Exception("flexp.setup() called twice") _eh["experiment"] = ExperimentHandler(default_rights=default_rights) _eh["experiment"].setup(root_dir, exp_name, with_date=with_date) + + # Clean the directory or check it's empty + clean_experiment_dir(override_dir) + if backup: _eh["experiment"].backup_files([sys.argv[0]]) atexit.register(_eh["experiment"]._write_metadata) @@ -327,4 +364,5 @@ def set_metadata(key, value): def disable(): """Surpress all output and returns /dev/null as path to all files.""" _eh["experiment"].disabled = True + _setup_logging(logging.FATAL, None, True) diff --git a/flexp/flexp/logging.py b/flexp/flexp/logging.py index aa57d50..b15c269 100644 --- a/flexp/flexp/logging.py +++ b/flexp/flexp/logging.py @@ -3,7 +3,6 @@ import warnings import os import six - log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') @@ -39,6 +38,7 @@ def get_loglevel_from_env(default_level): def _setup_logging(level=logging.DEBUG, filename='log.txt', disable_stderr=False): + _close_file_handlers() level = loglevel_from_string(level) root_logger = logging.getLogger() root_logger.setLevel(level) @@ -52,3 +52,9 @@ def _setup_logging(level=logging.DEBUG, filename='log.txt', disable_stderr=False root_logger.addHandler(stream_handler) warnings.simplefilter("once") + + +def _close_file_handlers(): + root_logger = logging.getLogger() + for file_handler in root_logger.handlers: + file_handler.close()	seznam/flexp	220a95804f0d682aab153ad9d500291c7d5ff4cf	diff --git a/tests/test_flexp.py b/tests/test_flexp.py index 574e942..e814871 100644 --- a/tests/test_flexp.py +++ b/tests/test_flexp.py @@ -30,6 +30,7 @@ def test_working(): if not hasattr(atexit, "unregister") and path.exists( path.join(expdir, "flexp_info.txt")): os.unlink(path.join(expdir, "flexp_info.txt")) + flexp.disable() shutil.rmtree(expdir) diff --git a/tests/test_flexp_override.py b/tests/test_flexp_override.py new file mode 100644 index 0000000..90623d0 --- /dev/null +++ b/tests/test_flexp_override.py @@ -0,0 +1,41 @@ +# coding: utf-8 + +import atexit +import io +import os +from os import path +import shutil + +import pytest + +from flexp import flexp + + +def test_override(): + expdir = path.join("tests/data/", "exp01") + + # Remove the experiment dir if it exists + if os.path.exists(expdir): + shutil.rmtree(expdir) + + # We have to reset the _eh to make flexp stop complaining about calling setup twice. + flexp.core._eh = {} + flexp.setup("tests/data/", "exp01", False, override_dir=False) + + assert path.isdir(expdir), "flexp didn't create experiment dir with override_dir=False" + + # Test that it fails to create the directory, there should be logging file already. + with pytest.raises(FileExistsError): + flexp.core._eh = {} + flexp.setup("tests/data/", "exp01", False, override_dir=False) + + # This should be ok + flexp.core._eh = {} + flexp.setup("tests/data/", "exp01", False, override_dir=True) + + # Disable logging to be able to delete the experiment directory. + flexp.disable() + + # Remove the experiment dir + if os.path.exists(expdir): + shutil.rmtree(expdir)	Flexp.setup doesn't clean the experiment directory. When creating an experiment, I usually did clean_experiment_folder to get rid of previous results. Now if I do this: ```python flexp.setup(EXPS_DIR, DESC, with_date=not SHORT_RUN, default_rights=RWXRWXRWX) clean_experiment_folder(flexp.get_file_path("")) ``` it will remove the log.txt as well, because it is now created by flexp.setup and not flog. Before calling `flexp.setup`, I don't know what is the experiment dir so I can't clean it. I suggest adding a switch `clean_experiment_folder`, defaults to True, which removes everything in the experiment folder and only after that creates the log file. What do you think?	220a95804f0d682aab153ad9d500291c7d5ff4cf	[ "tests/test_flexp_override.py::test_override" ]	[ "tests/test_flexp.py::test_working", "tests/test_flexp.py::test_static" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2018-10-04 12:59:11+00:00	bsd-3-clause	5,483
sgaynetdinov__py-vkontakte-28	diff --git a/vk/fetch.py b/vk/fetch.py index b0eb38e..761408c 100644 --- a/vk/fetch.py +++ b/vk/fetch.py @@ -65,7 +65,7 @@ class Session: items = res['items'] if not items: - raise StopIteration + return None for i in items: yield constructor_from_json(self, i)	sgaynetdinov/py-vkontakte	39a038277d2b439bf1a967f903e6c140fb8d4e49	diff --git a/tests/test_fetch.py b/tests/test_fetch.py index 711b724..ae22ee4 100644 --- a/tests/test_fetch.py +++ b/tests/test_fetch.py @@ -1,7 +1,10 @@ import io +import pytest + import vk from vk.fetch import Session +from vk.users import User def test_url_open(mocker): @@ -29,3 +32,12 @@ def test_upload_photo(): assert b'Content-Type: application/octet-stream' in data assert b'Python developer and blogger.' in data assert boundary.encode() in data + +def test_fetch_items_stop_iteration(mocker): + fetch = mocker.patch('vk.fetch.Session.fetch') + fetch.return_value = {'items': []} + + got = Session().fetch_items('test', User.from_json, 10) + + with pytest.raises(StopIteration): + next(got)	Raise error StopIteration ``` list(group.get_members()) ``` python3.7	39a038277d2b439bf1a967f903e6c140fb8d4e49	[ "tests/test_fetch.py::test_fetch_items_stop_iteration" ]	[ "tests/test_fetch.py::test_url_open", "tests/test_fetch.py::test_upload_photo" ]	{ "failed_lite_validators": [ "has_short_problem_statement" ], "has_test_patch": true, "is_lite": false }	2020-01-05 20:03:08+00:00	mit	5,484
shaarli__python-shaarli-client-54	diff --git a/setup.py b/setup.py index 5044848..404b2e5 100644 --- a/setup.py +++ b/setup.py @@ -40,9 +40,8 @@ setup( ], }, install_requires=[ - 'requests >= 2.10', - 'requests-jwt >= 0.4, < 0.5', - 'pyjwt == 1.7.1' + 'requests >= 2.25', + 'pyjwt == 2.0.1' ], classifiers=[ 'Development Status :: 3 - Alpha', diff --git a/shaarli_client/client/v1.py b/shaarli_client/client/v1.py index 59b0b93..2113abe 100644 --- a/shaarli_client/client/v1.py +++ b/shaarli_client/client/v1.py @@ -3,8 +3,8 @@ import calendar import time from argparse import Action, ArgumentTypeError +import jwt import requests -from requests_jwt import JWTAuth def check_positive_integer(value): @@ -248,8 +248,12 @@ class ShaarliV1Client: def _request(self, method, endpoint, params, verify_certs=True): """Send an HTTP request to this instance""" - auth = JWTAuth(self.secret, alg='HS512', header_format='Bearer %s') - auth.add_field('iat', lambda req: calendar.timegm(time.gmtime())) + encoded_token = jwt.encode( + {'iat': calendar.timegm(time.gmtime())}, + self.secret, + algorithm='HS512', + ) + headers = {'Authorization': 'Bearer %s' % encoded_token} endpoint_uri = '%s/api/v%d/%s' % (self.uri, self.version, endpoint) @@ -257,11 +261,16 @@ class ShaarliV1Client: return requests.request( method, endpoint_uri, - auth=auth, + headers=headers, params=params, verify=verify_certs ) - return requests.request(method, endpoint_uri, auth=auth, json=params) + return requests.request( + method, + endpoint_uri, + headers=headers, + json=params, + ) def request(self, args): """Send a parameterized request to this instance"""	shaarli/python-shaarli-client	1748cdfef3c356c7775f1c2dd3fdb9a37ef40d5b	diff --git a/tests/client/test_v1.py b/tests/client/test_v1.py index a08f239..9abee4f 100644 --- a/tests/client/test_v1.py +++ b/tests/client/test_v1.py @@ -119,7 +119,7 @@ def test_get_info_uri(request): request.assert_called_once_with( 'GET', '%s/api/v1/info' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, verify=True, params={} ) @@ -145,7 +145,7 @@ def test_get_links_uri(request): request.assert_called_once_with( 'GET', '%s/api/v1/links' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, verify=True, params={} ) @@ -187,7 +187,7 @@ def test_post_links_uri(request): request.assert_called_once_with( 'POST', '%s/api/v1/links' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, json={} ) @@ -229,7 +229,7 @@ def test_put_links_uri(request): request.assert_called_once_with( 'PUT', '%s/api/v1/links/12' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, json={} ) @@ -288,7 +288,7 @@ def test_get_tags_uri(request): request.assert_called_once_with( 'GET', '%s/api/v1/tags' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, verify=True, params={} ) @@ -301,7 +301,7 @@ def test_put_tags_uri(request): request.assert_called_once_with( 'PUT', '%s/api/v1/tags/some-tag' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, json={} ) @@ -340,7 +340,7 @@ def test_delete_tags_uri(request): request.assert_called_once_with( 'DELETE', '%s/api/v1/tags/some-tag' % SHAARLI_URL, - auth=mock.ANY, + headers=mock.ANY, json={} )	Traceback error ( AttributeError: 'str' object has no attribute 'decode') Python 3.7.3 When I enter `shaarli get-info` (or really any valid command) I get this: Traceback (most recent call last): File "/home/pi/.virtualenvs/shaarli/bin/shaarli", line 10, in <module> sys.exit(main()) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/shaarli_client/main.py", line 58, in main response = ShaarliV1Client(url, secret).request(args) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/shaarli_client/client/v1.py", line 267, in request return self._request(* self._retrieve_http_params(args)) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/shaarli_client/client/v1.py", line 261, in _request params=params File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests/api.py", line 61, in request return session.request(method=method, url=url, **kwargs) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests/sessions.py", line 528, in request prep = self.prepare_request(req) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests/sessions.py", line 466, in prepare_request hooks=merge_hooks(request.hooks, self.hooks), File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests/models.py", line 320, in prepare self.prepare_auth(auth, url) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests/models.py", line 551, in prepare_auth r = auth(self) File "/home/pi/.virtualenvs/shaarli/lib/python3.7/site-packages/requests_jwt/__init__.py", line 165, in __call__ request.headers['Authorization'] = self._header_format % token.decode('ascii') AttributeError: 'str' object has no attribute 'decode' I do have the correct secret and URL of my instance.	1748cdfef3c356c7775f1c2dd3fdb9a37ef40d5b	[ "tests/client/test_v1.py::test_get_info_uri", "tests/client/test_v1.py::test_get_links_uri", "tests/client/test_v1.py::test_post_links_uri", "tests/client/test_v1.py::test_put_links_uri", "tests/client/test_v1.py::test_get_tags_uri", "tests/client/test_v1.py::test_put_tags_uri", "tests/client/test_v1.py::test_delete_tags_uri" ]	[ "tests/client/test_v1.py::test_check_positive_integer", "tests/client/test_v1.py::test_check_positive_integer_negative", "tests/client/test_v1.py::test_check_positive_integer_alpha", "tests/client/test_v1.py::test_invalid_endpoint_parameters_exception", "tests/client/test_v1.py::test_constructor", "tests/client/test_v1.py::test_constructor_no_uri", "tests/client/test_v1.py::test_constructor_no_secret", "tests/client/test_v1.py::test_constructor_strip_uri[http://domain.tld/shaarli]", "tests/client/test_v1.py::test_constructor_strip_uri[http://domain.tld/shaarli/]", "tests/client/test_v1.py::test_constructor_strip_uri[http://domain.tld/shaarli///]", "tests/client/test_v1.py::test_check_endpoint_params_none", "tests/client/test_v1.py::test_check_endpoint_params_empty", "tests/client/test_v1.py::test_check_endpoint_params_ok", "tests/client/test_v1.py::test_check_endpoint_params_nok", "tests/client/test_v1.py::test_check_endpoint_params_nok_mixed", "tests/client/test_v1.py::test_get_info_invalid_uri[http:/shaarli-InvalidURL-No", "tests/client/test_v1.py::test_get_info_invalid_uri[htp://shaarli-InvalidSchema-No", "tests/client/test_v1.py::test_retrieve_http_params_get_info", "tests/client/test_v1.py::test_retrieve_http_params_get_links", "tests/client/test_v1.py::test_retrieve_http_params_get_links_searchterm", "tests/client/test_v1.py::test_retrieve_http_params_post_link", "tests/client/test_v1.py::test_retrieve_http_params_post_empty_link", "tests/client/test_v1.py::test_retrieve_http_params_put_link", "tests/client/test_v1.py::test_retrieve_http_params_put_empty_link", "tests/client/test_v1.py::test_retrieve_http_params_get_tags", "tests/client/test_v1.py::test_retrieve_http_params_put_tag", "tests/client/test_v1.py::test_retrieve_http_params_put_empty_tag", "tests/client/test_v1.py::test_retrieve_http_params_delete_tag", "tests/client/test_v1.py::test_retrieve_http_params_delete_empty_tag" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-04-07 20:24:24+00:00	mit	5,485
shadowmoose__pyderman-20	diff --git a/pyderman/drivers/chrome.py b/pyderman/drivers/chrome.py index 5b54fd6..7859b54 100644 --- a/pyderman/drivers/chrome.py +++ b/pyderman/drivers/chrome.py @@ -11,10 +11,16 @@ _base_download = "https://chromedriver.storage.googleapis.com/%s/chromedriver_%s def get_url( version: str = "latest", _os: str \| None = None, _os_bit: str \| None = None ) -> tuple[str, str, str]: + match = re.match(r"^(\d)[.]?(\d)[.]?(\d)[.]?(\d)$", version) if version == "latest": resolved_version = downloader.raw(_base_version) - elif re.match(r"\d+(\.\d+\.\d+)?", version): - resolved_version = downloader.raw("{}_{}".format(_base_version, version)) + elif match: + major, minor, patch, build = match.groups() + if patch: + patch_version = "{}.{}.{}".format(major, minor, patch) + else: + patch_version = major + resolved_version = downloader.raw("{}_{}".format(_base_version, patch_version)) else: resolved_version = version if not resolved_version:	shadowmoose/pyderman	d377c81e5684fc637388254f0f78e52748b0df0c	diff --git a/pyderman/test.py b/pyderman/test.py index 7ea9d03..127d25a 100644 --- a/pyderman/test.py +++ b/pyderman/test.py @@ -2,10 +2,19 @@ from __future__ import annotations import os import platform +import re import subprocess import unittest from types import ModuleType +try: + # Python 3 + from urllib.request import urlopen +except ImportError: + # Python 2 + # noinspection PyUnresolvedReferences + from urllib2 import urlopen # type: ignore[import,no-redef] + from pyderman import chrome, edge, firefox, install, opera, phantomjs @@ -59,5 +68,54 @@ class TestDriverInstalls(unittest.TestCase): process_driver(edge, self) +class TestChrome(unittest.TestCase): + def setUp(self) -> None: + version_re = re.compile(r"^(\d+)\.(\d+)\.(\d+)\.(\d+)$") + url = "https://chromedriver.storage.googleapis.com/LATEST_RELEASE" + resp = urlopen(url, timeout=15) + html = resp.read().decode("utf-8", errors="ignore") + version_string = str(html) + self.latest = version_string + + match = version_re.match(version_string) + if not match: + raise ValueError("Invalid version string: %r" % version_string) + + major, minor, patch, build = match.groups() + self.major = major + self.minor = minor + self.patch = patch + self.build = build + return + + def chrome_version(self, version: str) -> None: + drvr, url, vers = chrome.get_url(version, _os="mac", _os_bit="64") + self.assertEqual(vers, self.latest) + self.assertEqual( + url, + f"https://chromedriver.storage.googleapis.com/{self.latest}/chromedriver_mac64.zip", + ) + + def test_get_latest(self) -> None: + self.chrome_version("latest") + + def test_get_major(self) -> None: + self.chrome_version(f"{self.major}") + + def test_get_patch(self) -> None: + self.chrome_version(f"{self.major}.{self.minor}.{self.patch}") + + def test_get_build(self) -> None: + self.chrome_version(f"{self.latest}") + + def test_get_nonsense(self) -> None: + with self.assertRaises(Exception) as exc: + self.chrome_version("25.25.25.25") + self.assertEqual( + str(exc.exception), "Unable to locate ChromeDriver version: 25.25.25.25!" + ) + return + + if __name__ == "__main__": unittest.main()	pyderman.install() returns error when specifying full version of chromedriver. pyderman.install() returns error when specifying full version of chromedriver. I'm looking at the latest commit (not officially released yet). https://github.com/shadowmoose/pyderman/commit/d377c81e5684fc637388254f0f78e52748b0df0c ```python pyderman.install(browser=pyderman.chrome version="101.0.4951.41") ``` Results in: `Exception: Unable to locate ChromeDriver version: 101.0.4951.41!` It appears to be related to the changes in https://github.com/shadowmoose/pyderman/pull/13/files The code assumes that making a request to the following URL will return a version https://chromedriver.storage.googleapis.com/LATEST_RELEASE_101.0.4951.41 Looking through the xml on https://chromedriver.storage.googleapis.com/ there does not appear to be the option for that version. In fact I'm not seeing any options for `LATEST_RELEASE_X.X.X.X`. The options appear to be limited to `LATEST_RELEASE_X.X.X` Looking up versions seems to work with the Major and patch versions. These are valid lookups: - https://chromedriver.storage.googleapis.com/LATEST_RELEASE_101 - https://chromedriver.storage.googleapis.com/LATEST_RELEASE_101.0.4951	d377c81e5684fc637388254f0f78e52748b0df0c	[ "pyderman/test.py::TestChrome::test_get_build" ]	[ "pyderman/test.py::TestDriverInstalls::test_chrome", "pyderman/test.py::TestDriverInstalls::test_details", "pyderman/test.py::TestDriverInstalls::test_edge", "pyderman/test.py::TestDriverInstalls::test_phantomjs", "pyderman/test.py::TestChrome::test_get_latest", "pyderman/test.py::TestChrome::test_get_major", "pyderman/test.py::TestChrome::test_get_nonsense", "pyderman/test.py::TestChrome::test_get_patch" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2022-05-05 04:36:19+00:00	mit	5,486
shinichi-takii__ddlparse-43	diff --git a/CHANGELOG.md b/CHANGELOG.md index adef029..aca4078 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,13 @@ # Changelog +All notable changes to the "ddlparse" module will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + + +## [1.3.1] - 2019-12-05 +### Fixed +- Fixed parsing failure for columns include dot at default values. ## [1.3.0] - 2019-06-15 ### Added @@ -8,17 +17,22 @@ - Add supports column comments in BigQuery DDL. ## [1.2.3] - 2019-02-17 +### Fixed - Fix parse error for MySQL DDL with 'FOREIGN KEY'. - Fix not completely parsed with block comments. ## [1.2.2] - 2019-02-02 -- Fix FutureWarning of Python 3.7. +### Added - Add supports PostgreSQL data type. - `UUID` + +### Fixed +- Fix FutureWarning of Python 3.7. - Fix parse `DEFAULT` value. - Add parse regex of `DEFAULT` value. ## [1.2.1] - 2019-01-27 +### Added - Add supports for Python 3.7. - Pass Python 3.7 test. - Add supports PostgreSQL data type. @@ -29,6 +43,7 @@ - Add decimal point to `DEFAULT` parse character. ## [1.2.0] - 2019-01-02 +### Added - Add `DdlParseTable.to_bigquery_ddl` function. - BigQuery DDL (CREATE TABLE) statement generate function. - Add `DdlParseColumn.bigquery_legacy_data_type` property. @@ -38,38 +53,50 @@ - Get BigQuery Standard SQL data property. ## [1.1.3] - 2018-08-02 +### Added - Add support inline comment. - Add support constraint name with quotes. - Add support Oracle Length Semantics for Character Datatypes. ## [1.1.2] - 2018-03-25 +### Added - Add support Oracle data type. - `CLOB`, `NCLOB` - `NUMBER` with no length & scale specification + +### Fixed - Miner fix. ## [1.1.1] - 2018-03-25 +### Fixed - Fix Postgres/Redshift parse of "::" syntax in field attribute. ## [1.1.0] - 2018-01-14 +### Added - Add `source_database` option. - Add `to_bigquery_fields` method to Columns dicttionary(`DdlParseColumnDict` class). + +### Fixed - Fix BigQuery convert of Oracle data type. - Oracle 'DATE' -> BigQuery 'DATETIME' - Oracle 'NUMBER' -> BigQuery 'INTEGER' or 'FLOAT' ## [1.0.2] - 2018-01-09 +### Fixed - Miner enhancement. - `ddlparse.py` : Exclude unused module. - `example.py` : Modified comment. - `README.md` : Miner fix. ## [1.0.1] - 2018-01-07 +### Fixed - Miner enhancement. ## [1.0.0] +### Added - Initial released. +[1.3.1]: https://github.com/shinichi-takii/ddlparse/compare/v1.3.0...v1.3.1 [1.3.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.2.3...v1.3.0 [1.2.3]: https://github.com/shinichi-takii/ddlparse/compare/v1.2.2...v1.2.3 [1.2.2]: https://github.com/shinichi-takii/ddlparse/compare/v1.2.1...v1.2.2 diff --git a/ddlparse/__init__.py b/ddlparse/__init__.py index d19584b..e7f3440 100644 --- a/ddlparse/__init__.py +++ b/ddlparse/__init__.py @@ -8,7 +8,7 @@ from .ddlparse import * __copyright__ = 'Copyright (C) 2018-2019 Shinichi Takii' -__version__ = '1.3.0' +__version__ = '1.3.1' __license__ = 'BSD-3-Clause' __author__ = 'Shinichi Takii' __author_email__ = '[email protected]' diff --git a/ddlparse/ddlparse.py b/ddlparse/ddlparse.py index a4ac93c..44b133c 100644 --- a/ddlparse/ddlparse.py +++ b/ddlparse/ddlparse.py @@ -524,7 +524,7 @@ class DdlParse(DdlParseBase): + Optional(_LPAR + Regex(r"\d+\s,\s\d") + Optional(Suppress(_CHAR_SEMANTICS \| _BYTE_SEMANTICS)) + _RPAR) )("type") + Optional(Word(r"\[\]"))("array_brackets") - + Optional(Regex(r"(?!--)(\b(COMMENT\|DEFAULT)\b\s+[^,]+\|([A-Za-z0-9_'\": -]\|[^\x01-\x7E]))", re.IGNORECASE))("constraint") + + Optional(Regex(r"(?!--)(\b(COMMENT\|DEFAULT)\b\s+[^,]+\|([A-Za-z0-9_\.'\": -]\|[^\x01-\x7E]))", re.IGNORECASE))("constraint") )("column") \| _COMMENT diff --git a/setup.cfg b/setup.cfg index a5988c6..dddb9d5 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,2 +1,2 @@ [tool:pytest] -addopts = -vs --maxfail=2 --showlocal --durations=0 --cov-report term-missing --cov ./ddlparse +addopts = -vs --maxfail=2 --showlocals --durations=0 --cov-report term-missing --cov ./ddlparse	shinichi-takii/ddlparse	3f42a669074d1e7f8e436b19e56ee11692960ec5	diff --git a/test-requirements.txt b/test-requirements.txt index f2afa18..bae867f 100644 --- a/test-requirements.txt +++ b/test-requirements.txt @@ -1,5 +1,6 @@ pytest>=3.6 pytest-cov +tox coveralls codecov codeclimate-test-reporter diff --git a/test/test_ddlparse.py b/test/test_ddlparse.py index 944ac17..9bf5a76 100644 --- a/test/test_ddlparse.py +++ b/test/test_ddlparse.py @@ -152,6 +152,8 @@ TEST_DATA = { Col_03 integer, Col_04 double, Col_05 datetime, + Col_06 decimal(2,1) not null default '0.0', + Col_07 integer, CONSTRAINT const_01 PRIMARY KEY (Col_01, Col_02), CONSTRAINT \"const_02\" UNIQUE (Col_03, Col_04), CONSTRAINT \"const_03\" FOREIGN KEY (Col_04, \"Col_05\") REFERENCES ref_table_01 (\"Col_04\", Col_05) @@ -165,6 +167,8 @@ TEST_DATA = { {"name" : "Col_03", "type" : "INTEGER", "length" : None, "scale" : None, "array_dimensional" : 0, "not_null" : False, "pk" : False, "unique" : True, "constraint" : "UNIQUE", "description" : None}, {"name" : "Col_04", "type" : "DOUBLE", "length" : None, "scale" : None, "array_dimensional" : 0, "not_null" : False, "pk" : False, "unique" : True, "constraint" : "UNIQUE", "description" : None}, {"name" : "Col_05", "type" : "DATETIME", "length" : None, "scale" : None, "array_dimensional" : 0, "not_null" : False, "pk" : False, "unique" : False, "constraint" : "", "description" : None}, + {"name" : "Col_06", "type" : "DECIMAL", "length" : 2, "scale" : 1, "array_dimensional" : 0, "not_null" : True, "pk" : False, "unique" : False, "constraint" : "NOT NULL", "description" : None}, + {"name" : "Col_07", "type" : "INTEGER", "length" : None, "scale" : None, "array_dimensional" : 0, "not_null" : False, "pk" : False, "unique" : False, "constraint" : "", "description" : None}, ], "bq_field" : [ '{"name": "Col_01", "type": "STRING", "mode": "REQUIRED"}', @@ -172,6 +176,8 @@ TEST_DATA = { '{"name": "Col_03", "type": "INTEGER", "mode": "NULLABLE"}', '{"name": "Col_04", "type": "FLOAT", "mode": "NULLABLE"}', '{"name": "Col_05", "type": "DATETIME", "mode": "NULLABLE"}', + '{"name": "Col_06", "type": "FLOAT", "mode": "REQUIRED"}', + '{"name": "Col_07", "type": "INTEGER", "mode": "NULLABLE"}', ], "bq_standard_data_type" : [ "STRING", @@ -179,6 +185,8 @@ TEST_DATA = { "INT64", "FLOAT64", "DATETIME", + "FLOAT64", + "INT64", ], },	Parsing failure for columns include dot at default values # Requirements * Parsing failure for columns include dot at default values. ## Example code ```python # -- coding: utf-8 -- from ddlparse import DdlParse sample_ddl = """ CREATE TABLE Sample_Table ( Col_01 varchar(100), Col_02 char(200), Col_03 integer, Col_04 double, Col_05 datetime, Col_06 decimal(2,1) not null default '0.0', Col_07 integer, CONSTRAINT const_01 PRIMARY KEY (Col_01, Col_02), CONSTRAINT \"const_02\" UNIQUE (Col_03, Col_04), CONSTRAINT \"const_03\" FOREIGN KEY (Col_04, \"Col_05\") REFERENCES ref_table_01 (\"Col_04\", Col_05) ); """ parser = DdlParse(sample_ddl) table = parser.parse() print("* BigQuery Fields * : normal") print(table.to_bigquery_fields()) ``` ## Output Parsing stops at Col_06... ```json [{"name": "Col_01", "type": "STRING", "mode": "NULLABLE"},{"name": "Col_02", "type": "STRING", "mode": "NULLABLE"},{"name": "Col_03", "type": "INTEGER", "mode": "NULLABLE"},{"name": "Col_04", "type": "FLOAT", "mode": "NULLABLE"},{"name": "Col_05", "type": "DATETIME", "mode": "NULLABLE"},{"name": "Col_06", "type": "FLOAT", "mode": "REQUIRED"}] ```	3f42a669074d1e7f8e436b19e56ee11692960ec5	[ "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.property]", "test/test_ddlparse.py::test_parse[constraint_mysql-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[constraint_postgres_oracle_redshift-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[default_postgres_redshift-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_oracle-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_postgres-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_backquote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_doublequote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[temp_table-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[table_with_schema-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[column_comment-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_bq_ddl[exist_schema_name]", "test/test_ddlparse.py::test_bq_ddl[no_schema_name]", "test/test_ddlparse.py::test_bq_ddl[datatype_postgres]", "test/test_ddlparse.py::test_bq_ddl[column_comment]", "test/test_ddlparse.py::test_exception_ddl", "test/test_ddlparse.py::test_exception_bq_data_type", "test/test_ddlparse.py::test_set_comment" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2019-12-04 12:19:26+00:00	bsd-3-clause	5,487
shinichi-takii__ddlparse-52	diff --git a/CHANGELOG.md b/CHANGELOG.md index 405a366..55f0b1d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.6.1] - 2020-08-08 +### Fixed +- Fix parse Redshift `ENCODE` attribute. + + ## [1.6.0] - 2020-07-18 ### Added - Add property. @@ -161,6 +166,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Initial released. +[1.6.1]: https://github.com/shinichi-takii/ddlparse/compare/v1.6.0...v1.6.1 [1.6.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.5.0...v1.6.0 [1.5.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.4.0...v1.5.0 [1.4.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.3.1...v1.4.0 diff --git a/ddlparse/__init__.py b/ddlparse/__init__.py index 4a21d65..1e327c9 100644 --- a/ddlparse/__init__.py +++ b/ddlparse/__init__.py @@ -8,7 +8,7 @@ from .ddlparse import * __copyright__ = 'Copyright (C) 2018-2020 Shinichi Takii' -__version__ = '1.6.0' +__version__ = '1.6.1' __license__ = 'BSD-3-Clause' __author__ = 'Shinichi Takii' __author_email__ = '[email protected]' diff --git a/ddlparse/ddlparse.py b/ddlparse/ddlparse.py index c960ef8..0dc81e6 100644 --- a/ddlparse/ddlparse.py +++ b/ddlparse/ddlparse.py @@ -505,13 +505,11 @@ class DdlParse(DdlParseBase): ( ( \s\b(?:NOT\s+)NULL?\b - )? - ( + )?( \s\bAUTO_INCREMENT\b )?( \s\b(UNIQUE\|PRIMARY)(?:\s+KEY)?\b - )? - ( + )?( \s\bDEFAULT\b\s+( ([A-Za-z0-9_\.\'\" -]\|[^\x01-\x7E])\:\:[A-Za-z0-9\[\]]+ \| @@ -521,8 +519,7 @@ class DdlParse(DdlParseBase): \| [^,]+ ) - )? - ( + )?( \s\bCOMMENT\b\s+( \'(\\\'\|[^\']\|,)+\' \| @@ -530,6 +527,12 @@ class DdlParse(DdlParseBase): \| [^,]+ ) + )?( + \s\bENCODE\s+\w+\b + )?( + \s\b(?:NOT\s+)NULL?\b + )?( + \s*\b(UNIQUE\|PRIMARY)(?:\s+KEY)?\b )? ) """	shinichi-takii/ddlparse	4e7e09a906e2f26d3730c8404908b9eedf1a7084	diff --git a/test/test_ddlparse.py b/test/test_ddlparse.py index 76d1515..083ec18 100644 --- a/test/test_ddlparse.py +++ b/test/test_ddlparse.py @@ -321,8 +321,8 @@ TEST_DATA = { "ddl": """ CREATE TABLE Sample_Table ( - Col_01 char(1) DEFAULT '0'::bpchar, - Col_02 char(1) DEFAULT '0'::bpchar, + Col_01 char(1) DEFAULT '0'::bpchar PRIMARY KEY, + Col_02 char(1) DEFAULT '0'::bpchar ENCODE lzo NOT NULL, Col_03 integer DEFAULT 0, Col_04 numeric(10) DEFAULT 0, Col_05 numeric(20,3) DEFAULT 0.0, @@ -333,8 +333,8 @@ TEST_DATA = { "database": None, "table": {"schema": None, "name": "Sample_Table", "temp": False}, "columns": [ - {"name": "Col_01", "type": "CHAR", "length": 1, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, - {"name": "Col_02", "type": "CHAR", "length": 1, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, + {"name": "Col_01", "type": "CHAR", "length": 1, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": True, "pk": True, "unique": False, "constraint": "PRIMARY KEY", "description": None}, + {"name": "Col_02", "type": "CHAR", "length": 1, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": True, "pk": False, "unique": False, "constraint": "NOT NULL", "description": None}, {"name": "Col_03", "type": "INTEGER", "length": None, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, {"name": "Col_04", "type": "NUMERIC", "length": 10, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, {"name": "Col_05", "type": "NUMERIC", "length": 20, "scale": 3, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, @@ -342,8 +342,8 @@ TEST_DATA = { {"name": "Col_07", "type": "CHARACTER VARYING", "length": None, "scale": None, "array_dimensional": 1, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "constraint": "", "description": None}, ], "bq_field": [ - '{"name": "Col_01", "type": "STRING", "mode": "NULLABLE"}', - '{"name": "Col_02", "type": "STRING", "mode": "NULLABLE"}', + '{"name": "Col_01", "type": "STRING", "mode": "REQUIRED"}', + '{"name": "Col_02", "type": "STRING", "mode": "REQUIRED"}', '{"name": "Col_03", "type": "INTEGER", "mode": "NULLABLE"}', '{"name": "Col_04", "type": "INTEGER", "mode": "NULLABLE"}', '{"name": "Col_05", "type": "NUMERIC", "mode": "NULLABLE"}',	Postgres/Redshift : Not parse DDL of "::" syntax in field attribute ## Example ### DDL (Redshift) ```sql CREATE TABLE IF NOT EXISTS "sample_schema"."sample_table" ( "div_cd" VARCHAR(2) NOT NULL ,"div_name" VARCHAR(30) NOT NULL ,"org_cd" VARCHAR(8) NOT NULL ,"org_name" VARCHAR(60) NOT NULL ,"team_cd" VARCHAR(2) NOT NULL ,"team_name" VARCHAR(120) NOT NULL ,"personal_cd" VARCHAR(7) NOT NULL ,"personal_name" VARCHAR(300) NOT NULL ,"username" VARCHAR(6) NOT NULL ,"staff_flg" CHAR(1) DEFAULT '0'::bpchar ENCODE lzo ,"leader_flg" CHAR(1) DEFAULT '0'::bpchar ENCODE lzo ) DISTSTYLE EVEN ; ``` ### ddlparse output BigQuery JSON schema Not parse `leader_flg` field. ```javascript [{ "name": "div_cd", "type": "STRING", "mode": "REQUIRED" }, { "name": "div_name", "type": "STRING", "mode": "REQUIRED" }, { "name": "org_cd", "type": "STRING", "mode": "REQUIRED" }, { "name": "org_name", "type": "STRING", "mode": "REQUIRED" }, { "name": "team_cd", "type": "STRING", "mode": "REQUIRED" }, { "name": "team_name", "type": "STRING", "mode": "REQUIRED" }, { "name": "personal_cd", "type": "STRING", "mode": "REQUIRED" }, { "name": "personal_name", "type": "STRING", "mode": "REQUIRED" }, { "name": "username", "type": "STRING", "mode": "REQUIRED" }, { "name": "staff_flg", "type": "STRING", "mode": "NULLABLE" }] ```	4e7e09a906e2f26d3730c8404908b9eedf1a7084	[ "test/test_ddlparse.py::test_parse[default_postgres_redshift-DDL_SET_PATTERN.method]" ]	[ "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.property]", "test/test_ddlparse.py::test_parse[constraint_mysql-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[constraint_postgres_oracle_redshift-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_oracle-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_postgres-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_mysql-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_backquote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_doublequote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[temp_table-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[table_with_schema-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[column_comment-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_bq_ddl[exist_schema_name]", "test/test_ddlparse.py::test_bq_ddl[no_schema_name]", "test/test_ddlparse.py::test_bq_ddl[datatype_postgres]", "test/test_ddlparse.py::test_bq_ddl[column_comment]", "test/test_ddlparse.py::test_exception_ddl", "test/test_ddlparse.py::test_exception_bq_data_type", "test/test_ddlparse.py::test_set_comment" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2020-08-08 03:01:10+00:00	bsd-3-clause	5,488
shinichi-takii__ddlparse-70	diff --git a/.travis.yml b/.travis.yml index efe2382..0ea230d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,6 +7,7 @@ python: - "3.6" - "3.7" - "3.8" + - "3.9" # command to install dependencies install: diff --git a/CHANGELOG.md b/CHANGELOG.md index 955ffd3..70cc41d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.10.0] - 2021-07-10 +### Added +- Added supports for Python 3.9 + +### Fixed +- Fixed parsing of columns with NULL/NOT NULL constraint. + + ## [1.9.0] - 2020-11-04 ### Added - Add supports Cloud Spanner data-type. @@ -58,7 +66,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `FIXED` ### Fixed -- Miner fix. +- Minor fix. ## [1.5.0] - 2020-07-06 @@ -70,7 +78,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed - Fix parse for column-constraint. -- Miner fix. +- Minor fix. ## [1.4.0] - 2019-12-08 @@ -161,7 +169,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - `NUMBER` with no length & scale specification ### Fixed -- Miner fix. +- Minor fix. ## [1.1.1] - 2018-03-25 @@ -182,15 +190,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [1.0.2] - 2018-01-09 ### Fixed -- Miner enhancement. +- Minor enhancement. - `ddlparse.py` : Exclude unused module. - `example.py` : Modified comment. - - `README.md` : Miner fix. + - `README.md` : Minor fix. ## [1.0.1] - 2018-01-07 ### Fixed -- Miner enhancement. +- Minor enhancement. ## [1.0.0] @@ -198,6 +206,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Initial released. +[1.10.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.9.0...v1.10.0 [1.9.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.8.0...v1.9.0 [1.8.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.7.0...v1.8.0 [1.7.0]: https://github.com/shinichi-takii/ddlparse/compare/v1.6.1...v1.7.0 diff --git a/README.md b/README.md index 7e244ec..9719092 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ [![PyPI version](https://img.shields.io/pypi/v/ddlparse.svg)](https://pypi.org/project/ddlparse/) [![Python version](https://img.shields.io/pypi/pyversions/ddlparse.svg)](https://pypi.org/project/ddlparse/) -[![Travis CI Build Status](https://travis-ci.org/shinichi-takii/ddlparse.svg?branch=master)](https://travis-ci.org/shinichi-takii/ddlparse) +[![Travis CI Build Status](https://travis-ci.com/shinichi-takii/ddlparse.svg?branch=master)](https://travis-ci.com/shinichi-takii/ddlparse) [![Coveralls Coverage Status](https://coveralls.io/repos/github/shinichi-takii/ddlparse/badge.svg?branch=master)](https://coveralls.io/github/shinichi-takii/ddlparse?branch=master) [![codecov Coverage Status](https://codecov.io/gh/shinichi-takii/ddlparse/branch/master/graph/badge.svg)](https://codecov.io/gh/shinichi-takii/ddlparse) [![Requirements Status](https://requires.io/github/shinichi-takii/ddlparse/requirements.svg?branch=master)](https://requires.io/github/shinichi-takii/ddlparse/requirements/?branch=master) diff --git a/ddlparse/__init__.py b/ddlparse/__init__.py index 514a3f2..843a9fe 100644 --- a/ddlparse/__init__.py +++ b/ddlparse/__init__.py @@ -7,8 +7,8 @@ from .ddlparse import * -__copyright__ = 'Copyright (C) 2018-2020 Shinichi Takii' -__version__ = '1.9.0' +__copyright__ = 'Copyright (C) 2018-2021 Shinichi Takii' +__version__ = '1.10.0' __license__ = 'BSD-3-Clause' __author__ = 'Shinichi Takii' __author_email__ = '[email protected]' diff --git a/ddlparse/ddlparse.py b/ddlparse/ddlparse.py index 6fa4a69..930e670 100644 --- a/ddlparse/ddlparse.py +++ b/ddlparse/ddlparse.py @@ -645,7 +645,7 @@ class DdlParse(DdlParseBase): + Optional( Regex(r"(?!--)", re.IGNORECASE) + Group( - Optional(Regex(r"\b(?:NOT\s+)NULL?\b", re.IGNORECASE))("null") + Optional(Regex(r"\b(?:NOT\s+)?NULL?\b", re.IGNORECASE))("null") & Optional(Regex(r"\bAUTO_INCREMENT\b", re.IGNORECASE))("auto_increment") & Optional(Regex(r"\b(UNIQUE\|PRIMARY)(?:\s+KEY)?\b", re.IGNORECASE))("key") & Optional(Regex( diff --git a/setup.py b/setup.py index bf722c3..b227011 100644 --- a/setup.py +++ b/setup.py @@ -64,6 +64,7 @@ setup( 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', 'Topic :: Database', 'Topic :: Software Development :: Libraries :: Python Modules', ], diff --git a/tox.ini b/tox.ini index 0241569..1c9b29e 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = py35,py36,py37,py38 +envlist = py35,py36,py37,py38,py39 [testenv] deps=	shinichi-takii/ddlparse	cce0a1eac9d52c38df8206c6b28d9f999e267405	diff --git a/test/test_ddlparse.py b/test/test_ddlparse.py index 7a50697..086a2a3 100644 --- a/test/test_ddlparse.py +++ b/test/test_ddlparse.py @@ -65,7 +65,9 @@ TEST_DATA = { Col_49 number, Col_50 decimal, Col_51 string(20), - Col_52 bytes(20) + Col_52 bytes(20), + Col_53 char(200) NULL, + Col_54 char(200) NOT NULL ); """, "database": None, @@ -123,6 +125,8 @@ TEST_DATA = { {"name": "Col_50", "type": "DECIMAL", "length": None, "scale": None}, {"name": "Col_51", "type": "STRING", "length": 20, "scale": None}, {"name": "Col_52", "type": "BYTES", "length": 20, "scale": None}, + {"name": "Col_53", "type": "CHAR", "length": 200, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": False, "pk": False, "unique": False, "description": None}, + {"name": "Col_54", "type": "CHAR", "length": 200, "scale": None, "array_dimensional": 0, "is_unsigned": False, "is_zerofill": False, "not_null": True, "pk": False, "unique": False, "constraint": "NOT NULL", "description": None}, ], "bq_field": [ '{"name": "Col_01", "type": "STRING", "mode": "REQUIRED"}', @@ -177,6 +181,8 @@ TEST_DATA = { '{"name": "Col_50", "type": "INTEGER", "mode": "NULLABLE"}', '{"name": "Col_51", "type": "STRING", "mode": "NULLABLE"}', '{"name": "Col_52", "type": "BYTES", "mode": "NULLABLE"}', + '{"name": "Col_53", "type": "STRING", "mode": "NULLABLE"}', + '{"name": "Col_54", "type": "STRING", "mode": "REQUIRED"}', ], "bq_standard_data_type": [ "STRING", @@ -231,6 +237,8 @@ TEST_DATA = { "INT64", "STRING", "BYTES", + "STRING", + "STRING", ], },	MySQL CREATE TABLE parsing fails. some columns are missing. I tried to output a BigQuery column definition from a MySQL table definition, but some columns are missing. Please show me how to avoid it by crafting `CREATE TABLE`, or if I used ddlparse incorrectly. # reproduce ## environment ```console $ sw_vers ProductName: Mac OS X ProductVersion: 10.15.7 BuildVersion: 19H2 $ python -V Python 3.8.3 $ ll $(python -c "import site; print (site.getsitepackages()[0])")/ \| grep ddlparse drwxr-xr-x 5 sakamossan staff 160B 9 25 12:49 ddlparse drwxr-xr-x 8 sakamossan staff 256B 9 25 12:49 ddlparse-1.8.0.dist-info ``` ## execution I used following files ### /tmp/_.sql ```sql CREATE TABLE `t` ( `id` INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, `created` DATETIME NULL, `modified` DATETIME NULL ) ENGINE = InnoDB; ``` ### /tmp/_.py ```python #!/usr/bin/env python import sys import json from ddlparse import DdlParse sql = sys.stdin.read() table = DdlParse().parse(ddl=sql, source_database=DdlParse.DATABASE.mysql) print(table.to_bigquery_fields()) ``` ```bash $ cat /tmp/_.json \| /tmp/_.py \| jq . [ { "name": "id", "type": "INTEGER", "mode": "REQUIRED" }, { "name": "created", "type": "DATETIME", "mode": "NULLABLE" } ] ``` modified column is not output.	cce0a1eac9d52c38df8206c6b28d9f999e267405	[ "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[basic-DDL_SET_PATTERN.property]", "test/test_ddlparse.py::test_parse[constraint_mysql-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[constraint_postgres_oracle_redshift-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[default_postgres_redshift-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_oracle-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_postgres-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[datatype_mysql-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_backquote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[name_doublequote-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[temp_table-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[table_with_schema-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_parse[column_comment-DDL_SET_PATTERN.method]", "test/test_ddlparse.py::test_bq_ddl[exist_schema_name]", "test/test_ddlparse.py::test_bq_ddl[no_schema_name]", "test/test_ddlparse.py::test_bq_ddl[datatype_postgres]", "test/test_ddlparse.py::test_bq_ddl[column_comment]", "test/test_ddlparse.py::test_exception_ddl", "test/test_ddlparse.py::test_exception_bq_data_type", "test/test_ddlparse.py::test_set_comment", "test/test_ddlparse.py::test_constraint_compatibility" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-07-06 11:29:23+00:00	bsd-3-clause	5,489
sibson__redbeat-245	diff --git a/redbeat/decoder.py b/redbeat/decoder.py index 5f630c8..a1b1ed0 100644 --- a/redbeat/decoder.py +++ b/redbeat/decoder.py @@ -1,11 +1,15 @@ import calendar import json -from datetime import datetime +from datetime import datetime, timedelta, timezone from celery.schedules import crontab, schedule -from celery.utils.time import FixedOffset, timezone from dateutil.rrule import weekday +try: + import zoneinfo +except ImportError: + from backports import zoneinfo + from .schedules import rrule @@ -24,7 +28,7 @@ def get_utcoffset_minutes(dt): def from_timestamp(seconds, tz_minutes=0): """convert seconds since the epoch to an UTC aware datetime""" - tz = FixedOffset(tz_minutes) if tz_minutes else timezone.utc + tz = timezone(timedelta(minutes=tz_minutes)) if tz_minutes else timezone.utc return datetime.fromtimestamp(seconds, tz=tz) @@ -41,9 +45,9 @@ class RedBeatJSONDecoder(json.JSONDecoder): if objtype == 'datetime': zone = d.pop('timezone', 'UTC') try: - tzinfo = FixedOffset(zone / 60) + tzinfo = timezone(timedelta(minutes=(zone / 60))) except TypeError: - tzinfo = timezone.get_timezone(zone) + tzinfo = zoneinfo.ZoneInfo(zone) return datetime(tzinfo=tzinfo, **d) if objtype == 'interval': @@ -74,10 +78,10 @@ class RedBeatJSONEncoder(json.JSONEncoder): if isinstance(obj, datetime): if obj.tzinfo is None: timezone = 'UTC' - elif obj.tzinfo.zone is None: - timezone = obj.tzinfo.utcoffset(None).total_seconds() + elif hasattr(obj.tzinfo, 'key'): + timezone = obj.tzinfo.key else: - timezone = obj.tzinfo.zone + timezone = obj.tzinfo.utcoffset(None).total_seconds() return { '__type__': 'datetime', diff --git a/requirements-dev.txt b/requirements-dev.txt index d3f3b16..9d93a24 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -6,3 +6,4 @@ redis>=3.2 tenacity twine wheel +backports.zoneinfo>=0.2.1; python_version < "3.9.0" diff --git a/setup.py b/setup.py index fad7fc4..f76c17b 100644 --- a/setup.py +++ b/setup.py @@ -27,6 +27,12 @@ setup( 'Programming Language :: Python :: Implementation :: CPython', 'Operating System :: OS Independent', ], - install_requires=['redis>=3.2', 'celery>=5.0', 'python-dateutil', 'tenacity'], + install_requires=[ + 'redis>=3.2', + 'celery>=5.0', + 'python-dateutil', + 'tenacity', + 'backports.zoneinfo>=0.2.1; python_version < "3.9.0"', + ], tests_require=['pytest'], )	sibson/redbeat	d698cc3eae8b26f011836bb6f2e1ab87e9019951	diff --git a/tests/test_json.py b/tests/test_json.py index c08ad50..67ff61c 100644 --- a/tests/test_json.py +++ b/tests/test_json.py @@ -1,14 +1,18 @@ import json -from datetime import datetime +from datetime import datetime, timedelta, timezone from unittest import TestCase from celery.schedules import crontab, schedule -from celery.utils.time import FixedOffset, timezone from dateutil import rrule as dateutil_rrule from redbeat.decoder import RedBeatJSONDecoder, RedBeatJSONEncoder from redbeat.schedules import rrule +try: + import zoneinfo +except ImportError: + from backports import zoneinfo + class JSONTestCase(TestCase): def dumps(self, d): @@ -99,14 +103,14 @@ class RedBeatJSONEncoderTestCase(JSONTestCase): self.assertEqual(json.loads(result), expected) def test_datetime_with_tz(self): - dt = self.now(tzinfo=timezone.get_timezone('Asia/Shanghai')) + dt = self.now(tzinfo=zoneinfo.ZoneInfo('Asia/Shanghai')) result = self.dumps(dt) expected = self.datetime_as_dict(timezone='Asia/Shanghai', __type__='datetime') self.assertEqual(json.loads(result), expected) def test_datetime_with_fixedoffset(self): - dt = self.now(tzinfo=FixedOffset(4 * 60)) + dt = self.now(tzinfo=timezone(timedelta(hours=4))) result = self.dumps(dt) expected = self.datetime_as_dict(timezone=4 * 60 * 60.0) @@ -134,7 +138,7 @@ class RedBeatJSONEncoderTestCase(JSONTestCase): self.assertEqual(json.loads(result), self.rrule()) def test_rrule_timezone(self): - tz = timezone.get_timezone('US/Eastern') + tz = zoneinfo.ZoneInfo('US/Eastern') start1 = datetime(2015, 12, 30, 12, 59, 22, tzinfo=timezone.utc) start2 = start1.astimezone(tz) @@ -209,14 +213,14 @@ class RedBeatJSONDecoderTestCase(JSONTestCase): result = self.loads(json.dumps(d)) d.pop('__type__') d.pop('timezone') - self.assertEqual(result, datetime(tzinfo=timezone.get_timezone('Asia/Shanghai'), d)) + self.assertEqual(result, datetime(tzinfo=zoneinfo.ZoneInfo('Asia/Shanghai'), d)) def test_datetime_with_fixed_offset(self): d = self.datetime_as_dict(__type__='datetime', timezone=5 * 60 * 60) result = self.loads(json.dumps(d)) d.pop('__type__') d.pop('timezone') - self.assertEqual(result, datetime(tzinfo=FixedOffset(5 * 60), d)) + self.assertEqual(result, datetime(tzinfo=timezone(timedelta(hours=5)), d)) def test_schedule(self): d = self.schedule()	Celery 5.3.0rc1 not useable with redbeat anymore. Since celery 5.3.0rc1 redbeat isnt working anymore. Please see trace. Seems FixedOffset does not exist anymore in Celery 5.3.0: ``` celery-beat \| Traceback (most recent call last): celery-beat \| File "/venv/bin/celery", line 8, in <module> celery-beat \| sys.exit(main()) celery-beat \| ^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/__main__.py", line 15, in main celery-beat \| sys.exit(_main()) celery-beat \| ^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/bin/celery.py", line 235, in main celery-beat \| return celery(auto_envvar_prefix="CELERY") celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/core.py", line 1130, in __call__ celery-beat \| return self.main(args, kwargs) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/core.py", line 1055, in main celery-beat \| rv = self.invoke(ctx) celery-beat \| ^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/core.py", line 1657, in invoke celery-beat \| return _process_result(sub_ctx.command.invoke(sub_ctx)) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/core.py", line 1404, in invoke celery-beat \| return ctx.invoke(self.callback, ctx.params) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/core.py", line 760, in invoke celery-beat \| return __callback(args, *kwargs) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/click/decorators.py", line 26, in new_func celery-beat \| return f(get_current_context(), args, *kwargs) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/bin/base.py", line 134, in caller celery-beat \| return f(ctx, args, kwargs) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/bin/beat.py", line 72, in beat celery-beat \| return beat().run() celery-beat \| ^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/apps/beat.py", line 84, in run celery-beat \| self.start_scheduler() celery-beat \| File "/venv/lib/python3.11/site-packages/celery/apps/beat.py", line 104, in start_scheduler celery-beat \| print(self.banner(service)) celery-beat \| ^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/apps/beat.py", line 126, in banner celery-beat \| c.reset(self.startup_info(service))), celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/apps/beat.py", line 136, in startup_info celery-beat \| scheduler = service.get_scheduler(lazy=True) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/celery/beat.py", line 665, in get_scheduler celery-beat \| return symbol_by_name(self.scheduler_cls, aliases=aliases)( celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/kombu/utils/imports.py", line 58, in symbol_by_name celery-beat \| module = imp(module_name, package=package, kwargs) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/usr/local/lib/python3.11/importlib/__init__.py", line 126, in import_module celery-beat \| return _bootstrap._gcd_import(name[level:], package, level) celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "<frozen importlib._bootstrap>", line 1206, in _gcd_import celery-beat \| File "<frozen importlib._bootstrap>", line 1178, in _find_and_load celery-beat \| File "<frozen importlib._bootstrap>", line 1149, in _find_and_load_unlocked celery-beat \| File "<frozen importlib._bootstrap>", line 690, in _load_unlocked celery-beat \| File "<frozen importlib._bootstrap_external>", line 940, in exec_module celery-beat \| File "<frozen importlib._bootstrap>", line 241, in _call_with_frames_removed celery-beat \| File "/venv/lib/python3.11/site-packages/redbeat/__init__.py", line 3, in <module> celery-beat \| from .schedulers import RedBeatScheduler, RedBeatSchedulerEntry # noqa celery-beat \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ celery-beat \| File "/venv/lib/python3.11/site-packages/redbeat/schedulers.py", line 30, in <module> celery-beat \| from .decoder import RedBeatJSONEncoder, RedBeatJSONDecoder, to_timestamp celery-beat \| File "/venv/lib/python3.11/site-packages/redbeat/decoder.py", line 8, in <module> celery-beat \| from celery.utils.time import timezone, FixedOffset celery-beat \| ImportError: cannot import name 'FixedOffset' from 'celery.utils.time' (/venv/lib/python3.11/site-packages/celery/utils/time.py) ```	d698cc3eae8b26f011836bb6f2e1ab87e9019951	[ "tests/test_json.py::RedBeatJSONEncoderTestCase::test_crontab", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_datetime_no_tz", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_datetime_with_fixedoffset", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_datetime_with_tz", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_rrule", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_rrule_timezone", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_schedule", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_weekday", "tests/test_json.py::RedBeatJSONEncoderTestCase::test_weekday_in_rrule", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_crontab", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_datetime_no_timezone", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_datetime_with_fixed_offset", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_datetime_with_timezone", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_rrule", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_schedule", "tests/test_json.py::RedBeatJSONDecoderTestCase::test_weekday" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-05-16 13:25:41+00:00	apache-2.0	5,490
sigasi__SigasiProjectCreator-43	diff --git a/src/SigasiProjectCreator/CsvParser.py b/src/SigasiProjectCreator/CsvParser.py index 408eeba..83e59fc 100644 --- a/src/SigasiProjectCreator/CsvParser.py +++ b/src/SigasiProjectCreator/CsvParser.py @@ -5,7 +5,9 @@ """ import csv import pathlib +from collections import defaultdict +from SigasiProjectCreator import abort_if_false, is_valid_name from SigasiProjectCreator.ProjectFileParser import ProjectFileParser, project_file_parser, ProjectFileParserResult @@ -16,18 +18,21 @@ class CsvParser(ProjectFileParser): super().__init__() def parse_file(self, csv_file, options=None): - library_mapping = dict() + library_mapping = defaultdict(list) + includes = set() + defines = [] with open(csv_file, 'r') as f: reader = csv.reader(f, skipinitialspace=True) for row in reader: if row: library = row[0].strip() - path = pathlib.Path(row[1].strip()).absolute().resolve() - if path in library_mapping: - if isinstance(library_mapping[path], list): - library_mapping[path].append(library) - else: - library_mapping[path] = [library_mapping[path], library] + if library == '#define': + defines.append(row[1].strip()) else: - library_mapping[path] = library - return ProjectFileParserResult(library_mapping, None, None) + path = pathlib.Path(row[1].strip()).absolute().resolve() + if library == '#include': + includes.add(path) + else: + abort_if_false(is_valid_name(library), f'Invalid library name: {library}') + library_mapping[path].append(library) + return ProjectFileParserResult(library_mapping, verilog_defines=defines, verilog_includes=includes) diff --git a/src/SigasiProjectCreator/ProjectOptions.py b/src/SigasiProjectCreator/ProjectOptions.py index 328f30a..7d832d8 100644 --- a/src/SigasiProjectCreator/ProjectOptions.py +++ b/src/SigasiProjectCreator/ProjectOptions.py @@ -30,7 +30,8 @@ class ProjectOptions: parser.add_argument('--format', action='store', dest='format', choices=ProjectFileParser.project_file_parsers.keys(), default=None, help='Force input format (ignore file extension): ' + ', '.join( - f'{key} ({cls.__doc__})' for key, cls in ProjectFileParser.project_file_parsers.items())) + f'{key} ({cls.__doc__})' for key, cls in + ProjectFileParser.project_file_parsers.items())) parser.add_argument('--mapping', action='store', dest='mapping', choices=['file', 'folder'], default='file', help='Library mapping style: `folder` = map folders where possible, `file` = map ' diff --git a/src/SigasiProjectCreator/__init__.py b/src/SigasiProjectCreator/__init__.py index a70ae1b..bc4ddba 100644 --- a/src/SigasiProjectCreator/__init__.py +++ b/src/SigasiProjectCreator/__init__.py @@ -1,3 +1,4 @@ +import re import sys from os.path import abspath, normcase, splitdrive, join from pathlib import PurePath @@ -23,3 +24,7 @@ def abort_if_false(condition, message, code=5): if not condition: print(message) sys.exit(code) + + +def is_valid_name(text): + return re.match('(?!.__)[a-zA-Z][\\w][^_]', text)	sigasi/SigasiProjectCreator	7f9d8522d519f5349d63d5516dd01264ae8d4485	diff --git a/tests/CsvParserTest.py b/tests/CsvParserTest.py new file mode 100644 index 0000000..53f6f38 --- /dev/null +++ b/tests/CsvParserTest.py @@ -0,0 +1,57 @@ +import pathlib +import unittest + +from SigasiProjectCreator.CsvParser import CsvParser +from SigasiProjectCreator.ProjectOptions import ProjectOptions + + +class CsvParserTest(unittest.TestCase): + def test_extended_csv(self): + input_file = 'tests/test-files/csv/extended.csv' + command_line_options = ['the_project', input_file] + self.options = ProjectOptions(command_line_options) + result = CsvParser().parse_file(input_file, self.options) + expected_library_mapping = { + pathlib.Path('foo/bar.vhd').absolute().resolve(): ['test1'], + pathlib.Path('bahr/define.sv').absolute().resolve(): ['define'], + pathlib.Path('clock_generator.vhd').absolute().resolve(): ['test2'], + pathlib.Path('dut.vhd').absolute().resolve(): ['test2'], + pathlib.Path('testbench.vhd').absolute().resolve(): ['test1'], + pathlib.Path('include.vhd').absolute().resolve(): ['include'] + } + expected_includes = { + pathlib.Path('includes').absolute().resolve() + } + expected_defines = ['SIGASI=true'] + self.assertDictEqual(result.library_mapping, expected_library_mapping, 'Library mapping mismatch') + self.assertSetEqual(result.verilog_includes, expected_includes, 'Includes list mismatch') + self.assertListEqual(result.verilog_defines, expected_defines, 'Defines list mismatch') + + def test_multimap_csv(self): + self.maxDiff = None + input_file = 'tests/test-files/csv/multimap.csv' + command_line_options = ['the_project', input_file] + self.options = ProjectOptions(command_line_options) + result = CsvParser().parse_file(input_file, self.options) + expected_library_mapping = { + pathlib.Path('foo/bar.vhd').absolute().resolve(): ['test1'], + pathlib.Path('clock_generator.vhd').absolute().resolve(): ['test2', 'test1', 'test7'], + pathlib.Path('dut.vhd').absolute().resolve(): ['test2', 'test3'], + pathlib.Path('testbench.vhd').absolute().resolve(): ['test1'] + } + self.assertDictEqual(result.library_mapping, expected_library_mapping, 'Library mapping mismatch') + self.assertSetEqual(result.verilog_includes, set(), 'Includes list mismatch') + self.assertListEqual(result.verilog_defines, [], 'Defines list mismatch') + + def test_invalid_library_name(self): + self.maxDiff = None + input_file = 'tests/test-files/csv/invalid_lib.csv' + command_line_options = ['the_project', input_file] + self.options = ProjectOptions(command_line_options) + with self.assertRaises(SystemExit) as context: + result = CsvParser().parse_file(input_file, self.options) + self.assertEqual('5', str(context.exception)) # exit code 5 from abort_if_false + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/ProjectCreatorTest.py b/tests/ProjectCreatorTest.py index 0c4e40f..a75e000 100644 --- a/tests/ProjectCreatorTest.py +++ b/tests/ProjectCreatorTest.py @@ -435,7 +435,7 @@ class ProjectCreatorTest(unittest.TestCase): expected = [ ['include_folders', 'virtual:/virtual', True, False], [pathlib.Path('include_folders/verilog'), '/somelib/verilog', True, True], - [pathlib.Path('Common Libraries/uvm'), '/home/wmeeus/git/SigasiProjectCreator_github/uvm/src', True, True], + [pathlib.Path('Common Libraries/uvm'), base_path.joinpath('uvm/src').as_posix(), True, True], ['Common Libraries', 'virtual:/virtual', True, False], ['Common Libraries/IEEE', 'sigasiresource:/vhdl/2008/IEEE', True, False], ['Common Libraries/IEEE Synopsys', 'sigasiresource:/vhdl/2008/IEEE%20Synopsys', True, False], diff --git a/tests/test-files/csv/extended.csv b/tests/test-files/csv/extended.csv new file mode 100644 index 0000000..498119d --- /dev/null +++ b/tests/test-files/csv/extended.csv @@ -0,0 +1,8 @@ +test1, foo/bar.vhd +define, bahr/define.sv +test2, clock_generator.vhd +#define, SIGASI=true +test2, dut.vhd +#include, includes +test1, testbench.vhd +include, include.vhd diff --git a/tests/test-files/csv/invalid_lib.csv b/tests/test-files/csv/invalid_lib.csv new file mode 100644 index 0000000..ee1b249 --- /dev/null +++ b/tests/test-files/csv/invalid_lib.csv @@ -0,0 +1,8 @@ +test1, foo/bar.vhd +define, bahr/define.sv +_test2, clock_generator.vhd +#define, SIGASI=true +test2, dut.vhd +#include, includes +test1, testbench.vhd +include, include.vhd diff --git a/tests/test-files/csv/multimap.csv b/tests/test-files/csv/multimap.csv new file mode 100644 index 0000000..dd99344 --- /dev/null +++ b/tests/test-files/csv/multimap.csv @@ -0,0 +1,7 @@ +test1, foo/bar.vhd +test2, clock_generator.vhd +test2, dut.vhd +test1, testbench.vhd +test1, clock_generator.vhd +test3, dut.vhd +test7, clock_generator.vhd	Extend csv import for include folders and defines The csv import is currently limited to design files only. We want to extend that: * If the first column of the csv file contains `include`, interpret the 2nd column of the same line(s) as (an) include path(s) * If the first column of the csv file contains `define`, interpret the 2nd column of the same line(s) as (a) define(s)	7f9d8522d519f5349d63d5516dd01264ae8d4485	[ "tests/CsvParserTest.py::CsvParserTest::test_extended_csv", "tests/CsvParserTest.py::CsvParserTest::test_invalid_library_name", "tests/CsvParserTest.py::CsvParserTest::test_multimap_csv" ]	[ "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_abs_or_rel_path_abs", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_abs_or_rel_path_rel", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_abs_or_rel_path_rel_in", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_check_and_create_linked_folder", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_check_and_create_virtual_folder", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_library_mapping_folders", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_project_in_place", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_project_links_flat", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_project_links_folders", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_project_links_tree", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_create_project_simulator", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_get_design_folders", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_get_design_root_folder", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_get_design_subtrees", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_get_parser_for_type", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_parse_and_create_project", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_uniquify_project_path_empty_list", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_uniquify_project_path_in_list", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_uniquify_project_path_in_list_multi", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_uniquify_project_path_none", "tests/ProjectCreatorTest.py::ProjectCreatorTest::test_uniquify_project_path_not_in_list" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2023-11-10 11:03:59+00:00	bsd-3-clause	5,491
signaux-faibles__predictsignauxfaibles-68	diff --git a/predictsignauxfaibles/data.py b/predictsignauxfaibles/data.py index 1fb9e9c..70835a0 100644 --- a/predictsignauxfaibles/data.py +++ b/predictsignauxfaibles/data.py @@ -151,6 +151,12 @@ class SFDataset: for feat in missing: self.data[feat] = NAN + # force SIREN and SIRET to be strings + if "siren" in self.data.columns: + self.data.siren = self.data.siren.astype(str) + if "siret" in self.data.columns: + self.data.siret = self.data.siret.astype(str) + return self def raise_if_empty(self): diff --git a/predictsignauxfaibles/pipelines.py b/predictsignauxfaibles/pipelines.py index 7f2df8b..3e564d8 100644 --- a/predictsignauxfaibles/pipelines.py +++ b/predictsignauxfaibles/pipelines.py @@ -11,6 +11,11 @@ from predictsignauxfaibles.preprocessors import ( acoss_make_avg_delta_dette_par_effectif, ) +from predictsignauxfaibles.redressements import ( + Redressement, + redressement_urssaf_covid, +) + class MissingDataError(Exception): """ @@ -20,29 +25,30 @@ class MissingDataError(Exception): def run_pipeline(data: pd.DataFrame, pipeline: List[namedtuple]): """ - Run a pipeline of Preprocessor objects on a dataframe + Run a pipeline of Preprocessor or Redressement objects (aka "steps") on a dataframe Args: - pipeline: a list of Preprocessor objects (see predictsignauxfaibles.preprocessors) + pipeline: a list of Preprocessor or Redressement objects + (see predictsignauxfaibles.preprocessors or predictsignauxfaibles.redressements) """ logging.info("Checking that input columns are all there.") - for preprocessor in pipeline: - if not set(preprocessor.input).issubset(data.columns): - missing_cols = set(preprocessor.input) - set(data.columns) + for step in pipeline: + if not set(step.input).issubset(data.columns): + missing_cols = set(step.input) - set(data.columns) error_message = ( - f"Missing variables {missing_cols} in order to run {preprocessor.name}." + f"Missing variables {missing_cols} in order to run {step.name}." ) raise MissingDataError(error_message) logging.info("Running pipeline on data.") data = data.copy() - for i, preprocessor in enumerate(pipeline): - logging.info(f"STEP {i+1}: {preprocessor.name}") - data = preprocessor.function(data) - if preprocessor.output is None: + for i, step in enumerate(pipeline): + logging.info(f"STEP {i+1}: {step.name}") + data = step.function(data) + if step.output is None: continue - if not set(preprocessor.output).issubset(data.columns): - missing_output_cols = set(preprocessor.output) - set(data.columns) - warning_message = f"STEP {i+1}: function {preprocessor.function.__name__} \ + if not set(step.output).issubset(data.columns): + missing_output_cols = set(step.output) - set(data.columns) + warning_message = f"STEP {i+1}: function {step.function.__name__} \ did not produce expected output {missing_output_cols}" logging.warning(warning_message) continue @@ -52,6 +58,8 @@ did not produce expected output {missing_output_cols}" # Pipelines +# Preprocessors + DEFAULT_PIPELINE = [ Preprocessor( "Remove Administrations", @@ -106,5 +114,23 @@ SMALL_PIPELINE = [ ), ] +# Redressements + +REDRESSEMENTS_PIPELINE = [ + Redressement( + "Redressement URSSAF evolution dette Juillet 2020", + redressement_urssaf_covid, + input=[ + "montant_part_ouvriere_latest", + "montant_part_patronale_latest", + "montant_part_ouvriere_july2020", + "montant_part_patronale_july2020", + "cotisation_moy12m_latest", + "group_final", + ], + output=["group_final_regle_urssaf"], + ), +] + # This is useful for automatic testing -ALL_PIPELINES = [DEFAULT_PIPELINE, SMALL_PIPELINE] +ALL_PIPELINES = [DEFAULT_PIPELINE, SMALL_PIPELINE, REDRESSEMENTS_PIPELINE] diff --git a/predictsignauxfaibles/redressements.py b/predictsignauxfaibles/redressements.py new file mode 100644 index 0000000..58dffa5 --- /dev/null +++ b/predictsignauxfaibles/redressements.py @@ -0,0 +1,48 @@ +from collections import namedtuple + +import pandas as pd + +Redressement = namedtuple("Redressement", ["name", "function", "input", "output"]) + + +def redressement_urssaf_covid(data: pd.DataFrame): + """ + Règle experte + """ + + # compute change in social debt as a proportion of average cotisations over the past 12months + data["montant_part_ouvriere_latest"].fillna(0, inplace=True) + data["montant_part_patronale_latest"].fillna(0, inplace=True) + data["montant_part_ouvriere_july2020"].fillna(0, inplace=True) + data["montant_part_patronale_july2020"].fillna(0, inplace=True) + data["dette_sociale_july2020"] = ( + data.montant_part_ouvriere_july2020 + data.montant_part_patronale_july2020 + ) + data["dette_sociale_latest"] = ( + data.montant_part_ouvriere_latest + data.montant_part_patronale_latest + ) + + data["delta_dette"] = ( + data.dette_sociale_latest - data.dette_sociale_july2020 + ) / data.cotisation_moy12m_latest + + tol = 0.2 # tolerate a change smaller than 20% + + def rule(dataframe): + """ + Expert rule to apply + """ + value = dataframe["delta_dette"] + group = dataframe["group_final"] + if value > tol: + if group == "vert": + return "orange" + if group == "orange": + return "rouge" + if group == "rouge": + return "rouge" + return group + + data["group_final_regle_urssaf"] = data.apply(rule, axis=1) + + return data	signaux-faibles/predictsignauxfaibles	43bf1c391a029f1af76e0763e6f1709e5a458484	diff --git a/tests/fake_data/dataframes.py b/tests/fake_data/dataframes.py index a86536b..b88d574 100644 --- a/tests/fake_data/dataframes.py +++ b/tests/fake_data/dataframes.py @@ -26,3 +26,14 @@ df_test_code_naf = pd.DataFrame( ) df_test_full = pd.concat((df_test_code_naf, df_test_acoss, df_test_paydex), axis=1) + +df_test_redressement_urssaf = pd.DataFrame( + { + "montant_part_ouvriere_latest": [50, 60, 100], + "montant_part_patronale_latest": [75, 50, 100], + "montant_part_ouvriere_july2020": [50, 50, 50], + "montant_part_patronale_july2020": [50, 50, 0], + "cotisation_moy12m_latest": [100, 100, 75], + "group_final": ["vert", "vert", "rouge"], + } +) diff --git a/tests/unit/pipelines_test.py b/tests/unit/pipelines_test.py index 2dba9ba..9b62b1f 100644 --- a/tests/unit/pipelines_test.py +++ b/tests/unit/pipelines_test.py @@ -10,22 +10,23 @@ from predictsignauxfaibles.pipelines import ( ) from predictsignauxfaibles.preprocessors import Preprocessor +from predictsignauxfaibles.redressements import Redressement from tests.fake_data.dataframes import df_test_full @pytest.mark.parametrize("pipeline", ALL_PIPELINES) -def test_final_pipeline(pipeline): - for preprocessor in pipeline: - assert isinstance(preprocessor, Preprocessor) - assert hasattr(preprocessor, "name") - assert hasattr(preprocessor, "function") - assert hasattr(preprocessor, "input") - assert hasattr(preprocessor, "output") - assert isinstance(preprocessor.name, str) - assert callable(preprocessor.function) - assert isinstance(preprocessor.input, list) - assert isinstance(preprocessor.output, list) or preprocessor.output is None +def test_all_pipeline(pipeline): + for step in pipeline: + assert isinstance(step, (Preprocessor, Redressement)) + assert hasattr(step, "name") + assert hasattr(step, "function") + assert hasattr(step, "input") + assert hasattr(step, "output") + assert isinstance(step.name, str) + assert callable(step.function) + assert isinstance(step.input, list) + assert isinstance(step.output, list) or step.output is None def test_default_pipeline_sucess(): diff --git a/tests/unit/redressements_test.py b/tests/unit/redressements_test.py new file mode 100644 index 0000000..2078717 --- /dev/null +++ b/tests/unit/redressements_test.py @@ -0,0 +1,11 @@ +# pylint: disable=missing-function-docstring +import pandas as pd +from predictsignauxfaibles.redressements import redressement_urssaf_covid + +from tests.fake_data.dataframes import df_test_redressement_urssaf + + +def test_redressement_urssaf_covid(): + data_in = df_test_redressement_urssaf.copy() + data_out = redressement_urssaf_covid(data_in) + assert (data_out["group_final_regle_urssaf"] == ["orange", "vert", "rouge"]).all()	Make SIREN and SIRET string not int ### Problem The dataframe retrieved by `SFDataset` contains SIRET and SIREN that are typed as `int64` which means that their leading 0 is ignored. So we have ```python # this fails dataset.data.siren == "012345678" # this works dataset.data.siren == 12345678 ``` which is not right ### Solution Figure out a way to force the `siret` and `siren` columns to be read as strings. ### ⚠️ I haven't checked yet but there's a chance that this typing issue not due to pandas but to MongoDB.	43bf1c391a029f1af76e0763e6f1709e5a458484	[ "tests/unit/pipelines_test.py::test_all_pipeline[pipeline0]", "tests/unit/pipelines_test.py::test_all_pipeline[pipeline1]", "tests/unit/pipelines_test.py::test_all_pipeline[pipeline2]", "tests/unit/pipelines_test.py::test_default_pipeline_sucess", "tests/unit/pipelines_test.py::test_default_pipeline_missing_input", "tests/unit/redressements_test.py::test_redressement_urssaf_covid" ]	[]	{ "failed_lite_validators": [ "has_added_files", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-05-25 09:24:27+00:00	mit	5,492
simonsobs__ocs-206	diff --git a/ocs/matched_client.py b/ocs/matched_client.py index b5be3a6..5a32114 100644 --- a/ocs/matched_client.py +++ b/ocs/matched_client.py @@ -79,19 +79,22 @@ class MatchedClient: """ def __init__(self, instance_id, kwargs): - """MatchedClient __init__ function. - + """ Args: instance_id (str): Instance id for agent to run args (list or args object, optional): Takes in the parser arguments for the client. - If None, reads from command line. + If None, pass an empty list. If list, reads in list elements as arguments. Defaults to None. - For additional kwargs see site_config.get_control_client. + .. note:: + For additional ``kwargs`` see site_config.get_control_client. """ + if kwargs.get('args') is None: + kwargs['args'] = [] + self._client = site_config.get_control_client(instance_id, **kwargs) self.instance_id = instance_id	simonsobs/ocs	e1a813e7a32649c6cd85f52c4fc0eac0dff0de86	diff --git a/tests/test_matched_client.py b/tests/test_matched_client.py new file mode 100644 index 0000000..1e8765d --- /dev/null +++ b/tests/test_matched_client.py @@ -0,0 +1,28 @@ +import os +from unittest.mock import MagicMock, patch +from ocs.matched_client import MatchedClient + +mocked_client = MagicMock() +mock_from_yaml = MagicMock() + + +@patch('ocs.client_http.ControlClient', mocked_client) +@patch('ocs.site_config.SiteConfig.from_yaml', mock_from_yaml) +@patch('sys.argv', ['example_client.py', 'test']) +def test_extra_argv(): + """If there are extra arguments in sys.argv and args=[] is not set when + instantiating a MatchedClient, then internally + site_config.get_control_client() will inspect sys.argv[1:], which causes + issues down the line when run through the site_config parser. + + Here we patch in a mocked ControlClient to avoid needing to talk to a + crossbar server. We also patch in a mocked from_yaml() method, to avoid + needing to read a real site file. Lastly, and most importantly, we patch in + sys.argv with an actual additional argument. This will cause an + "unrecognized arguments" error when argparse inspects sys.argv within the + site_config parser. + + """ + # Set for get_config to pick up on + os.environ["OCS_CONFIG_DIR"] = '/tmp/' + MatchedClient("test")	MatchedClient(instance_id) causes argparse to run on sys.argv If you do something simple like ``` c = MatchedClient('acu1') ``` then sys.argv will get run through the site_config parser. This causes trouble when you want to use MatchedClient in anything where sys.argv is non-trivial, such as in jupyter or a script with its own command line args. The work-around is to pass args=[] to this constructor. But it would be better if by default there was no inspection of sys.argv. The MatchedClient code should be changed as follows: If args=None is passed in to the constructor, that should result in args=[] being passed through to site_config. (If a user really wants to pass sys.argv through, they can do that explicitly in MatchedClient instantiation.)	e1a813e7a32649c6cd85f52c4fc0eac0dff0de86	[ "tests/test_matched_client.py::test_extra_argv" ]	[]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2021-07-02 02:34:33+00:00	bsd-2-clause	5,493
simonsobs__ocs-269	diff --git a/Dockerfile b/Dockerfile index 49d1f0d..6b7bc59 100644 --- a/Dockerfile +++ b/Dockerfile @@ -2,7 +2,7 @@ # A container setup with an installation of ocs. # Use ubuntu base image -FROM simonsobs/so3g:v0.1.0-117-g75c1d8d +FROM simonsobs/so3g:v0.1.3-13-g5471f0d # Set locale ENV LANG C.UTF-8 diff --git a/ocs/ocs_feed.py b/ocs/ocs_feed.py index 0e59b49..934e727 100644 --- a/ocs/ocs_feed.py +++ b/ocs/ocs_feed.py @@ -248,17 +248,15 @@ class Feed: supported types. Args: - value (list, float, int): + value (list, float, int, bool): 'data' dictionary value published (see Feed.publish_message for details). """ - valid_types = (float, int, str) + valid_types = (float, int, str, bool) - # separate bool checks since bool is a subclass of int # multi-sample check if isinstance(value, list): - if (any(isinstance(x, bool) for x in value) - or not all(isinstance(x, valid_types) for x in value)): + if not all(isinstance(x, valid_types) for x in value): type_set = set([type(x) for x in value]) invalid_types = type_set.difference(valid_types) raise TypeError("message 'data' block contains invalid data" + @@ -266,7 +264,7 @@ class Feed: # single sample check else: - if isinstance(value, bool) or not isinstance(value, valid_types): + if not isinstance(value, valid_types): invalid_type = type(value) raise TypeError("message 'data' block contains invalid " + f"data type: {invalid_type}")	simonsobs/ocs	bc67d6132e9806c7b482f39466feecce8deae965	diff --git a/tests/test_ocs_feed.py b/tests/test_ocs_feed.py index b6ec529..d5869ca 100644 --- a/tests/test_ocs_feed.py +++ b/tests/test_ocs_feed.py @@ -76,8 +76,7 @@ class TestPublishMessage: } } - with pytest.raises(TypeError): - test_feed.publish_message(test_message) + test_feed.publish_message(test_message) def test_bool_multi_sample_input(self): mock_agent = MagicMock() @@ -91,6 +90,21 @@ class TestPublishMessage: } } + test_feed.publish_message(test_message) + + def test_invalid_single_sample_input(self): + mock_agent = MagicMock() + test_feed = ocs_feed.Feed(mock_agent, 'test_feed', record=True) + + test_message = { + 'block_name': 'test', + 'timestamps': time.time(), + 'data': { + 'key1': 1., + 'key2': None, + } + } + with pytest.raises(TypeError): test_feed.publish_message(test_message)	Add boolean support to OCS feeds Once Bool support is added to so3g (https://github.com/simonsobs/so3g/issues/116) `Feed.verify_message_data_type` should be updated to support bools.	bc67d6132e9806c7b482f39466feecce8deae965	[ "tests/test_ocs_feed.py::TestPublishMessage::test_bool_multi_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_bool_single_sample_input" ]	[ "tests/test_ocs_feed.py::test_block_creation", "tests/test_ocs_feed.py::test_block_append", "tests/test_ocs_feed.py::TestPublishMessage::test_valid_multi_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_valid_single_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_start_underscore4", "tests/test_ocs_feed.py::TestPublishMessage::test_invalid_data_key_character", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_start_underscore1", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_start_underscore2", "tests/test_ocs_feed.py::TestPublishMessage::test_empty_field_name", "tests/test_ocs_feed.py::TestPublishMessage::test_str_multi_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_invalid_single_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_str_single_sample_input", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_start_with_number", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_start_underscore3", "tests/test_ocs_feed.py::TestPublishMessage::test_data_key_too_long" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2022-05-26 13:36:23+00:00	bsd-2-clause	5,494
simonsobs__ocs-297	diff --git a/ocs/agents/influxdb_publisher/drivers.py b/ocs/agents/influxdb_publisher/drivers.py index 018657a..116fdef 100644 --- a/ocs/agents/influxdb_publisher/drivers.py +++ b/ocs/agents/influxdb_publisher/drivers.py @@ -125,6 +125,19 @@ class Publisher: except InfluxDBServerError as err: LOG.error("InfluxDB Server Error: {e}", e=err) + @staticmethod + def _format_field_line(field_key, field_value): + """Format key-value pair for InfluxDB line protocol.""" + # Strings must be in quotes for line protocol + if isinstance(field_value, str): + line = f'{field_key}="{field_value}"' + else: + line = f"{field_key}={field_value}" + # Don't append 'i' to bool, which is a subclass of int + if isinstance(field_value, int) and not isinstance(field_value, bool): + line += "i" + return line + @staticmethod def format_data(data, feed, protocol): """Format the data from an OCS feed into a dict for pushing to InfluxDB. @@ -167,13 +180,7 @@ class Publisher: if protocol == 'line': fields_line = [] for mk, mv in fields.items(): - # Strings must be in quotes for line protocol - if isinstance(mv, str): - f_line = f'{mk}="{mv}"' - else: - f_line = f"{mk}={mv}" - if isinstance(mv, int): - f_line += "i" + f_line = Publisher._format_field_line(mk, mv) fields_line.append(f_line) measurement_line = ','.join(fields_line)	simonsobs/ocs	3a998daaa394daccedb25bbdef87cbd0c44e5700	diff --git a/tests/agents/test_influxdb_publisher_drivers.py b/tests/agents/test_influxdb_publisher_drivers.py new file mode 100644 index 0000000..4e3bca5 --- /dev/null +++ b/tests/agents/test_influxdb_publisher_drivers.py @@ -0,0 +1,13 @@ +from ocs.agents.influxdb_publisher.drivers import Publisher + +import pytest + + [email protected]("key,value,result", [('fieldname', False, 'fieldname=False'), + ('fieldname', 1, 'fieldname=1i'), + ('fieldname', 4.2, 'fieldname=4.2'), + ('fieldname', 'string', 'fieldname="string"')]) +def test_publisher_format_field_line(key, value, result): + f_line = Publisher._format_field_line(key, value) + + assert f_line == result	booleans published to influxdb get malformed by publisher Seen at Penn recently: ``` 2022-07-29T19:23:54+0000 InfluxDB Client Error: 400: {"error":"unable to parse 'observatory.pysmurf-monitor-so6,feed=ufm_mv17_meta AMCcSmurfProcessorFileWriterIsOpen=Falsei 1659122634599413504': invalid boolean"} 2022-07-29T19:23:58+0000 InfluxDB Client Error: 400: {"error":"unable to parse 'observatory.pysmurf-monitor-so6,feed=ufm_mv4_meta AMCcSmurfProcessorFileWriterIsOpen=Falsei 1659122637660398848': invalid boolean"} 2022-07-29T19:23:58+0000 InfluxDB Client Error: 400: {"error":"unable to parse 'observatory.pysmurf-monitor-so6,feed=ufm_mv11_meta AMCcSmurfProcessorFileWriterIsOpen=Falsei 1659122637663661824': invalid boolean"} ``` This is caused by these couple lines: https://github.com/simonsobs/ocs/blob/971bac7f8133744184a46c1312800cbcf44ea11e/ocs/agent/influxdb_publisher.py#L174-L175 Since `bool` is a subclass of `int` this results in `True` for any `bool` in `mv`, which appends an "i" to the bool. This fails to insert into InfluxDB, hence the error. We saw this same thing in #229.	3a998daaa394daccedb25bbdef87cbd0c44e5700	[ "tests/agents/test_influxdb_publisher_drivers.py::test_publisher_format_field_line[fieldname-False-fieldname=False]", "tests/agents/test_influxdb_publisher_drivers.py::test_publisher_format_field_line[fieldname-1-fieldname=1i]", "tests/agents/test_influxdb_publisher_drivers.py::test_publisher_format_field_line[fieldname-4.2-fieldname=4.2]", "tests/agents/test_influxdb_publisher_drivers.py::test_publisher_format_field_line[fieldname-string-fieldname=\"string\"]" ]	[]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2022-11-02 22:12:47+00:00	bsd-2-clause	5,495
simonsobs__ocs-304	diff --git a/docs/developer/session-data.rst b/docs/developer/session-data.rst index 480a0c6..5aa89d7 100644 --- a/docs/developer/session-data.rst +++ b/docs/developer/session-data.rst @@ -147,6 +147,9 @@ This block formats the latest values for each "channel" into a dictionary and stores it in ``session.data``. +Structure and Content +--------------------- + The structure of the ``data`` entry is not strictly defined, but please observe the following guidelines: @@ -170,6 +173,30 @@ please observe the following guidelines: object to break. Changes that do take place should be announced in the change logs of new OCS versions. + +There are some restrictions on what data can be carried in +``session.data``: + +- The session.data will ultimately be converted and transported using + JSON, so some containers will be automatically converted into + JSON-compatible forms. Specifically note that: + + - dict keys will be converted to strings. + - there is no distinction between lists and tuples. + - there is no (standardized) support for non-finite floats such as + inf, -inf, or NaN. + +- If your session.data contains any NaN, they will be converted to + None (which is transported as JSON null). +- If your session.data contains inf/-inf, or other JSON-encodable + entities, OCS will raise an error. To have those transported as + None/null, you should convert inf/-inf to NaN before storing the + data in session.data. +- If your session.data includes numpy arrays (or scalars), these will + be converted to serializable types automatically using + ``numpy.tolist``. + + Client Access ------------- Once your Agent is storing information in the ``session.data`` object you diff --git a/ocs/ocs_agent.py b/ocs/ocs_agent.py index 8230daf..af5134f 100644 --- a/ocs/ocs_agent.py +++ b/ocs/ocs_agent.py @@ -17,6 +17,8 @@ from autobahn.wamp.exception import ApplicationError, TransportLost from autobahn.exception import Disconnected from .ocs_twisted import in_reactor_context +import json +import math import time import datetime import socket @@ -1055,7 +1057,9 @@ class OpSession: data : dict This is an area for the Operation code to store custom information for Control Clients to consume. See notes - below. + below. This structure will be tested for strict JSON + compliance, and certain translations performed (such as + converting NaN to None/null). messages : list A buffer of messages posted by the Operation. Each element of the list is a tuple, (timestamp, message) where timestamp @@ -1073,6 +1077,43 @@ class OpSession: advice on structuring your Agent session data. """ + def json_safe(data, check_ok=False): + """Convert data so it can be serialized and decoded on + the other end. This includes: + + - Converting numpy arrays and scalars to generic lists and + Python basic types. + + - Converting NaN to None (although crossbar handles + NaN/inf, web browsers may fail to deserialize the + invalid JSON this requires). + + In the case of inf/-inf, a ValueError is raised. + + """ + if check_ok: + output = json_safe(data) + json.dumps(output, allow_nan=False) + return output + if isinstance(data, dict): + return {k: json_safe(v) for k, v in data.items()} + if isinstance(data, (list, tuple)): + return [json_safe(x) for x in data] + if hasattr(data, 'dtype'): + # numpy arrays and scalars. + return json_safe(data.tolist()) + if isinstance(data, (str, int, bool)): + return data + if isinstance(data, float): + if math.isnan(data): + return None + if not math.isfinite(data): + raise ValueError('Session.data cannot store inf/-inf; ' + 'please convert to NaN.') + # This could still be something weird but json.dumps will + # probably reject it! + return data + return {'session_id': self.session_id, 'op_name': self.op_name, 'op_code': self.op_code.value, @@ -1080,7 +1121,7 @@ class OpSession: 'success': self.success, 'start_time': self.start_time, 'end_time': self.end_time, - 'data': self.data, + 'data': json_safe(self.data, True), 'messages': self.messages} @property	simonsobs/ocs	616865c03cfc60c526d4868b65e45800b85d033d	diff --git a/tests/test_ocs_agent.py b/tests/test_ocs_agent.py index 547ce15..d300276 100644 --- a/tests/test_ocs_agent.py +++ b/tests/test_ocs_agent.py @@ -2,6 +2,7 @@ import ocs from ocs.ocs_agent import ( OCSAgent, AgentTask, AgentProcess, ParamError, ParamHandler, param, + OpSession ) from ocs.base import OpCode @@ -10,6 +11,18 @@ from unittest.mock import MagicMock import pytest import pytest_twisted +import json +import math +import numpy as np + + +def create_session(op_name): + """Create an OpSession with a mocked app for testing.""" + mock_app = MagicMock() + session = OpSession(1, op_name, app=mock_app) + + return session + def tfunc(session, a): """Test function to call as a mocked OCS Task. We double it as the start @@ -438,6 +451,45 @@ def test_status_no_session(mock_agent): assert res[2] == {} [email protected]("key,value,expected", [('a', 1, 1), + ('b', 'string', 'string'), + ('c', [1, 2., 'blech'], [1, 2., 'blech']), + ('d', [1., 2., math.nan], [1., 2., None]), + ('e', np.int64(10), 10), + ('f', np.array([10, 20, 30]), [10, 20, 30]), + ('g', np.array([1., 2., math.nan]), [1., 2., None]), + ('h', {'x': math.nan}, {'x': None})]) +def test_session_data_good(key, value, expected): + """Test that session.data is encoded as expected and can be + JSON-serialized. + + """ + session = create_session('test_encoding') + session.data = {key: value} + + encoded = session.encoded() + print(encoded['data']) + + data = encoded['data'] + assert (key in data) + assert data[key] == expected + + json.dumps(data, allow_nan=False) + + [email protected]("key,value", [('fail_a', math.inf), + ('fail_b', [1., 2., -math.inf]), + ('fail_c', {'x': math.inf})]) +def test_session_data_bad(key, value): + """Test that invalid session.data raises an error.""" + + session = create_session('test_encoding') + session.data = {key: value} + + with pytest.raises(ValueError): + session.encoded() + + # # Tests for the @param decorator #	NaNs / infs in session.data cause trouble in ocs-web NaNs/infs are not compliant JSON, but are passed through from Agents to ocs-web anyway. This causes ocs-web to totally choke on the session.data ... which is difficult to avoid. I don't think there's a way to catch this or change how JSON is parsed by autobahn. Two possible solutions: 1. Convert NaNs/infs to None in ocs_agent.OpSession; this will produce compliant JSON. 2. Reject NaNs/infs entirely -- i.e. forbid them forcibly and raise an exception I think solution (1) is slightly better, but it should be noted that some Python based clients may be affected by this. First, one can not distinguish between NaN, inf, -inf. I think that's ok ... usually we're just trying to flag invalid data, using NaN. Another consequence of using "None" (which renders as "null" in JSON) is that lists received by Python clients will not as easily be convertible into arrays. E.g. if the agent sends [1.0, 2.0, None], and the client tries to turn that into a numpy array: ``` >>> np.array([1.0, 2.0, None]) array([1.0, 2.0, None], dtype=object) ``` (that's bad -- it's of dtype=object). But a work-around on the client side is to specify dtype: ``` >>> np.array([1.,2.,None], dtype=float) array([ 1., 2., nan]) ``` I think this is an acceptable price to pay, to have ocs-web work and also allow NaNs.	616865c03cfc60c526d4868b65e45800b85d033d	[ "tests/test_ocs_agent.py::test_session_data_good[d-value3-expected3]", "tests/test_ocs_agent.py::test_session_data_good[e-value4-10]", "tests/test_ocs_agent.py::test_session_data_good[f-value5-expected5]", "tests/test_ocs_agent.py::test_session_data_good[g-value6-expected6]", "tests/test_ocs_agent.py::test_session_data_good[h-value7-expected7]", "tests/test_ocs_agent.py::test_session_data_bad[fail_a-inf]", "tests/test_ocs_agent.py::test_session_data_bad[fail_b-value1]", "tests/test_ocs_agent.py::test_session_data_bad[fail_c-value2]" ]	[ "tests/test_ocs_agent.py::test_register_task", "tests/test_ocs_agent.py::test_register_task_w_startup", "tests/test_ocs_agent.py::test_register_task_wo_startup", "tests/test_ocs_agent.py::test_register_task_w_startup_dict", "tests/test_ocs_agent.py::test_register_process", "tests/test_ocs_agent.py::test_register_process_w_startup", "tests/test_ocs_agent.py::test_register_process_wo_startup", "tests/test_ocs_agent.py::test_register_process_w_startup_dict", "tests/test_ocs_agent.py::test_start_task", "tests/test_ocs_agent.py::test_start_process", "tests/test_ocs_agent.py::test_start_nonblocking_task", "tests/test_ocs_agent.py::test_start_task_done_status", "tests/test_ocs_agent.py::test_start_task_other_status", "tests/test_ocs_agent.py::test_start_unregistered_task", "tests/test_ocs_agent.py::test_wait", "tests/test_ocs_agent.py::test_wait_unregistered_task", "tests/test_ocs_agent.py::test_wait_idle", "tests/test_ocs_agent.py::test_wait_expired_timeout", "tests/test_ocs_agent.py::test_wait_timeout", "tests/test_ocs_agent.py::test_wait_timeout_w_error", "tests/test_ocs_agent.py::test_stop_task", "tests/test_ocs_agent.py::test_stop_unregistered_process", "tests/test_ocs_agent.py::test_stop_process", "tests/test_ocs_agent.py::test_stop_process_no_session", "tests/test_ocs_agent.py::test_abort", "tests/test_ocs_agent.py::test_status", "tests/test_ocs_agent.py::test_status_unregistered_task", "tests/test_ocs_agent.py::test_status_no_session", "tests/test_ocs_agent.py::test_session_data_good[a-1-1]", "tests/test_ocs_agent.py::test_session_data_good[b-string-string]", "tests/test_ocs_agent.py::test_session_data_good[c-value2-expected2]", "tests/test_ocs_agent.py::test_params_get", "tests/test_ocs_agent.py::test_params_strays", "tests/test_ocs_agent.py::test_params_decorator", "tests/test_ocs_agent.py::test_params_decorated" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-11-11 19:55:03+00:00	bsd-2-clause	5,496
simonsobs__ocs-332	diff --git a/ocs/ocs_agent.py b/ocs/ocs_agent.py index fc06a6e..8238a4f 100644 --- a/ocs/ocs_agent.py +++ b/ocs/ocs_agent.py @@ -1389,6 +1389,9 @@ class ParamHandler: # Free cast from int to float. if type is float and isinstance(value, int): value = float(value) + # Fix type after json conversion + if type is tuple and isinstance(value, list) and cast in [tuple, None]: + value = tuple(value) if not isinstance(value, type): raise ParamError(f"Param '{key}'={value} is not of required type ({type})") if choices is not None:	simonsobs/ocs	93cc8b2e4f174112f4db1a942dc9d0e3a1ca002e	diff --git a/tests/test_ocs_agent.py b/tests/test_ocs_agent.py index e6c1a83..be213ce 100644 --- a/tests/test_ocs_agent.py +++ b/tests/test_ocs_agent.py @@ -503,12 +503,14 @@ def test_params_get(): 'float_param': 1e8, 'numerical_string_param': '145.12', 'none_param': None, + 'tuple_param': [20., 120.], # gets cast to list by json conversion }) # Basic successes params.get('int_param', type=int) params.get('string_param', type=str) params.get('float_param', type=float) + params.get('tuple_param', type=tuple) # Tricky successes params.get('int_param', type=float)	param decorator doen't support type check on tuples For context, this came up in socs on the ACU Agent. When using the param decorator, if trying to type check a tuple, i.e.: ``` @ocs_agent.param('azpts', type=tuple) ``` Before the check occurs the input parameter value is converted to and from json, effectively casting it to a list. This results in a failed type check, for example: ``` >>> resp = client.constant_velocity_scan(azpts=(20., 120.), el=35., azvel=2., acc=2., ntimes=8, azonly=False, simulator=True) >>> print(resp) OCSReply: ERROR : Param 'azpts'=[20.0, 120.0] is not of required type (<class 'tuple'>) ``` We should check if the type is `tuple` and cast before the check within this if block: https://github.com/simonsobs/ocs/blob/076105e9613ef78745d37df3d9bf8a38ce1e28bd/ocs/ocs_agent.py#L1221	93cc8b2e4f174112f4db1a942dc9d0e3a1ca002e	[ "tests/test_ocs_agent.py::test_params_get" ]	[ "tests/test_ocs_agent.py::test_register_task", "tests/test_ocs_agent.py::test_register_task_w_startup", "tests/test_ocs_agent.py::test_register_task_wo_startup", "tests/test_ocs_agent.py::test_register_task_w_startup_dict", "tests/test_ocs_agent.py::test_register_process", "tests/test_ocs_agent.py::test_register_process_w_startup", "tests/test_ocs_agent.py::test_register_process_wo_startup", "tests/test_ocs_agent.py::test_register_process_w_startup_dict", "tests/test_ocs_agent.py::test_start_task", "tests/test_ocs_agent.py::test_start_process", "tests/test_ocs_agent.py::test_start_nonblocking_task", "tests/test_ocs_agent.py::test_start_task_done_status", "tests/test_ocs_agent.py::test_start_task_other_status", "tests/test_ocs_agent.py::test_start_unregistered_task", "tests/test_ocs_agent.py::test_wait", "tests/test_ocs_agent.py::test_wait_unregistered_task", "tests/test_ocs_agent.py::test_wait_idle", "tests/test_ocs_agent.py::test_wait_expired_timeout", "tests/test_ocs_agent.py::test_wait_timeout", "tests/test_ocs_agent.py::test_wait_timeout_w_error", "tests/test_ocs_agent.py::test_stop_task", "tests/test_ocs_agent.py::test_stop_unregistered_process", "tests/test_ocs_agent.py::test_stop_process", "tests/test_ocs_agent.py::test_stop_process_no_session", "tests/test_ocs_agent.py::test_abort", "tests/test_ocs_agent.py::test_status", "tests/test_ocs_agent.py::test_status_unregistered_task", "tests/test_ocs_agent.py::test_status_no_session", "tests/test_ocs_agent.py::test_session_data_good[a-1-1]", "tests/test_ocs_agent.py::test_session_data_good[b-string-string]", "tests/test_ocs_agent.py::test_session_data_good[c-value2-expected2]", "tests/test_ocs_agent.py::test_session_data_good[d-value3-expected3]", "tests/test_ocs_agent.py::test_session_data_good[e-value4-10]", "tests/test_ocs_agent.py::test_session_data_good[f-value5-expected5]", "tests/test_ocs_agent.py::test_session_data_good[g-value6-expected6]", "tests/test_ocs_agent.py::test_session_data_good[h-value7-expected7]", "tests/test_ocs_agent.py::test_session_data_bad[fail_a-inf]", "tests/test_ocs_agent.py::test_session_data_bad[fail_b-value1]", "tests/test_ocs_agent.py::test_session_data_bad[fail_c-value2]", "tests/test_ocs_agent.py::test_params_strays", "tests/test_ocs_agent.py::test_params_decorator", "tests/test_ocs_agent.py::test_params_decorated" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2023-05-22 21:00:34+00:00	bsd-2-clause	5,497
simonw__datasette-1736	diff --git a/datasette/app.py b/datasette/app.py index a5330458..b7b84371 100644 --- a/datasette/app.py +++ b/datasette/app.py @@ -288,9 +288,12 @@ class Datasette: self._settings = dict(DEFAULT_SETTINGS, **(settings or {})) self.renderers = {} # File extension -> (renderer, can_render) functions self.version_note = version_note - self.executor = futures.ThreadPoolExecutor( - max_workers=self.setting("num_sql_threads") - ) + if self.setting("num_sql_threads") == 0: + self.executor = None + else: + self.executor = futures.ThreadPoolExecutor( + max_workers=self.setting("num_sql_threads") + ) self.max_returned_rows = self.setting("max_returned_rows") self.sql_time_limit_ms = self.setting("sql_time_limit_ms") self.page_size = self.setting("default_page_size") @@ -862,6 +865,8 @@ class Datasette: ] def _threads(self): + if self.setting("num_sql_threads") == 0: + return {"num_threads": 0, "threads": []} threads = list(threading.enumerate()) d = { "num_threads": len(threads), diff --git a/datasette/database.py b/datasette/database.py index ba594a8c..44d32667 100644 --- a/datasette/database.py +++ b/datasette/database.py @@ -45,6 +45,9 @@ class Database: self._cached_table_counts = None self._write_thread = None self._write_queue = None + # These are used when in non-threaded mode: + self._read_connection = None + self._write_connection = None if not self.is_mutable and not self.is_memory: p = Path(path) self.hash = inspect_hash(p) @@ -134,6 +137,14 @@ class Database: return results async def execute_write_fn(self, fn, block=True): + if self.ds.executor is None: + # non-threaded mode + if self._write_connection is None: + self._write_connection = self.connect(write=True) + self.ds._prepare_connection(self._write_connection, self.name) + return fn(self._write_connection) + + # threaded mode task_id = uuid.uuid5(uuid.NAMESPACE_DNS, "datasette.io") if self._write_queue is None: self._write_queue = queue.Queue() @@ -177,6 +188,14 @@ class Database: task.reply_queue.sync_q.put(result) async def execute_fn(self, fn): + if self.ds.executor is None: + # non-threaded mode + if self._read_connection is None: + self._read_connection = self.connect() + self.ds._prepare_connection(self._read_connection, self.name) + return fn(self._read_connection) + + # threaded mode def in_thread(): conn = getattr(connections, self.name, None) if not conn: diff --git a/docs/settings.rst b/docs/settings.rst index 60c4b36d..8437fb04 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -107,6 +107,8 @@ Maximum number of threads in the thread pool Datasette uses to execute SQLite qu datasette mydatabase.db --setting num_sql_threads 10 +Setting this to 0 turns off threaded SQL queries entirely - useful for environments that do not support threading such as `Pyodide <https://pyodide.org/>`__. + .. _setting_allow_facet: allow_facet	simonw/datasette	a29c1277896b6a7905ef5441c42a37bc15f67599	diff --git a/tests/test_internals_datasette.py b/tests/test_internals_datasette.py index cc200a2d..1dc14cab 100644 --- a/tests/test_internals_datasette.py +++ b/tests/test_internals_datasette.py @@ -1,7 +1,7 @@ """ Tests for the datasette.app.Datasette class """ -from datasette.app import Datasette +from datasette.app import Datasette, Database from itsdangerous import BadSignature from .fixtures import app_client import pytest @@ -63,3 +63,15 @@ async def test_datasette_constructor(): "hash": None, } ] + + [email protected] +async def test_num_sql_threads_zero(): + ds = Datasette([], memory=True, settings={"num_sql_threads": 0}) + db = ds.add_database(Database(ds, memory_name="test_num_sql_threads_zero")) + await db.execute_write("create table t(id integer primary key)") + await db.execute_write("insert into t (id) values (1)") + response = await ds.client.get("/-/threads.json") + assert response.json() == {"num_threads": 0, "threads": []} + response2 = await ds.client.get("/test_num_sql_threads_zero/t.json?_shape=array") + assert response2.json() == [{"id": 1}]	Datasette setting to disable threading (for Pyodide) > I'm going to add a Datasette setting to disable threading entirely, designed for usage in this particular case. > > I thought about adding a new setting, then I noticed this: > > datasette mydatabase.db --setting num_sql_threads 10 > > I'm going to let users set that to `0` to disable threaded execution of SQL queries. _Originally posted by @simonw in https://github.com/simonw/datasette/issues/1733#issuecomment-1115278325_	a29c1277896b6a7905ef5441c42a37bc15f67599	[ "tests/test_internals_datasette.py::test_num_sql_threads_zero" ]	[ "tests/test_internals_datasette.py::test_get_database", "tests/test_internals_datasette.py::test_get_database_no_argument", "tests/test_internals_datasette.py::test_sign_unsign[None-hello]", "tests/test_internals_datasette.py::test_sign_unsign[None-123]", "tests/test_internals_datasette.py::test_sign_unsign[None-value2]", "tests/test_internals_datasette.py::test_sign_unsign[two-hello]", "tests/test_internals_datasette.py::test_sign_unsign[two-123]", "tests/test_internals_datasette.py::test_sign_unsign[two-value2]", "tests/test_internals_datasette.py::test_datasette_setting[base_url-/]", "tests/test_internals_datasette.py::test_datasette_setting[max_csv_mb-100]", "tests/test_internals_datasette.py::test_datasette_setting[allow_csv_stream-True]", "tests/test_internals_datasette.py::test_datasette_constructor" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-05-02 20:14:38+00:00	apache-2.0	5,498
simonw__datasette-1898	diff --git a/datasette/templates/_codemirror.html b/datasette/templates/_codemirror.html index dea4710c..c4629aeb 100644 --- a/datasette/templates/_codemirror.html +++ b/datasette/templates/_codemirror.html @@ -4,7 +4,6 @@ .cm-editor { resize: both; overflow: hidden; - min-height: 70px; width: 80%; border: 1px solid #ddd; } diff --git a/datasette/templates/_codemirror_foot.html b/datasette/templates/_codemirror_foot.html index b76d06fa..a624c8a4 100644 --- a/datasette/templates/_codemirror_foot.html +++ b/datasette/templates/_codemirror_foot.html @@ -1,86 +1,11 @@ <script> - const schema = { - "123_starts_with_digits": ["content"], - "Table With Space In Name": ["content", "pk"], - attraction_characteristic: ["name", "pk"], - binary_data: ["data"], - complex_foreign_keys: ["f1", "f2", "f3", "pk"], - compound_primary_key: ["content", "pk1", "pk2"], - compound_three_primary_keys: ["content", "pk1", "pk2", "pk3"], - custom_foreign_key_label: ["foreign_key_with_custom_label", "pk"], - facet_cities: ["id", "name"], - facetable: [ - "_city_id", - "_neighborhood", - "complex_array", - "created", - "distinct_some_null", - "n", - "on_earth", - "pk", - "planet_int", - "state", - "tags", - ], - foreign_key_references: [ - "foreign_key_compound_pk1", - "foreign_key_compound_pk2", - "foreign_key_with_blank_label", - "foreign_key_with_label", - "foreign_key_with_no_label", - "pk", - ], - infinity: ["value"], - no_primary_key: ["a", "b", "c", "content"], - primary_key_multiple_columns: ["content", "content2", "id"], - primary_key_multiple_columns_explicit_label: ["content", "content2", "id"], - roadside_attraction_characteristics: ["attraction_id", "characteristic_id"], - roadside_attractions: [ - "address", - "latitude", - "longitude", - "name", - "pk", - "url", - ], - searchable: ["name with . and spaces", "pk", "text1", "text2"], - searchable_fts: [ - "__langid", - "docid", - "name with . and spaces", - "searchable_fts", - "text1", - "text2", - ], - searchable_fts_docsize: ["docid", "size"], - searchable_fts_segdir: [ - "end_block", - "idx", - "leaves_end_block", - "level", - "root", - "start_block", - ], - searchable_fts_segments: ["block", "blockid"], - searchable_fts_stat: ["id", "value"], - searchable_tags: ["searchable_id", "tag"], - select: ["and", "group", "having", "json"], - simple_primary_key: ["content", "id"], - sortable: [ - "content", - "pk1", - "pk2", - "sortable", - "sortable_with_nulls", - "sortable_with_nulls_2", - "text", - ], - "table/with/slashes.csv": ["content", "pk"], - tags: ["tag"], - units: ["distance", "frequency", "pk"], - }; + {% if table_columns %} + const schema = {{ table_columns\|tojson(2) }}; + {% else %} + const schema = {}; + {% endif %} - window.onload = () => { + window.addEventListener("DOMContentLoaded", () => { const sqlFormat = document.querySelector("button#sql-format"); const readOnly = document.querySelector("pre#sql-query"); const sqlInput = document.querySelector("textarea#sql-editor"); @@ -113,5 +38,5 @@ }); } } - }; + }); </script> diff --git a/datasette/views/database.py b/datasette/views/database.py index 8e08c3b1..a50cf3d3 100644 --- a/datasette/views/database.py +++ b/datasette/views/database.py @@ -139,6 +139,9 @@ class DatabaseView(DataView): attached_databases = [d.name for d in await db.attached_databases()] + allow_execute_sql = await self.ds.permission_allowed( + request.actor, "execute-sql", database, default=True + ) return ( { "database": database, @@ -149,9 +152,10 @@ class DatabaseView(DataView): "hidden_count": len([t for t in tables if t["hidden"]]), "views": views, "queries": canned_queries, - "allow_execute_sql": await self.ds.permission_allowed( - request.actor, "execute-sql", database, default=True - ), + "allow_execute_sql": allow_execute_sql, + "table_columns": await _table_columns(self.ds, database) + if allow_execute_sql + else {}, }, { "database_actions": database_actions, @@ -508,6 +512,9 @@ class QueryView(DataView): "show_hide_text": show_hide_text, "show_hide_hidden": markupsafe.Markup(show_hide_hidden), "hide_sql": hide_sql, + "table_columns": await _table_columns(self.ds, database) + if allow_execute_sql + else {}, } return ( @@ -554,3 +561,15 @@ class MagicParameters(dict): return super().__getitem__(key) else: return super().__getitem__(key) + + +async def _table_columns(datasette, database_name): + internal = datasette.get_database("_internal") + result = await internal.execute( + "select table_name, name from columns where database_name = ?", + [database_name], + ) + table_columns = {} + for row in result.rows: + table_columns.setdefault(row["table_name"], []).append(row["name"]) + return table_columns	simonw/datasette	00e233d7a7f6443cb95fb5227c23580c48551cad	diff --git a/tests/test_permissions.py b/tests/test_permissions.py index 8812d0f7..0364707a 100644 --- a/tests/test_permissions.py +++ b/tests/test_permissions.py @@ -1,7 +1,9 @@ from .fixtures import app_client, assert_permissions_checked, make_app_client from bs4 import BeautifulSoup as Soup import copy +import json import pytest +import re import urllib @@ -237,24 +239,35 @@ def test_view_query(allow, expected_anon, expected_auth): ], ) def test_execute_sql(metadata): + schema_re = re.compile("const schema = ({.*?});", re.DOTALL) with make_app_client(metadata=metadata) as client: form_fragment = '<form class="sql" action="/fixtures"' # Anonymous users - should not display the form: - assert form_fragment not in client.get("/fixtures").text + anon_html = client.get("/fixtures").text + assert form_fragment not in anon_html + # And const schema should be an empty object: + assert "const schema = {};" in anon_html # This should 403: - assert 403 == client.get("/fixtures?sql=select+1").status + assert client.get("/fixtures?sql=select+1").status == 403 # ?_where= not allowed on tables: - assert 403 == client.get("/fixtures/facet_cities?_where=id=3").status + assert client.get("/fixtures/facet_cities?_where=id=3").status == 403 # But for logged in user all of these should work: cookies = {"ds_actor": client.actor_cookie({"id": "root"})} response_text = client.get("/fixtures", cookies=cookies).text + # Extract the schema= portion of the JavaScript + schema_json = schema_re.search(response_text).group(1) + schema = json.loads(schema_json) + assert set(schema["attraction_characteristic"]) == {"name", "pk"} assert form_fragment in response_text - assert 200 == client.get("/fixtures?sql=select+1", cookies=cookies).status + query_response = client.get("/fixtures?sql=select+1", cookies=cookies) + assert query_response.status == 200 + schema2 = json.loads(schema_re.search(query_response.text).group(1)) + assert set(schema2["attraction_characteristic"]) == {"name", "pk"} assert ( - 200 - == client.get("/fixtures/facet_cities?_where=id=3", cookies=cookies).status + client.get("/fixtures/facet_cities?_where=id=3", cookies=cookies).status + == 200 )	Initialize CodeMirror during DOMContentLoaded instead of onload As per https://github.com/simonw/datasette/pull/1893/files#r1023248927 this should prevent a flash between the textarea being replaced by CodeMirror.	00e233d7a7f6443cb95fb5227c23580c48551cad	[ "tests/test_permissions.py::test_execute_sql[metadata0]", "tests/test_permissions.py::test_execute_sql[metadata1]" ]	[ "tests/test_permissions.py::test_view_padlock[/-None-200-200]", "tests/test_permissions.py::test_view_padlock[/-allow1-403-403]", "tests/test_permissions.py::test_view_padlock[/-allow2-403-200]", "tests/test_permissions.py::test_view_padlock[/fixtures-None-200-200]", "tests/test_permissions.py::test_view_padlock[/fixtures-allow1-403-403]", "tests/test_permissions.py::test_view_padlock[/fixtures-allow2-403-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys-None-200-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys-allow1-403-403]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys-allow2-403-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys/a,a,a-None-200-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys/a,a,a-allow1-403-403]", "tests/test_permissions.py::test_view_padlock[/fixtures/compound_three_primary_keys/a,a,a-allow2-403-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/two-None-200-200]", "tests/test_permissions.py::test_view_padlock[/fixtures/two-allow1-403-403]", "tests/test_permissions.py::test_view_padlock[/fixtures/two-allow2-403-200]", "tests/test_permissions.py::test_view_database[None-200-200]", "tests/test_permissions.py::test_view_database[allow1-403-403]", "tests/test_permissions.py::test_view_database[allow2-403-200]", "tests/test_permissions.py::test_database_list_respects_view_database", "tests/test_permissions.py::test_database_list_respects_view_table", "tests/test_permissions.py::test_view_table[None-200-200]", "tests/test_permissions.py::test_view_table[allow1-403-403]", "tests/test_permissions.py::test_view_table[allow2-403-200]", "tests/test_permissions.py::test_table_list_respects_view_table", "tests/test_permissions.py::test_view_query[None-200-200]", "tests/test_permissions.py::test_view_query[allow1-403-403]", "tests/test_permissions.py::test_view_query[allow2-403-200]", "tests/test_permissions.py::test_query_list_respects_view_query", "tests/test_permissions.py::test_permissions_checked[/-permissions0]", "tests/test_permissions.py::test_permissions_checked[/fixtures-permissions1]", "tests/test_permissions.py::test_permissions_checked[/fixtures/facetable/1-permissions2]", "tests/test_permissions.py::test_permissions_checked[/fixtures/simple_primary_key-permissions3]", "tests/test_permissions.py::test_permissions_checked[/fixtures?sql=select+1-permissions4]", "tests/test_permissions.py::test_permissions_checked[/fixtures.db-permissions5]", "tests/test_permissions.py::test_permissions_checked[/fixtures/neighborhood_search-permissions6]", "tests/test_permissions.py::test_permissions_debug", "tests/test_permissions.py::test_allow_debug[{\"id\":\"root\"}-{}-Result:", "tests/test_permissions.py::test_allow_debug[{\"id\":\"root\"}-{\"id\":", "tests/test_permissions.py::test_allow_debug[{\"-{\"id\":", "tests/test_permissions.py::test_allow_debug[{\"id\":\"root\"}-\"*\"}-Allow", "tests/test_permissions.py::test_allow_unauthenticated[allow0-403]", "tests/test_permissions.py::test_allow_unauthenticated[allow1-200]", "tests/test_permissions.py::test_view_instance[/]", "tests/test_permissions.py::test_view_instance[/fixtures]", "tests/test_permissions.py::test_view_instance[/fixtures/facetable]", "tests/test_permissions.py::test_view_instance[/-/metadata]", "tests/test_permissions.py::test_view_instance[/-/versions]", "tests/test_permissions.py::test_view_instance[/-/plugins]", "tests/test_permissions.py::test_view_instance[/-/settings]", "tests/test_permissions.py::test_view_instance[/-/threads]", "tests/test_permissions.py::test_view_instance[/-/databases]", "tests/test_permissions.py::test_view_instance[/-/actor]", "tests/test_permissions.py::test_view_instance[/-/permissions]", "tests/test_permissions.py::test_view_instance[/-/messages]", "tests/test_permissions.py::test_view_instance[/-/patterns]", "tests/test_permissions.py::test_permissions_cascade[/-permissions0-403]", "tests/test_permissions.py::test_permissions_cascade[/-permissions1-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions2-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions3-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions4-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions5-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions6-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data-permissions7-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions8-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions9-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions10-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions11-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions12-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/binary_data/1-permissions13-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions14-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions15-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions16-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions17-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions18-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures/magic_parameters-permissions19-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures-permissions20-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures-permissions21-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures-permissions22-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures.db-permissions23-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures.db-permissions24-403]", "tests/test_permissions.py::test_permissions_cascade[/fixtures.db-permissions25-200]", "tests/test_permissions.py::test_permissions_cascade[/fixtures.db-permissions26-200]", "tests/test_permissions.py::test_padlocks_on_database_page" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-11-17 00:19:21+00:00	apache-2.0	5,499
simonw__datasette-mask-columns-4	diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index ee5ce9d..90b14a4 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -4,28 +4,26 @@ on: release: types: [created] +permissions: + contents: read + jobs: test: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.6, 3.7, 3.8, 3.9] + python-version: ["3.8", "3.9", "3.10", "3.11"] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - - uses: actions/cache@v2 - name: Configure pip caching - with: - path: ~/.cache/pip - key: ${{ runner.os }}-pip-${{ hashFiles('/setup.py') }} - restore-keys: \| - ${{ runner.os }}-pip- + cache: pip + cache-dependency-path: setup.py - name: Install dependencies run: \| - pip install -e '.[test]' + pip install '.[test]' - name: Run tests run: \| pytest @@ -33,26 +31,21 @@ jobs: runs-on: ubuntu-latest needs: [test] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - name: Set up Python - uses: actions/setup-python@v2 - with: - python-version: '3.9' - - uses: actions/cache@v2 - name: Configure pip caching + uses: actions/setup-python@v4 with: - path: ~/.cache/pip - key: ${{ runner.os }}-publish-pip-${{ hashFiles('/setup.py') }} - restore-keys: \| - ${{ runner.os }}-publish-pip- + python-version: "3.11" + cache: pip + cache-dependency-path: setup.py - name: Install dependencies run: \| - pip install setuptools wheel twine + pip install setuptools wheel twine build - name: Publish env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} run: \| - python setup.py sdist bdist_wheel + python -m build twine upload dist/* diff --git a/datasette_mask_columns/__init__.py b/datasette_mask_columns/__init__.py index f0af289..dcbd121 100644 --- a/datasette_mask_columns/__init__.py +++ b/datasette_mask_columns/__init__.py @@ -1,5 +1,5 @@ from datasette import hookimpl -import jinja2 +from markupsafe import Markup import sqlite3 @@ -31,6 +31,6 @@ def render_cell(column, table, database, datasette): masks = datasette.plugin_config("datasette-mask-columns", database=database) or {} columns_to_mask = masks.get(table) or set() if column in columns_to_mask: - return jinja2.Markup( + return Markup( '<span style="font-size: 0.8em; color: red; opacity: 0.8">REDACTED</span>' )	simonw/datasette-mask-columns	50acf9833954f230fd7938bffdbbad0f78c9af27	diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index cd7e525..e22143a 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,30 +1,27 @@ name: Test -on: [push] +on: [push, pull_request] + +permissions: + contents: read jobs: test: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.6, 3.7, 3.8, 3.9] + python-version: ["3.8", "3.9", "3.10", "3.11"] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - - uses: actions/cache@v2 - name: Configure pip caching - with: - path: ~/.cache/pip - key: ${{ runner.os }}-pip-${{ hashFiles('**/setup.py') }} - restore-keys: \| - ${{ runner.os }}-pip- + cache: pip + cache-dependency-path: setup.py - name: Install dependencies run: \| pip install -e '.[test]' - name: Run tests run: \| pytest -	Err 500 module 'jinja2' has no attribute 'Markup' At first attempt of masking columns, I get `module 'jinja2' has no attribute 'Markup'` ![Screenshot 2023-01-24 at 18 33 44](https://user-images.githubusercontent.com/116795/214352088-7015036d-828a-4fa6-9b5e-10f01d9443b6.png) ![Screenshot 2023-01-24 at 18 33 30](https://user-images.githubusercontent.com/116795/214352069-5d922a28-76d7-4765-a278-d2cf757d5f27.png)	50acf9833954f230fd7938bffdbbad0f78c9af27	[ "tests/test_mask_columns.py::test_datasette_mask_columns" ]	[]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks", "has_media", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-09-14 20:38:11+00:00	apache-2.0	5,500
simonw__sqlite-utils-142	diff --git a/docs/python-api.rst b/docs/python-api.rst index 9697fd3..5860397 100644 --- a/docs/python-api.rst +++ b/docs/python-api.rst @@ -410,7 +410,7 @@ Use it like this: "is_good_dog": True, }], pk="id", column_order=("id", "twitter", "name")) -The column types used in the ``CREATE TABLE`` statement are automatically derived from the types of data in that first batch of rows. Any additional or missing columns in subsequent batches will be ignored. +The column types used in the ``CREATE TABLE`` statement are automatically derived from the types of data in that first batch of rows. Any additional columns in subsequent batches will cause a ``sqlite3.OperationalError`` exception to be raised unless the ``alter=True`` argument is supplied, in which case the new columns will be created. The function can accept an iterator or generator of rows and will commit them according to the batch size. The default batch size is 100, but you can specify a different size using the ``batch_size`` parameter: diff --git a/sqlite_utils/db.py b/sqlite_utils/db.py index a8791c3..75599f6 100644 --- a/sqlite_utils/db.py +++ b/sqlite_utils/db.py @@ -1074,6 +1074,14 @@ class Table(Queryable): all_columns = list(sorted(all_columns)) if hash_id: all_columns.insert(0, hash_id) + else: + all_columns += [ + column + for record in chunk + for column in record + if column not in all_columns + ] + validate_column_names(all_columns) first = False # values is the list of insert data that is passed to the	simonw/sqlite-utils	ea87c2b943fdd162c42a900ac0aea5ecc2f4b9d9	diff --git a/tests/test_create.py b/tests/test_create.py index a84eb8d..fc8edc0 100644 --- a/tests/test_create.py +++ b/tests/test_create.py @@ -707,13 +707,24 @@ def test_insert_thousands_using_generator(fresh_db): assert 10000 == fresh_db["test"].count -def test_insert_thousands_ignores_extra_columns_after_first_100(fresh_db): +def test_insert_thousands_raises_exception_wtih_extra_columns_after_first_100(fresh_db): + # https://github.com/simonw/sqlite-utils/issues/139 + with pytest.raises(Exception, match="table test has no column named extra"): + fresh_db["test"].insert_all( + [{"i": i, "word": "word_{}".format(i)} for i in range(100)] + + [{"i": 101, "extra": "This extra column should cause an exception"}], + ) + + +def test_insert_thousands_adds_extra_columns_after_first_100_with_alter(fresh_db): + # https://github.com/simonw/sqlite-utils/issues/139 fresh_db["test"].insert_all( [{"i": i, "word": "word_{}".format(i)} for i in range(100)] - + [{"i": 101, "extra": "This extra column should cause an exception"}] + + [{"i": 101, "extra": "Should trigger ALTER"}], + alter=True, ) rows = fresh_db.execute_returning_dicts("select * from test where i = 101") - assert [{"i": 101, "word": None}] == rows + assert [{"i": 101, "word": None, "extra": "Should trigger ALTER"}] == rows def test_insert_ignore(fresh_db):	insert_all(..., alter=True) should work for new columns introduced after the first 100 records Is there a way to make `.insert_all()` work properly when new columns are introduced outside the first 100 records (with or without the `alter=True` argument)? I'm using `.insert_all()` to bulk insert ~3-4k records at a time and it is common for records to need to introduce new columns. However, if new columns are introduced after the first 100 records, `sqlite_utils` doesn't even raise the `OperationalError: table ... has no column named ...` exception; it just silently drops the extra data and moves on. It took me a while to find this little snippet in the [documentation for `.insert_all()`](https://sqlite-utils.readthedocs.io/en/stable/python-api.html#bulk-inserts) (it's not mentioned under [Adding columns automatically on insert/update](https://sqlite-utils.readthedocs.io/en/stable/python-api.html#bulk-inserts)): > The column types used in the CREATE TABLE statement are automatically derived from the types of data in that first batch of rows. _Any additional or missing columns in subsequent batches will be ignored._ I tried changing the `batch_size` argument to the total number of records, but it seems only to effect the number of rows that are committed at a time, and has no influence on this problem. Is there a way around this that you would suggest? It seems like it should raise an exception at least.	ea87c2b943fdd162c42a900ac0aea5ecc2f4b9d9	[ "tests/test_create.py::test_insert_thousands_raises_exception_wtih_extra_columns_after_first_100", "tests/test_create.py::test_insert_thousands_adds_extra_columns_after_first_100_with_alter" ]	[ "tests/test_create.py::test_create_table", "tests/test_create.py::test_create_table_compound_primary_key", "tests/test_create.py::test_create_table_with_bad_defaults", "tests/test_create.py::test_create_table_with_invalid_column_characters", "tests/test_create.py::test_create_table_with_defaults", "tests/test_create.py::test_create_table_with_bad_not_null", "tests/test_create.py::test_create_table_with_not_null", "tests/test_create.py::test_create_table_from_example[example0-expected_columns0]", "tests/test_create.py::test_create_table_from_example[example1-expected_columns1]", "tests/test_create.py::test_create_table_from_example[example2-expected_columns2]", "tests/test_create.py::test_create_table_from_example[example3-expected_columns3]", "tests/test_create.py::test_create_table_from_example[example4-expected_columns4]", "tests/test_create.py::test_create_table_from_example[example5-expected_columns5]", "tests/test_create.py::test_create_table_from_example_with_compound_primary_keys", "tests/test_create.py::test_create_table_with_custom_columns[insert]", "tests/test_create.py::test_create_table_with_custom_columns[upsert]", "tests/test_create.py::test_create_table_with_custom_columns[insert_all]", "tests/test_create.py::test_create_table_with_custom_columns[upsert_all]", "tests/test_create.py::test_create_table_column_order[True]", "tests/test_create.py::test_create_table_column_order[False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification0-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification1-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification2-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification3-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification4-NoObviousTable]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification5-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification6-AlterError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification7-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification0-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification1-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification2-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification3-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification4-NoObviousTable]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification5-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification6-AlterError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification7-AssertionError]", "tests/test_create.py::test_create_error_if_invalid_foreign_keys", "tests/test_create.py::test_add_column[nickname-str-None-CREATE", "tests/test_create.py::test_add_column[dob-date-None-CREATE", "tests/test_create.py::test_add_column[age-int-None-CREATE", "tests/test_create.py::test_add_column[weight-float-None-CREATE", "tests/test_create.py::test_add_column[text-TEXT-None-CREATE", "tests/test_create.py::test_add_column[integer-INTEGER-None-CREATE", "tests/test_create.py::test_add_column[float-FLOAT-None-CREATE", "tests/test_create.py::test_add_column[blob-blob-None-CREATE", "tests/test_create.py::test_add_column[default_str-None-None-CREATE", "tests/test_create.py::test_add_column[nickname-str--CREATE", "tests/test_create.py::test_add_column[nickname-str-dawg's", "tests/test_create.py::test_add_foreign_key", "tests/test_create.py::test_add_foreign_key_error_if_column_does_not_exist", "tests/test_create.py::test_add_foreign_key_error_if_other_table_does_not_exist", "tests/test_create.py::test_add_foreign_key_error_if_already_exists", "tests/test_create.py::test_add_foreign_keys", "tests/test_create.py::test_add_column_foreign_key", "tests/test_create.py::test_add_foreign_key_guess_table", "tests/test_create.py::test_index_foreign_keys", "tests/test_create.py::test_insert_row_alter_table[True-extra_data0-expected_new_columns0]", "tests/test_create.py::test_insert_row_alter_table[True-extra_data1-expected_new_columns1]", "tests/test_create.py::test_insert_row_alter_table[True-extra_data2-expected_new_columns2]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data0-expected_new_columns0]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data1-expected_new_columns1]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data2-expected_new_columns2]", "tests/test_create.py::test_insert_row_alter_table_invalid_column_characters", "tests/test_create.py::test_insert_replace_rows_alter_table[True]", "tests/test_create.py::test_insert_replace_rows_alter_table[False]", "tests/test_create.py::test_bulk_insert_more_than_999_values", "tests/test_create.py::test_error_if_more_than_999_columns[900-False]", "tests/test_create.py::test_error_if_more_than_999_columns[999-False]", "tests/test_create.py::test_error_if_more_than_999_columns[1000-True]", "tests/test_create.py::test_create_index[columns0-None-expected_index0]", "tests/test_create.py::test_create_index[columns1-None-expected_index1]", "tests/test_create.py::test_create_index[columns2-age_index-expected_index2]", "tests/test_create.py::test_create_index_unique", "tests/test_create.py::test_create_index_if_not_exists", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure0]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure1]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure2]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure3]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure4]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure5]", "tests/test_create.py::test_insert_uuid", "tests/test_create.py::test_insert_memoryview", "tests/test_create.py::test_insert_thousands_using_generator", "tests/test_create.py::test_insert_ignore", "tests/test_create.py::test_insert_hash_id", "tests/test_create.py::test_vacuum", "tests/test_create.py::test_works_with_pathlib_path", "tests/test_create.py::test_cannot_provide_both_filename_and_memory", "tests/test_create.py::test_creates_id_column", "tests/test_create.py::test_drop", "tests/test_create.py::test_drop_view", "tests/test_create.py::test_insert_all_empty_list", "tests/test_create.py::test_create_with_a_null_column", "tests/test_create.py::test_create_with_nested_bytes" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2020-08-28 22:22:57+00:00	apache-2.0	5,501
simonw__sqlite-utils-51	diff --git a/sqlite_utils/db.py b/sqlite_utils/db.py index ef55976..586014b 100644 --- a/sqlite_utils/db.py +++ b/sqlite_utils/db.py @@ -6,6 +6,8 @@ import itertools import json import pathlib +SQLITE_MAX_VARS = 999 + try: import numpy as np except ImportError: @@ -848,7 +850,17 @@ class Table: ), "Use either ignore=True or upsert=True, not both" all_columns = None first = True - for chunk in chunks(records, batch_size): + # We can only handle a max of 999 variables in a SQL insert, so + # we need to adjust the batch_size down if we have too many cols + records = iter(records) + # Peek at first record to count its columns: + first_record = next(records) + num_columns = len(first_record.keys()) + assert ( + num_columns <= SQLITE_MAX_VARS + ), "Rows can have a maximum of {} columns".format(SQLITE_MAX_VARS) + batch_size = max(1, min(batch_size, SQLITE_MAX_VARS // num_columns)) + for chunk in chunks(itertools.chain([first_record], records), batch_size): chunk = list(chunk) if first: if not self.exists:	simonw/sqlite-utils	9b7be79c86b4283f24a64f62257c918f12542997	diff --git a/tests/test_create.py b/tests/test_create.py index 222a967..71b1583 100644 --- a/tests/test_create.py +++ b/tests/test_create.py @@ -500,6 +500,42 @@ def test_upsert_rows_alter_table(fresh_db, use_table_factory): ] == list(table.rows) +def test_bulk_insert_more_than_999_values(fresh_db): + "Inserting 100 items with 11 columns should work" + fresh_db["big"].insert_all( + ( + { + "id": i + 1, + "c2": 2, + "c3": 3, + "c4": 4, + "c5": 5, + "c6": 6, + "c7": 7, + "c8": 8, + "c8": 9, + "c10": 10, + "c11": 11, + } + for i in range(100) + ), + pk="id", + ) + assert 100 == fresh_db["big"].count + + [email protected]( + "num_columns,should_error", ((900, False), (999, False), (1000, True)) +) +def test_error_if_more_than_999_columns(fresh_db, num_columns, should_error): + record = dict([("c{}".format(i), i) for i in range(num_columns)]) + if should_error: + with pytest.raises(AssertionError): + fresh_db["big"].insert(record) + else: + fresh_db["big"].insert(record) + + @pytest.mark.parametrize( "columns,index_name,expected_index", (	"Too many SQL variables" on large inserts Reported here: https://github.com/dogsheep/healthkit-to-sqlite/issues/9 It looks like there's a default limit of 999 variables - we need to be smart about that, maybe dynamically lower the batch size based on the number of columns.	9b7be79c86b4283f24a64f62257c918f12542997	[ "tests/test_create.py::test_error_if_more_than_999_columns[1000-True]" ]	[ "tests/test_create.py::test_create_table", "tests/test_create.py::test_create_table_compound_primary_key", "tests/test_create.py::test_create_table_with_bad_defaults", "tests/test_create.py::test_create_table_with_defaults", "tests/test_create.py::test_create_table_with_bad_not_null", "tests/test_create.py::test_create_table_with_not_null", "tests/test_create.py::test_create_table_from_example[example0-expected_columns0]", "tests/test_create.py::test_create_table_from_example[example1-expected_columns1]", "tests/test_create.py::test_create_table_from_example[example2-expected_columns2]", "tests/test_create.py::test_create_table_from_example_with_compound_primary_keys", "tests/test_create.py::test_create_table_column_order[True]", "tests/test_create.py::test_create_table_column_order[False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification0-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification1-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification2-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification3-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification4-NoObviousTable]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification5-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification6-AlterError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[True-foreign_key_specification7-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification0-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification1-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification2-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification3-False]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification4-NoObviousTable]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification5-AssertionError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification6-AlterError]", "tests/test_create.py::test_create_table_works_for_m2m_with_only_foreign_keys[False-foreign_key_specification7-AssertionError]", "tests/test_create.py::test_create_error_if_invalid_foreign_keys", "tests/test_create.py::test_add_column[nickname-str-None-CREATE", "tests/test_create.py::test_add_column[dob-date-None-CREATE", "tests/test_create.py::test_add_column[age-int-None-CREATE", "tests/test_create.py::test_add_column[weight-float-None-CREATE", "tests/test_create.py::test_add_column[text-TEXT-None-CREATE", "tests/test_create.py::test_add_column[integer-INTEGER-None-CREATE", "tests/test_create.py::test_add_column[float-FLOAT-None-CREATE", "tests/test_create.py::test_add_column[blob-blob-None-CREATE", "tests/test_create.py::test_add_column[default_str-None-None-CREATE", "tests/test_create.py::test_add_column[nickname-str--CREATE", "tests/test_create.py::test_add_column[nickname-str-dawg's", "tests/test_create.py::test_add_foreign_key", "tests/test_create.py::test_add_foreign_key_error_if_column_does_not_exist", "tests/test_create.py::test_add_foreign_key_error_if_other_table_does_not_exist", "tests/test_create.py::test_add_foreign_key_error_if_already_exists", "tests/test_create.py::test_add_foreign_keys", "tests/test_create.py::test_add_column_foreign_key", "tests/test_create.py::test_add_foreign_key_guess_table", "tests/test_create.py::test_index_foreign_keys", "tests/test_create.py::test_insert_row_alter_table[True-extra_data0-expected_new_columns0]", "tests/test_create.py::test_insert_row_alter_table[True-extra_data1-expected_new_columns1]", "tests/test_create.py::test_insert_row_alter_table[True-extra_data2-expected_new_columns2]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data0-expected_new_columns0]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data1-expected_new_columns1]", "tests/test_create.py::test_insert_row_alter_table[False-extra_data2-expected_new_columns2]", "tests/test_create.py::test_upsert_rows_alter_table[True]", "tests/test_create.py::test_upsert_rows_alter_table[False]", "tests/test_create.py::test_bulk_insert_more_than_999_values", "tests/test_create.py::test_error_if_more_than_999_columns[900-False]", "tests/test_create.py::test_error_if_more_than_999_columns[999-False]", "tests/test_create.py::test_create_index[columns0-None-expected_index0]", "tests/test_create.py::test_create_index[columns1-None-expected_index1]", "tests/test_create.py::test_create_index[columns2-age_index-expected_index2]", "tests/test_create.py::test_create_index_unique", "tests/test_create.py::test_create_index_if_not_exists", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure0]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure1]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure2]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure3]", "tests/test_create.py::test_insert_dictionaries_and_lists_as_json[data_structure4]", "tests/test_create.py::test_insert_thousands_using_generator", "tests/test_create.py::test_insert_thousands_ignores_extra_columns_after_first_100", "tests/test_create.py::test_insert_ignore", "tests/test_create.py::test_insert_hash_id", "tests/test_create.py::test_create_view", "tests/test_create.py::test_vacuum", "tests/test_create.py::test_works_with_pathlib_path", "tests/test_create.py::test_cannot_provide_both_filename_and_memory", "tests/test_create.py::test_creates_id_column" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks" ], "has_test_patch": true, "is_lite": false }	2019-07-28 11:30:30+00:00	apache-2.0	5,502
simpeg__simpeg-1320	diff --git a/SimPEG/regularization/base.py b/SimPEG/regularization/base.py index 1c89fb4ec..8e91c704d 100644 --- a/SimPEG/regularization/base.py +++ b/SimPEG/regularization/base.py @@ -383,6 +383,13 @@ class BaseRegularization(BaseObjectiveFunction): self._weights[key] = values self._W = None + @property + def weights_keys(self) -> list[str]: + """ + Return the keys for the existing cell weights + """ + return list(self._weights.keys()) + def remove_weights(self, key): """Removes the weights for the key provided.	simpeg/simpeg	e3cd6ed869d5e49ab817b45f1fec037ac638a68f	diff --git a/tests/base/test_regularization.py b/tests/base/test_regularization.py index ceb910baf..8e9f769b9 100644 --- a/tests/base/test_regularization.py +++ b/tests/base/test_regularization.py @@ -6,7 +6,13 @@ import inspect import discretize from SimPEG import maps, objective_function, regularization, utils -from SimPEG.regularization import BaseRegularization, WeightedLeastSquares +from SimPEG.regularization import ( + BaseRegularization, + WeightedLeastSquares, + Smallness, + SmoothnessFirstOrder, + SmoothnessSecondOrder, +) from SimPEG.objective_function import ComboObjectiveFunction @@ -657,6 +663,67 @@ class TestParent: regularization.parent = invalid_parent +class TestWeightsKeys: + """ + Test weights_keys property of regularizations + """ + + @pytest.fixture + def mesh(self): + """Sample mesh.""" + return discretize.TensorMesh([8, 7, 6]) + + def test_empty_weights(self, mesh): + """ + Test weights_keys when no weight is defined + """ + reg = BaseRegularization(mesh) + assert reg.weights_keys == [] + + def test_user_defined_weights_as_dict(self, mesh): + """ + Test weights_keys after user defined weights as dictionary + """ + weights = dict(dummy_weight=np.ones(mesh.n_cells)) + reg = BaseRegularization(mesh, weights=weights) + assert reg.weights_keys == ["dummy_weight"] + + def test_user_defined_weights_as_array(self, mesh): + """ + Test weights_keys after user defined weights as dictionary + """ + weights = np.ones(mesh.n_cells) + reg = BaseRegularization(mesh, weights=weights) + assert reg.weights_keys == ["user_weights"] + + @pytest.mark.parametrize( + "regularization_class", (Smallness, SmoothnessFirstOrder, SmoothnessSecondOrder) + ) + def test_volume_weights(self, mesh, regularization_class): + """ + Test weights_keys has "volume" by default on some regularizations + """ + reg = regularization_class(mesh) + assert reg.weights_keys == ["volume"] + + @pytest.mark.parametrize( + "regularization_class", + (BaseRegularization, Smallness, SmoothnessFirstOrder, SmoothnessSecondOrder), + ) + def test_multiple_weights(self, mesh, regularization_class): + """ + Test weights_keys has "volume" by default on some regularizations + """ + weights = dict( + dummy_weight=np.ones(mesh.n_cells), other_weights=np.ones(mesh.n_cells) + ) + reg = regularization_class(mesh, weights=weights) + if regularization_class == BaseRegularization: + assert reg.weights_keys == ["dummy_weight", "other_weights"] + else: + assert reg.weights_keys == ["dummy_weight", "other_weights", "volume"] + + class TestDeprecatedArguments: """ Test errors after simultaneously passing new and deprecated arguments.	ENH: Add method to expose weights keys in regularizations ### Proposed new feature or change: Would be nice to add a public method to regularization classes that exposes the keys of the `_weights` dictionary, so every array in it can be accessed without the need to know all the keys. This new method should live in `BaseRegularization` and could look like this: ```python @property def weights_keys(self) -> list[str]: """Return keys of cell weights.""" return list(self._weights.keys()) ``` --- This idea came up after the SimPEG Meeting of 2024-01-03.	e3cd6ed869d5e49ab817b45f1fec037ac638a68f	[ "tests/base/test_regularization.py::TestWeightsKeys::test_empty_weights", "tests/base/test_regularization.py::TestWeightsKeys::test_user_defined_weights_as_dict", "tests/base/test_regularization.py::TestWeightsKeys::test_user_defined_weights_as_array", "tests/base/test_regularization.py::TestWeightsKeys::test_volume_weights[Smallness]", "tests/base/test_regularization.py::TestWeightsKeys::test_volume_weights[SmoothnessFirstOrder]", "tests/base/test_regularization.py::TestWeightsKeys::test_volume_weights[SmoothnessSecondOrder]", "tests/base/test_regularization.py::TestWeightsKeys::test_multiple_weights[BaseRegularization]", "tests/base/test_regularization.py::TestWeightsKeys::test_multiple_weights[Smallness]", "tests/base/test_regularization.py::TestWeightsKeys::test_multiple_weights[SmoothnessFirstOrder]", "tests/base/test_regularization.py::TestWeightsKeys::test_multiple_weights[SmoothnessSecondOrder]" ]	[ "tests/base/test_regularization.py::RegularizationTests::test_active_cells_nc_residual", "tests/base/test_regularization.py::RegularizationTests::test_addition", "tests/base/test_regularization.py::RegularizationTests::test_base_regularization", "tests/base/test_regularization.py::RegularizationTests::test_linked_properties", "tests/base/test_regularization.py::RegularizationTests::test_mappings", "tests/base/test_regularization.py::RegularizationTests::test_mappings_and_cell_weights", "tests/base/test_regularization.py::RegularizationTests::test_mref_is_zero", "tests/base/test_regularization.py::RegularizationTests::test_nC_residual", "tests/base/test_regularization.py::RegularizationTests::test_property_mirroring", "tests/base/test_regularization.py::RegularizationTests::test_regularization", "tests/base/test_regularization.py::RegularizationTests::test_regularizationMesh", "tests/base/test_regularization.py::RegularizationTests::test_regularization_ActiveCells", "tests/base/test_regularization.py::RegularizationTests::test_smooth_deriv", "tests/base/test_regularization.py::RegularizationTests::test_sparse_properties", "tests/base/test_regularization.py::RegularizationTests::test_update_of_sparse_norms", "tests/base/test_regularization.py::RegularizationTests::test_vector_amplitude", "tests/base/test_regularization.py::RegularizationTests::test_weighted_least_squares", "tests/base/test_regularization.py::test_WeightedLeastSquares", "tests/base/test_regularization.py::test_cross_ref_reg[2]", "tests/base/test_regularization.py::test_cross_ref_reg[3]", "tests/base/test_regularization.py::test_cross_reg_reg_errors", "tests/base/test_regularization.py::TestParent::test_parent", "tests/base/test_regularization.py::TestParent::test_invalid_parent", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[1D-BaseRegularization]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[1D-WeightedLeastSquares]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[2D-BaseRegularization]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[2D-WeightedLeastSquares]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[3D-BaseRegularization]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_active_cells[3D-WeightedLeastSquares]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_weights[1D]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_weights[2D]", "tests/base/test_regularization.py::TestDeprecatedArguments::test_weights[3D]" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2024-01-05 21:35:20+00:00	mit	5,503
simpeg__simpeg-1334	diff --git a/SimPEG/utils/mat_utils.py b/SimPEG/utils/mat_utils.py index 5d128d997..c7b3d07fc 100644 --- a/SimPEG/utils/mat_utils.py +++ b/SimPEG/utils/mat_utils.py @@ -396,7 +396,7 @@ def coterminal(theta): \theta = 2\pi N + \gamma and N is an integer, the function returns the value of :math:`\gamma`. - The coterminal angle :math:`\gamma` is within the range :math:`[-\pi , \pi]`. + The coterminal angle :math:`\gamma` is within the range :math:`[-\pi , \pi)`. Parameters ---------- @@ -409,12 +409,8 @@ def coterminal(theta): Coterminal angles """ - sub = theta[np.abs(theta) >= np.pi] - sub = -np.sign(sub) * (2 * np.pi - np.abs(sub)) - - theta[np.abs(theta) >= np.pi] = sub - - return theta + coterminal = (theta + np.pi) % (2 * np.pi) - np.pi + return coterminal def define_plane_from_points(xyz1, xyz2, xyz3):	simpeg/simpeg	aa7c3297edec312e0e74c1c5b75399e7b8f9a3c7	diff --git a/tests/base/test_utils.py b/tests/base/test_utils.py index 541ed1642..5952b755f 100644 --- a/tests/base/test_utils.py +++ b/tests/base/test_utils.py @@ -1,4 +1,5 @@ import unittest +import pytest import numpy as np import scipy.sparse as sp import os @@ -22,6 +23,7 @@ from SimPEG.utils import ( Counter, download, surface2ind_topo, + coterminal, ) import discretize @@ -342,5 +344,35 @@ class TestDownload(unittest.TestCase): shutil.rmtree(os.path.expanduser("./test_url")) +class TestCoterminalAngle: + """ + Tests for the coterminal function + """ + + @pytest.mark.parametrize( + "coterminal_angle", + (1 / 4 * np.pi, 3 / 4 * np.pi, -3 / 4 * np.pi, -1 / 4 * np.pi), + ids=("pi/4", "3/4 pi", "-3/4 pi", "-pi/4"), + ) + def test_angles_in_quadrants(self, coterminal_angle): + """ + Test coterminal for angles in each quadrant + """ + angles = np.array([2 * n * np.pi + coterminal_angle for n in range(-3, 4)]) + np.testing.assert_allclose(coterminal(angles), coterminal_angle) + + @pytest.mark.parametrize( + "coterminal_angle", + (0, np.pi / 2, -np.pi, -np.pi / 2), + ids=("0", "pi/2", "-pi", "-pi/2"), + ) + def test_right_angles(self, coterminal_angle): + """ + Test coterminal for right angles + """ + angles = np.array([2 * n * np.pi + coterminal_angle for n in range(-3, 4)]) + np.testing.assert_allclose(coterminal(angles), coterminal_angle) + + if __name__ == "__main__": unittest.main()	Unintended behaviour of `SimPEG.utils.coterminal`? ## Question If we pass angles equal to $-\pi$ or $\pi$ we'll get $\pi$ or $-\pi$, respectively. This means that the function will return floats with different signs for this pair of coterminal angles ($-\pi$ and $\pi$ are coterminal angles). For example: ```python import numpy as np from SimPEG.utils import coterminal angles = np.array([-np.pi, np.pi]) print(coterminal(angles)) ``` ``` [ 3.14159265 -3.14159265] ``` This may cause issues when trying to regularize such angles: if one cell has a vector with angle $-\pi$, and the next one has an angle of $\pi$, then a smoothness regularization on angles will introduce a penalty (because the difference between these two floats is non-zero), while it shouldn't because there's no change in angles between the two cells. Is this the intended behaviour? ## Idea Wouldn't be better if the function returns angles in the interval $(-\pi, \pi]$ ? In that case, passing $-\pi$ and $\pi$ would return the same value for both of them. Therefore it should have the following behaviour for the previous example: ```python import numpy as np from SimPEG.utils import coterminal angles = np.array([-np.pi, np.pi]) print(coterminal(angles)) ``` ``` [ 3.14159265 3.14159265] ``` ## If we decide to go forward with this If we want to change the behaviour of this function I think we should: 1. Modify the implementation of `SimPEG.utils.coterminal` accordingly. 2. Improve the docstrings to reflect the new change. Probably the $\gamma$ angle could be defined as belonging to $(-\pi, \pi]$. 3. Add test functions that check the function under these circumstances: - Passing $-\pi$, $\pi$, $3\pi$, $-3\pi$ should return the same angle: $\pi$ - Are angles within the interval not being modified? - Are angles outisde the interval being correctly brought to that interval?	aa7c3297edec312e0e74c1c5b75399e7b8f9a3c7	[ "tests/base/test_utils.py::TestCoterminalAngle::test_angles_in_quadrants[pi/4]", "tests/base/test_utils.py::TestCoterminalAngle::test_angles_in_quadrants[3/4", "tests/base/test_utils.py::TestCoterminalAngle::test_angles_in_quadrants[-3/4", "tests/base/test_utils.py::TestCoterminalAngle::test_angles_in_quadrants[-pi/4]", "tests/base/test_utils.py::TestCoterminalAngle::test_right_angles[0]", "tests/base/test_utils.py::TestCoterminalAngle::test_right_angles[pi/2]", "tests/base/test_utils.py::TestCoterminalAngle::test_right_angles[-pi]", "tests/base/test_utils.py::TestCoterminalAngle::test_right_angles[-pi/2]" ]	[ "tests/base/test_utils.py::TestCounter::test_simpleFail", "tests/base/test_utils.py::TestSequenceFunctions::test_TensorType2D", "tests/base/test_utils.py::TestSequenceFunctions::test_TensorType3D", "tests/base/test_utils.py::TestSequenceFunctions::test_as_array_n_by_dim", "tests/base/test_utils.py::TestSequenceFunctions::test_ind2sub", "tests/base/test_utils.py::TestSequenceFunctions::test_index_cube_2D", "tests/base/test_utils.py::TestSequenceFunctions::test_index_cube_3D", "tests/base/test_utils.py::TestSequenceFunctions::test_invXXXBlockDiagonal", "tests/base/test_utils.py::TestSequenceFunctions::test_inverse_property_tensor2D", "tests/base/test_utils.py::TestSequenceFunctions::test_inverse_property_tensor3D", "tests/base/test_utils.py::TestSequenceFunctions::test_mkvc1", "tests/base/test_utils.py::TestSequenceFunctions::test_mkvc2", "tests/base/test_utils.py::TestSequenceFunctions::test_mkvc3", "tests/base/test_utils.py::TestSequenceFunctions::test_ndgrid_2D", "tests/base/test_utils.py::TestSequenceFunctions::test_ndgrid_3D", "tests/base/test_utils.py::TestSequenceFunctions::test_sub2ind", "tests/base/test_utils.py::TestDiagEst::testProbing" ]	{ "failed_lite_validators": [], "has_test_patch": true, "is_lite": true }	2024-01-21 20:12:02+00:00	mit	5,504
simphony__simphony-remote-117	diff --git a/remoteappmanager/db/csv_db.py b/remoteappmanager/db/csv_db.py index 99227dc..7c8d6d9 100644 --- a/remoteappmanager/db/csv_db.py +++ b/remoteappmanager/db/csv_db.py @@ -44,6 +44,7 @@ Note """ import csv +import hashlib from remoteappmanager.db.interfaces import ( ABCAccounting, ABCApplication, ABCApplicationPolicy) @@ -132,9 +133,11 @@ class CSVAccounting(ABCAccounting): # Save the configuration # Note that we don't filter existing duplicate entry + mapping_id_prehex = '_'.join((application.image, str(count))) self.all_records.setdefault(username, []).append( - ('_'.join((application.image, str(count))), - application, application_policy)) + (hashlib.md5(mapping_id_prehex.encode('u8')).hexdigest(), + application, + application_policy)) def get_user_by_name(self, user_name): """ Return a CSVUser for a given user_name, or return diff --git a/remoteappmanager/restresources/container.py b/remoteappmanager/restresources/container.py index 864e1fd..3191c6b 100644 --- a/remoteappmanager/restresources/container.py +++ b/remoteappmanager/restresources/container.py @@ -202,7 +202,7 @@ class Container(Resource): server_url = "http://{}:{}{}/".format( container.ip, container.port, - url_path_join(self.application.command_line_config.base_url, + url_path_join(self.application.command_line_config.base_urlpath, container.urlpath)) yield _wait_for_http_server_2xx(	simphony/simphony-remote	61ec23ffe44463cbc41f6fa54b4247963093ed79	diff --git a/tests/db/abc_test_interfaces.py b/tests/db/abc_test_interfaces.py index 9aa7dd5..7ac0201 100644 --- a/tests/db/abc_test_interfaces.py +++ b/tests/db/abc_test_interfaces.py @@ -1,5 +1,6 @@ from abc import abstractmethod, ABCMeta import inspect as _inspect +import string from remoteappmanager.db.interfaces import ABCApplication, ABCApplicationPolicy @@ -77,3 +78,22 @@ class ABCTestDatabaseInterface(metaclass=ABCMeta): if temp: self.fail('These are not expected: {}'.format(temp)) + + def test_get_apps_for_user_mapping_id_rest_compliant(self): + ''' Test if the mapping_id to be rest identifier complient ''' + allowed_chars = set(string.ascii_letters+string.digits) + accounting = self.create_accounting() + + for user in self.create_expected_users(): + # should be ((mapping_id, Application, ApplicationPolicy), + # (mapping_id, Application, ApplicationPolicy) ... ) + actual_id_configs = accounting.get_apps_for_user(user) + + if not actual_id_configs: + continue + + for mapping_id, _, _ in actual_id_configs: + self.assertFalse( + set(mapping_id) - allowed_chars, + "mapping id should contain these characters only: {} " + "Got : {}".format(allowed_chars, mapping_id)) diff --git a/tests/db/test_interfaces.py b/tests/db/test_interfaces.py index 6b4b3a8..02ced52 100644 --- a/tests/db/test_interfaces.py +++ b/tests/db/test_interfaces.py @@ -27,9 +27,9 @@ class Accounting(ABCAccounting): return User(name=username) def get_apps_for_user(self, user): - return (('mapping_id1', + return (('abc1', Application(image=user.name+'1'), ApplicationPolicy()), - ('mapping_id2', + ('abc2', Application(image=user.name+'2'), ApplicationPolicy())) diff --git a/tests/restmodel/test_container.py b/tests/restmodel/test_container.py index f9862e9..ba87141 100644 --- a/tests/restmodel/test_container.py +++ b/tests/restmodel/test_container.py @@ -29,7 +29,7 @@ class TestContainer(AsyncHTTPTestCase): app.file_config = Mock() app.file_config.network_timeout = 5 app.command_line_config = Mock() - app.command_line_config.base_url = "http://127.0.0.1:8000/" + app.command_line_config.base_urlpath = "/" app.reverse_proxy = Mock() app.reverse_proxy.add_container = mock_coro_factory() app.reverse_proxy.remove_container = mock_coro_factory()	remoteapprest app start error due to unfound `base_url` ``` (simremote)kit@kit-virtual-machine:jupyterhub$ remoteapprest app start 629b1d86d69bfb4b400dfee204f5e3a0 [W 160718 10:37:39 container:154] HOME (None) is not available for kit [I 160718 10:37:39 container_manager:218] Got container image: simphonyproject/simphonic-mayavi [I 2016-07-18 10:37:39.576 JupyterHub log:100] 200 GET /hub/api/authorizations/cookie/jupyter-hub-token-kit/[secret] ([email protected]) 8.24ms [E 160718 10:37:39 container_manager:417] Container 'remoteexec-kit-629b1d86d69bfb4b400dfee204f5e3a0' is gone [I 160718 10:37:39 container_manager:260] Mounting these volumes: /appdata/image_name/common -> /appdata [I 160718 10:37:39 container_manager:293] Created container 'remoteexec-kit-629b1d86d69bfb4b400dfee204f5e3a0' (id: 2dcdd6621f8f736322969b25449d5c75566cf617632cb9481f865aeaf919b863) from image simphonyproject/simphonic-mayavi [I 160718 10:37:39 container_manager:330] Started container 'remoteexec-kit-629b1d86d69bfb4b400dfee204f5e3a0' (id: 2dcdd6621f8f736322969b25449d5c75566cf617632cb9481f865aeaf919b863). Exported port reachable at 127.0.0.1:32769 [E 160718 10:37:39 rest_handler:71] Internal error during POST operation on containers Traceback (most recent call last): File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/rest/rest_handler.py", line 60, in post resource_id = yield res_handler.create(data) File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1015, in run value = future.result() File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/concurrent.py", line 237, in result raise_exc_info(self._exc_info) File "<string>", line 3, in raise_exc_info File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1021, in run yielded = self.gen.throw(*exc_info) File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/restresources/container.py", line 38, in create yield self._wait_for_container_ready(container) File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1015, in run value = future.result() File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/concurrent.py", line 237, in result raise_exc_info(self._exc_info) File "<string>", line 3, in raise_exc_info File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 285, in wrapper yielded = next(result) File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/restresources/container.py", line 205, in _wait_for_container_ready url_path_join(self.application.command_line_config.base_url, AttributeError: 'CommandLineConfig' object has no attribute 'base_url' ```	61ec23ffe44463cbc41f6fa54b4247963093ed79	[ "tests/restmodel/test_container.py::TestContainer::test_create" ]	[ "tests/db/test_interfaces.py::TestDatabaseInterface::test_get_apps_for_user", "tests/db/test_interfaces.py::TestDatabaseInterface::test_get_apps_for_user_mapping_id_rest_compliant", "tests/db/test_interfaces.py::TestDatabaseInterface::test_get_user_by_name", "tests/restmodel/test_container.py::TestContainer::test_delete", "tests/restmodel/test_container.py::TestContainer::test_items", "tests/restmodel/test_container.py::TestContainer::test_retrieve" ]	{ "failed_lite_validators": [ "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2016-07-18 09:48:08+00:00	bsd-3-clause	5,505
simphony__simphony-remote-120	diff --git a/remoteappmanager/application.py b/remoteappmanager/application.py index 7666a2a..abfcecf 100644 --- a/remoteappmanager/application.py +++ b/remoteappmanager/application.py @@ -19,6 +19,7 @@ from remoteappmanager.services.reverse_proxy import ReverseProxy from remoteappmanager import rest from remoteappmanager.rest import registry from remoteappmanager import restresources +from remoteappmanager.utils import url_path_join class Application(web.Application, LoggingMixin): @@ -103,7 +104,6 @@ class Application(web.Application, LoggingMixin): return ReverseProxy( endpoint_url=self.command_line_config.proxy_api_url, auth_token=auth_token, - base_urlpath=self.command_line_config.base_urlpath ) @default("hub") @@ -149,6 +149,16 @@ class Application(web.Application, LoggingMixin): tornado.ioloop.IOLoop.current().start() + def urlpath_for_object(self, object): + """ + Resolves the absolute url path of a given object. + The object must have a urlpath property. + """ + + return url_path_join( + self.command_line_config.base_urlpath, + object.urlpath) + # Private def _get_handlers(self): """Returns the registered handlers""" diff --git a/remoteappmanager/handlers/home_handler.py b/remoteappmanager/handlers/home_handler.py index c1648de..8936f28 100644 --- a/remoteappmanager/handlers/home_handler.py +++ b/remoteappmanager/handlers/home_handler.py @@ -112,7 +112,11 @@ class HomeHandler(BaseHandler): # The server is up and running. Now contact the proxy and add # the container url to it. - urlpath = yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register( + urlpath, container.host_url) # Redirect the user self.log.info('Redirecting to {}'.format(urlpath)) @@ -136,7 +140,11 @@ class HomeHandler(BaseHandler): yield self._wait_for_container_ready(container) # in case the reverse proxy is not already set up - urlpath = yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register( + urlpath, container.host_url) self.log.info('Redirecting to {}'.format(urlpath)) self.redirect(urlpath) @@ -155,13 +163,10 @@ class HomeHandler(BaseHandler): self.finish("Unable to view the application") return - try: - yield app.reverse_proxy.remove_container(container) - except HTTPError as http_error: - # The reverse proxy may be absent to start with - if http_error.code != 404: - raise http_error - + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield app.reverse_proxy.unregister(urlpath) yield container_manager.stop_and_remove_container(container.docker_id) # We don't have fancy stuff at the moment to change the button, so diff --git a/remoteappmanager/restresources/container.py b/remoteappmanager/restresources/container.py index 3191c6b..cbf224a 100644 --- a/remoteappmanager/restresources/container.py +++ b/remoteappmanager/restresources/container.py @@ -36,7 +36,11 @@ class Container(Resource): policy, mapping_id) yield self._wait_for_container_ready(container) - yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register(urlpath, + container.host_url) return container.url_id @@ -56,13 +60,15 @@ class Container(Resource): @gen.coroutine def delete(self, identifier): """Stop the container.""" - app = self.application container = yield self._container_from_url_id(identifier) if not container: raise exceptions.NotFound() - yield app.reverse_proxy.remove_container(container) - yield app.container_manager.stop_and_remove_container( + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.unregister(urlpath) + yield self.application.container_manager.stop_and_remove_container( container.docker_id) @gen.coroutine diff --git a/remoteappmanager/services/reverse_proxy.py b/remoteappmanager/services/reverse_proxy.py index 64807c3..4bff151 100644 --- a/remoteappmanager/services/reverse_proxy.py +++ b/remoteappmanager/services/reverse_proxy.py @@ -5,7 +5,6 @@ from jupyterhub import orm as jupyterhub_orm from traitlets import HasTraits, Unicode from remoteappmanager.logging.logging_mixin import LoggingMixin -from remoteappmanager.utils import url_path_join class ReverseProxy(LoggingMixin, HasTraits): @@ -17,9 +16,6 @@ class ReverseProxy(LoggingMixin, HasTraits): #: The authorization token to authenticate the request auth_token = Unicode() - #: The prefix for the url added to the passed object relative .url() - base_urlpath = Unicode('/') - def __init__(self, args, kwargs): """Initializes the reverse proxy connection object.""" super().__init__(args, **kwargs) @@ -31,73 +27,59 @@ class ReverseProxy(LoggingMixin, HasTraits): api_server=_server_from_url(self.endpoint_url) ) - self.log.info("Reverse proxy setup on {} with base url {}".format( + self.log.info("Reverse proxy setup on {}".format( self.endpoint_url, - self.base_urlpath )) @gen.coroutine - def remove_container(self, container): - """Removes a container from the reverse proxy at the associated url. + def register(self, urlpath, target_host_url): + """Register a given urlpath to redirect to a different target host. + The operation is idempotent. Parameters ---------- - container : remoteappmanager.docker.container.Container - A container object. + urlpath: str + The absolute path of the url (e.g. /my/internal/service/)" + + target_host_url: + The host to redirect to, e.g. http://127.0.0.1:31233/service/ """ - proxy = self._reverse_proxy + self.log.info("Registering {} redirection to {}".format( + urlpath, + target_host_url)) - urlpath = url_path_join(self.base_urlpath, container.urlpath) - self.log.info("Unregistering url {} to {} on reverse proxy.".format( + yield self._reverse_proxy.api_request( urlpath, - container.host_url - )) + method='POST', + body=dict( + target=target_host_url, + ) + ) + + @gen.coroutine + def unregister(self, urlpath): + """Unregisters a previously registered urlpath. + If the urlpath is not found in the reverse proxy, it will not raise + an error, but it will log the unexpected circumstance. + + Parameters + ---------- + urlpath: str + The absolute path of the url (e.g. /my/internal/service/" + """ + self.log.info("Deregistering {} redirection".format(urlpath)) try: - yield proxy.api_request(urlpath, method='DELETE') + yield self._reverse_proxy.api_request(urlpath, method='DELETE') except httpclient.HTTPError as e: if e.code == 404: self.log.warning("Could not find urlpath {} when removing" " container. In any case, the reverse proxy" " does not map the url. Continuing".format( - urlpath)) + urlpath)) else: raise e - @gen.coroutine - def add_container(self, container): - """Adds the url associated to a given container on the reverse proxy. - - Parameters - ---------- - container : remoteappmanager.docker.container.Container - A container object. - - Returns - ------- - urlpath : str - The absolute url path of the container as registered on the reverse - proxy. - """ - - proxy = self._reverse_proxy - urlpath = url_path_join(self.base_urlpath, container.urlpath) - - self.log.info("Registering url {} to {} on reverse proxy.".format( - urlpath, - container.host_url - )) - - yield proxy.api_request( - urlpath, - method='POST', - body=dict( - target=container.host_url, - ) - ) - - return urlpath - def _server_from_url(url): """Creates a orm.Server from a given url"""	simphony/simphony-remote	05225db5d853d5b00bc1135763affe0f9935ea99	diff --git a/tests/handlers/test_home_handler.py b/tests/handlers/test_home_handler.py index 95807b8..596b8db 100644 --- a/tests/handlers/test_home_handler.py +++ b/tests/handlers/test_home_handler.py @@ -7,10 +7,10 @@ from remoteappmanager.docker.container import Container from remoteappmanager.docker.container_manager import ContainerManager from remoteappmanager.docker.image import Image from remoteappmanager.services.hub import Hub -from remoteappmanager.services.reverse_proxy import ReverseProxy from remoteappmanager.application import Application from tests import utils +from tests.mock.mock_reverse_proxy import MockReverseProxy from tests.temp_mixin import TempMixin @@ -38,9 +38,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): file_config.accounting_kwargs = {'url': "sqlite:///"+sqlite_file_path} app = Application(command_line_config, file_config) - app.reverse_proxy = mock.Mock(spec=ReverseProxy) - app.reverse_proxy.add_container = utils.mock_coro_factory("/") - app.reverse_proxy.remove_container = utils.mock_coro_factory() + app.reverse_proxy = MockReverseProxy() app.hub = mock.Mock(spec=Hub) app.hub.verify_token = utils.mock_coro_factory({ 'pending': None, @@ -107,7 +105,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): ".HomeHandler" ".redirect") as redirect: - self.assertFalse(self._app.reverse_proxy.add_container.called) + self.assertFalse(self._app.reverse_proxy.register.called) self.fetch("/user/username/", method="POST", headers={ @@ -115,7 +113,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.add_container.called) + self.assertTrue(self._app.reverse_proxy.register.called) self.assertTrue(redirect.called) def test_post_failed_auth(self): @@ -156,7 +154,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.remove_container.called) + self.assertTrue(self._app.reverse_proxy.unregister.called) self.assertTrue(redirect.called) def test_post_view(self): @@ -184,5 +182,5 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.add_container.called) + self.assertTrue(self._app.reverse_proxy.register.called) self.assertTrue(redirect.called) diff --git a/tests/mock/__init__.py b/tests/mock/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/mock/mock_reverse_proxy.py b/tests/mock/mock_reverse_proxy.py new file mode 100644 index 0000000..ee624a6 --- /dev/null +++ b/tests/mock/mock_reverse_proxy.py @@ -0,0 +1,15 @@ +from unittest import mock + +from remoteappmanager.services.reverse_proxy import ReverseProxy +from tests import utils + + +def MockReverseProxy(): + """Constructor. Returns a mock reverse proxy implementation. + Named as a class for potential future expansion in mock implementation.""" + + mock_revproxy = mock.Mock(spec=ReverseProxy) + mock_revproxy.register = utils.mock_coro_factory("/") + mock_revproxy.unregister = utils.mock_coro_factory() + + return mock_revproxy diff --git a/tests/restmodel/test_container.py b/tests/restmodel/test_container.py index ba87141..7ae9a96 100644 --- a/tests/restmodel/test_container.py +++ b/tests/restmodel/test_container.py @@ -2,6 +2,7 @@ from unittest.mock import Mock, patch from remoteappmanager.restresources import Container from tests import utils +from tests.mock.mock_reverse_proxy import MockReverseProxy from tornado import web, escape from remoteappmanager import rest @@ -28,11 +29,10 @@ class TestContainer(AsyncHTTPTestCase): app = web.Application(handlers=handlers) app.file_config = Mock() app.file_config.network_timeout = 5 + app.urlpath_for_object = Mock(return_value="/urlpath_for_object/") app.command_line_config = Mock() app.command_line_config.base_urlpath = "/" - app.reverse_proxy = Mock() - app.reverse_proxy.add_container = mock_coro_factory() - app.reverse_proxy.remove_container = mock_coro_factory() + app.reverse_proxy = MockReverseProxy() container = Mock() container.urlpath = "containers/12345" container.url_id = "12345" diff --git a/tests/services/test_reverse_proxy.py b/tests/services/test_reverse_proxy.py index 39ff093..71b0298 100644 --- a/tests/services/test_reverse_proxy.py +++ b/tests/services/test_reverse_proxy.py @@ -4,8 +4,6 @@ from jupyterhub import orm from remoteappmanager.services.reverse_proxy import ReverseProxy from tornado import gen, testing -from remoteappmanager.docker.container import Container - class TestReverseProxy(testing.AsyncTestCase): @testing.gen_test @@ -22,11 +20,11 @@ class TestReverseProxy(testing.AsyncTestCase): reverse_proxy._reverse_proxy = Mock(spec=orm.Proxy) reverse_proxy._reverse_proxy.api_request = mock_api_request - container = Container(docker_id="12345", base_urlpath="/foo/") - yield reverse_proxy.add_container(container) + yield reverse_proxy.register("/hello/from/me/", + "http://localhost:12312/") self.assertEqual(coroutine_out["kwargs"]["method"], "POST") - yield reverse_proxy.remove_container(container) + yield reverse_proxy.unregister("/hello/from/me/") self.assertEqual(coroutine_out["kwargs"]["method"], "DELETE")	Simplify the ReverseProxy A reverse proxy does not really need to have remove and add container methods. All that is necessary is to map urls.	05225db5d853d5b00bc1135763affe0f9935ea99	[ "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_start", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_stop", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_view", "tests/restmodel/test_container.py::TestContainer::test_create", "tests/restmodel/test_container.py::TestContainer::test_delete" ]	[ "tests/handlers/test_home_handler.py::TestHomeHandler::test_failed_auth", "tests/handlers/test_home_handler.py::TestHomeHandler::test_home", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_failed_auth", "tests/restmodel/test_container.py::TestContainer::test_items", "tests/restmodel/test_container.py::TestContainer::test_retrieve" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-07-18 12:29:36+00:00	bsd-3-clause	5,506
simphony__simphony-remote-121	diff --git a/remoteappmanager/application.py b/remoteappmanager/application.py index 7666a2a..abfcecf 100644 --- a/remoteappmanager/application.py +++ b/remoteappmanager/application.py @@ -19,6 +19,7 @@ from remoteappmanager.services.reverse_proxy import ReverseProxy from remoteappmanager import rest from remoteappmanager.rest import registry from remoteappmanager import restresources +from remoteappmanager.utils import url_path_join class Application(web.Application, LoggingMixin): @@ -103,7 +104,6 @@ class Application(web.Application, LoggingMixin): return ReverseProxy( endpoint_url=self.command_line_config.proxy_api_url, auth_token=auth_token, - base_urlpath=self.command_line_config.base_urlpath ) @default("hub") @@ -149,6 +149,16 @@ class Application(web.Application, LoggingMixin): tornado.ioloop.IOLoop.current().start() + def urlpath_for_object(self, object): + """ + Resolves the absolute url path of a given object. + The object must have a urlpath property. + """ + + return url_path_join( + self.command_line_config.base_urlpath, + object.urlpath) + # Private def _get_handlers(self): """Returns the registered handlers""" diff --git a/remoteappmanager/handlers/home_handler.py b/remoteappmanager/handlers/home_handler.py index c1648de..c21824b 100644 --- a/remoteappmanager/handlers/home_handler.py +++ b/remoteappmanager/handlers/home_handler.py @@ -1,6 +1,5 @@ import socket import os -import uuid from datetime import timedelta import errno @@ -45,12 +44,11 @@ class HomeHandler(BaseHandler): try: yield handler(options) - except Exception as e: + except Exception as exc: # Create a random reference number for support - ref = str(uuid.uuid1()) - self.log.exception("Failed with POST action: {0}. {1} " - "Ref: {2}".format( - action, str(e), ref)) + ref = self.log.issue( + "Failed with POST action {}".format(action), + exc) images_info = yield self._get_images_info() @@ -63,7 +61,7 @@ class HomeHandler(BaseHandler): images_info=images_info, error_message=message.format( action=action, - error_type=type(e).__name__, + error_type=type(exc).__name__, ref=ref)) # Subhandling after post @@ -112,7 +110,11 @@ class HomeHandler(BaseHandler): # The server is up and running. Now contact the proxy and add # the container url to it. - urlpath = yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register( + urlpath, container.host_url) # Redirect the user self.log.info('Redirecting to {}'.format(urlpath)) @@ -136,7 +138,11 @@ class HomeHandler(BaseHandler): yield self._wait_for_container_ready(container) # in case the reverse proxy is not already set up - urlpath = yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register( + urlpath, container.host_url) self.log.info('Redirecting to {}'.format(urlpath)) self.redirect(urlpath) @@ -155,13 +161,10 @@ class HomeHandler(BaseHandler): self.finish("Unable to view the application") return - try: - yield app.reverse_proxy.remove_container(container) - except HTTPError as http_error: - # The reverse proxy may be absent to start with - if http_error.code != 404: - raise http_error - + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield app.reverse_proxy.unregister(urlpath) yield container_manager.stop_and_remove_container(container.docker_id) # We don't have fancy stuff at the moment to change the button, so diff --git a/remoteappmanager/logging/logging_mixin.py b/remoteappmanager/logging/logging_mixin.py index 6339a43..fddc6f6 100644 --- a/remoteappmanager/logging/logging_mixin.py +++ b/remoteappmanager/logging/logging_mixin.py @@ -1,3 +1,6 @@ +import uuid +import types + from traitlets import ( HasTraits, Instance, @@ -5,6 +8,25 @@ from traitlets import ( ) +def issue(self, message, exc=None): + """Accepts a message that will be logged with an additional reference + code for easy log lookup. + + The identifier will be returned for inclusion in user-visible + error messages. + """ + ref = str(uuid.uuid1()) + + if exc is None: + err_message = "{}. Ref: {}".format(message, ref) + else: + err_message = "{} : {}. Ref: {}".format( + message, str(exc), ref) + + self.error(err_message) + return ref + + class LoggingMixin(HasTraits): """A HasTrait class that provides logging. Used as a mixin. """ @@ -13,5 +35,9 @@ class LoggingMixin(HasTraits): @default('log') def _log_default(self): - from traitlets import log - return log.get_logger() + from tornado.log import app_log + + # monkey patch the logger to provide an additional method that handles + # issues + app_log.issue = types.MethodType(issue, app_log) + return app_log diff --git a/remoteappmanager/restresources/container.py b/remoteappmanager/restresources/container.py index 3191c6b..cbf224a 100644 --- a/remoteappmanager/restresources/container.py +++ b/remoteappmanager/restresources/container.py @@ -36,7 +36,11 @@ class Container(Resource): policy, mapping_id) yield self._wait_for_container_ready(container) - yield self.application.reverse_proxy.add_container(container) + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.register(urlpath, + container.host_url) return container.url_id @@ -56,13 +60,15 @@ class Container(Resource): @gen.coroutine def delete(self, identifier): """Stop the container.""" - app = self.application container = yield self._container_from_url_id(identifier) if not container: raise exceptions.NotFound() - yield app.reverse_proxy.remove_container(container) - yield app.container_manager.stop_and_remove_container( + urlpath = url_path_join( + self.application.command_line_config.base_urlpath, + container.urlpath) + yield self.application.reverse_proxy.unregister(urlpath) + yield self.application.container_manager.stop_and_remove_container( container.docker_id) @gen.coroutine diff --git a/remoteappmanager/services/reverse_proxy.py b/remoteappmanager/services/reverse_proxy.py index 64807c3..4bff151 100644 --- a/remoteappmanager/services/reverse_proxy.py +++ b/remoteappmanager/services/reverse_proxy.py @@ -5,7 +5,6 @@ from jupyterhub import orm as jupyterhub_orm from traitlets import HasTraits, Unicode from remoteappmanager.logging.logging_mixin import LoggingMixin -from remoteappmanager.utils import url_path_join class ReverseProxy(LoggingMixin, HasTraits): @@ -17,9 +16,6 @@ class ReverseProxy(LoggingMixin, HasTraits): #: The authorization token to authenticate the request auth_token = Unicode() - #: The prefix for the url added to the passed object relative .url() - base_urlpath = Unicode('/') - def __init__(self, args, kwargs): """Initializes the reverse proxy connection object.""" super().__init__(args, **kwargs) @@ -31,73 +27,59 @@ class ReverseProxy(LoggingMixin, HasTraits): api_server=_server_from_url(self.endpoint_url) ) - self.log.info("Reverse proxy setup on {} with base url {}".format( + self.log.info("Reverse proxy setup on {}".format( self.endpoint_url, - self.base_urlpath )) @gen.coroutine - def remove_container(self, container): - """Removes a container from the reverse proxy at the associated url. + def register(self, urlpath, target_host_url): + """Register a given urlpath to redirect to a different target host. + The operation is idempotent. Parameters ---------- - container : remoteappmanager.docker.container.Container - A container object. + urlpath: str + The absolute path of the url (e.g. /my/internal/service/)" + + target_host_url: + The host to redirect to, e.g. http://127.0.0.1:31233/service/ """ - proxy = self._reverse_proxy + self.log.info("Registering {} redirection to {}".format( + urlpath, + target_host_url)) - urlpath = url_path_join(self.base_urlpath, container.urlpath) - self.log.info("Unregistering url {} to {} on reverse proxy.".format( + yield self._reverse_proxy.api_request( urlpath, - container.host_url - )) + method='POST', + body=dict( + target=target_host_url, + ) + ) + + @gen.coroutine + def unregister(self, urlpath): + """Unregisters a previously registered urlpath. + If the urlpath is not found in the reverse proxy, it will not raise + an error, but it will log the unexpected circumstance. + + Parameters + ---------- + urlpath: str + The absolute path of the url (e.g. /my/internal/service/" + """ + self.log.info("Deregistering {} redirection".format(urlpath)) try: - yield proxy.api_request(urlpath, method='DELETE') + yield self._reverse_proxy.api_request(urlpath, method='DELETE') except httpclient.HTTPError as e: if e.code == 404: self.log.warning("Could not find urlpath {} when removing" " container. In any case, the reverse proxy" " does not map the url. Continuing".format( - urlpath)) + urlpath)) else: raise e - @gen.coroutine - def add_container(self, container): - """Adds the url associated to a given container on the reverse proxy. - - Parameters - ---------- - container : remoteappmanager.docker.container.Container - A container object. - - Returns - ------- - urlpath : str - The absolute url path of the container as registered on the reverse - proxy. - """ - - proxy = self._reverse_proxy - urlpath = url_path_join(self.base_urlpath, container.urlpath) - - self.log.info("Registering url {} to {} on reverse proxy.".format( - urlpath, - container.host_url - )) - - yield proxy.api_request( - urlpath, - method='POST', - body=dict( - target=container.host_url, - ) - ) - - return urlpath - def _server_from_url(url): """Creates a orm.Server from a given url"""	simphony/simphony-remote	05225db5d853d5b00bc1135763affe0f9935ea99	diff --git a/tests/handlers/test_home_handler.py b/tests/handlers/test_home_handler.py index 95807b8..596b8db 100644 --- a/tests/handlers/test_home_handler.py +++ b/tests/handlers/test_home_handler.py @@ -7,10 +7,10 @@ from remoteappmanager.docker.container import Container from remoteappmanager.docker.container_manager import ContainerManager from remoteappmanager.docker.image import Image from remoteappmanager.services.hub import Hub -from remoteappmanager.services.reverse_proxy import ReverseProxy from remoteappmanager.application import Application from tests import utils +from tests.mock.mock_reverse_proxy import MockReverseProxy from tests.temp_mixin import TempMixin @@ -38,9 +38,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): file_config.accounting_kwargs = {'url': "sqlite:///"+sqlite_file_path} app = Application(command_line_config, file_config) - app.reverse_proxy = mock.Mock(spec=ReverseProxy) - app.reverse_proxy.add_container = utils.mock_coro_factory("/") - app.reverse_proxy.remove_container = utils.mock_coro_factory() + app.reverse_proxy = MockReverseProxy() app.hub = mock.Mock(spec=Hub) app.hub.verify_token = utils.mock_coro_factory({ 'pending': None, @@ -107,7 +105,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): ".HomeHandler" ".redirect") as redirect: - self.assertFalse(self._app.reverse_proxy.add_container.called) + self.assertFalse(self._app.reverse_proxy.register.called) self.fetch("/user/username/", method="POST", headers={ @@ -115,7 +113,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.add_container.called) + self.assertTrue(self._app.reverse_proxy.register.called) self.assertTrue(redirect.called) def test_post_failed_auth(self): @@ -156,7 +154,7 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.remove_container.called) + self.assertTrue(self._app.reverse_proxy.unregister.called) self.assertTrue(redirect.called) def test_post_view(self): @@ -184,5 +182,5 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): }, body=body) - self.assertTrue(self._app.reverse_proxy.add_container.called) + self.assertTrue(self._app.reverse_proxy.register.called) self.assertTrue(redirect.called) diff --git a/tests/logging/__init__.py b/tests/logging/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/logging/test_logging_mixin.py b/tests/logging/test_logging_mixin.py new file mode 100644 index 0000000..833562e --- /dev/null +++ b/tests/logging/test_logging_mixin.py @@ -0,0 +1,19 @@ +import unittest +from unittest import mock + +from remoteappmanager.logging.logging_mixin import LoggingMixin + + +class Logged(LoggingMixin): + pass + + +class TestLoggingMixin(unittest.TestCase): + def test_issue(self): + l = Logged() + with mock.patch("tornado.log.app_log.error") as mock_error: + ref = l.log.issue("hello") + self.assertIn("hello. Ref: "+str(ref), mock_error.call_args[0][0]) + ref = l.log.issue("hello", Exception("Boom!")) + self.assertIn("hello : Boom!. Ref: "+str(ref), + mock_error.call_args[0][0]) diff --git a/tests/mock/__init__.py b/tests/mock/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/mock/mock_reverse_proxy.py b/tests/mock/mock_reverse_proxy.py new file mode 100644 index 0000000..ee624a6 --- /dev/null +++ b/tests/mock/mock_reverse_proxy.py @@ -0,0 +1,15 @@ +from unittest import mock + +from remoteappmanager.services.reverse_proxy import ReverseProxy +from tests import utils + + +def MockReverseProxy(): + """Constructor. Returns a mock reverse proxy implementation. + Named as a class for potential future expansion in mock implementation.""" + + mock_revproxy = mock.Mock(spec=ReverseProxy) + mock_revproxy.register = utils.mock_coro_factory("/") + mock_revproxy.unregister = utils.mock_coro_factory() + + return mock_revproxy diff --git a/tests/restmodel/test_container.py b/tests/restmodel/test_container.py index ba87141..7ae9a96 100644 --- a/tests/restmodel/test_container.py +++ b/tests/restmodel/test_container.py @@ -2,6 +2,7 @@ from unittest.mock import Mock, patch from remoteappmanager.restresources import Container from tests import utils +from tests.mock.mock_reverse_proxy import MockReverseProxy from tornado import web, escape from remoteappmanager import rest @@ -28,11 +29,10 @@ class TestContainer(AsyncHTTPTestCase): app = web.Application(handlers=handlers) app.file_config = Mock() app.file_config.network_timeout = 5 + app.urlpath_for_object = Mock(return_value="/urlpath_for_object/") app.command_line_config = Mock() app.command_line_config.base_urlpath = "/" - app.reverse_proxy = Mock() - app.reverse_proxy.add_container = mock_coro_factory() - app.reverse_proxy.remove_container = mock_coro_factory() + app.reverse_proxy = MockReverseProxy() container = Mock() container.urlpath = "containers/12345" container.url_id = "12345" diff --git a/tests/services/test_reverse_proxy.py b/tests/services/test_reverse_proxy.py index 39ff093..71b0298 100644 --- a/tests/services/test_reverse_proxy.py +++ b/tests/services/test_reverse_proxy.py @@ -4,8 +4,6 @@ from jupyterhub import orm from remoteappmanager.services.reverse_proxy import ReverseProxy from tornado import gen, testing -from remoteappmanager.docker.container import Container - class TestReverseProxy(testing.AsyncTestCase): @testing.gen_test @@ -22,11 +20,11 @@ class TestReverseProxy(testing.AsyncTestCase): reverse_proxy._reverse_proxy = Mock(spec=orm.Proxy) reverse_proxy._reverse_proxy.api_request = mock_api_request - container = Container(docker_id="12345", base_urlpath="/foo/") - yield reverse_proxy.add_container(container) + yield reverse_proxy.register("/hello/from/me/", + "http://localhost:12312/") self.assertEqual(coroutine_out["kwargs"]["method"], "POST") - yield reverse_proxy.remove_container(container) + yield reverse_proxy.unregister("/hello/from/me/") self.assertEqual(coroutine_out["kwargs"]["method"], "DELETE")	Formalise error handling with the logger and the refnumber for the issue Currently when an error takes place in a number of places we generate a `refnumber` that can be displayed in the user when an error takes place. This `refnumber` is at the same time logged next to the related error. This will help to pinpoint the place in the logs where a specific error (reported by a user) took place and simplify debugging. To achieve this I would suggest one of the following: - Wrap the python `Logger` logging functions so that they generate a refnumber, pass it to the logger and then return it to the caller. - Provide a generic `log(self, level, msg, args, *kwargs)` function in the `BaseHandler` that will generate the refnumber pass it to a python logger and return it. I think that the second implementation is simpler and easier to test.	05225db5d853d5b00bc1135763affe0f9935ea99	[ "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_start", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_stop", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_view", "tests/logging/test_logging_mixin.py::TestLoggingMixin::test_issue", "tests/restmodel/test_container.py::TestContainer::test_create", "tests/restmodel/test_container.py::TestContainer::test_delete" ]	[ "tests/handlers/test_home_handler.py::TestHomeHandler::test_failed_auth", "tests/handlers/test_home_handler.py::TestHomeHandler::test_home", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_failed_auth", "tests/restmodel/test_container.py::TestContainer::test_items", "tests/restmodel/test_container.py::TestContainer::test_retrieve" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-07-18 13:14:05+00:00	bsd-3-clause	5,507
simphony__simphony-remote-123	diff --git a/remoteappmanager/cli/remoteappdb/__main__.py b/remoteappmanager/cli/remoteappdb/__main__.py index ab76d4f..e4144ab 100644 --- a/remoteappmanager/cli/remoteappdb/__main__.py +++ b/remoteappmanager/cli/remoteappdb/__main__.py @@ -94,6 +94,24 @@ def get_docker_client(): return client +def is_sqlitedb_url(db_url): + """Returns True if the url refers to a sqlite database""" + return db_url.startswith("sqlite:///") + + +def sqlitedb_present(db_url): + """Checks if the db url is present. + Remote urls are always assumed to be present, so this method + concerns mostly sqlite databases.""" + + if not db_url.startswith("sqlite:///"): + raise ValueError("db_url {} does not refer to a " + "sqlite database.".format(db_url)) + + path = sqlite_url_to_path(db_url) + return os.path.exists(path) + + class RemoteAppDBContext(object): def __init__(self, db_url): db_url = normalise_to_url(db_url) @@ -120,11 +138,9 @@ def init(ctx): db_url = db.url # Check if the database already exists - if db_url.startswith("sqlite:///"): - path = sqlite_url_to_path(db_url) - if os.path.exists(path): - raise click.UsageError("Refusing to overwrite database " - "at {}".format(db_url)) + if is_sqlitedb_url(db_url) and sqlitedb_present(db_url): + raise click.UsageError("Refusing to overwrite database " + "at {}".format(db_url)) db.reset() @@ -133,9 +149,18 @@ def init(ctx): @cli.group() -def user(): [email protected]_context +def user(ctx): """Subcommand to manage users.""" - pass + db = ctx.obj.db + db_url = db.url + + # sqlite driver for sqlalchemy creates an empty file on commit as a side + # effect. We don't want this creation to happen, so before attempting + # the creation we stop short if we already find out that the file is + # missing and cannot possibly be initialized. + if is_sqlitedb_url(db_url) and not sqlitedb_present(db_url): + raise click.UsageError("Could not find database at {}".format(db_url)) @user.command() @@ -228,9 +253,14 @@ def list(ctx, no_decoration, show_apps): @cli.group() -def app(): [email protected]_context +def app(ctx): """Subcommand to manage applications.""" - pass + db = ctx.obj.db + db_url = db.url + + if is_sqlitedb_url(db_url) and not sqlitedb_present(db_url): + raise click.UsageError("Could not find database at {}".format(db_url)) @app.command() # noqa diff --git a/remoteappmanager/handlers/home_handler.py b/remoteappmanager/handlers/home_handler.py index c21824b..7d5ce97 100644 --- a/remoteappmanager/handlers/home_handler.py +++ b/remoteappmanager/handlers/home_handler.py @@ -131,8 +131,10 @@ class HomeHandler(BaseHandler): container_manager = self.application.container_manager container = yield container_manager.container_from_url_id(url_id) if not container: - self.finish("Unable to view the application") - return + self.log.warning("Could not find container for url_id {}".format( + url_id + )) + raise ValueError("Unable to view container for specified url_id") # make sure the container is actually running and working yield self._wait_for_container_ready(container) @@ -158,8 +160,10 @@ class HomeHandler(BaseHandler): container = yield container_manager.container_from_url_id(url_id) if not container: - self.finish("Unable to view the application") - return + self.log.warning("Could not find container for url_id {}".format( + url_id + )) + raise ValueError("Unable to view container for specified url_id") urlpath = url_path_join( self.application.command_line_config.base_urlpath, diff --git a/remoteappmanager/spawner.py b/remoteappmanager/spawner.py index a226fa9..8637879 100644 --- a/remoteappmanager/spawner.py +++ b/remoteappmanager/spawner.py @@ -20,7 +20,7 @@ class Spawner(LocalProcessSpawner): proxy = Any() #: The path of the configuration file for the cmd executable - config_file_path = Unicode() + config_file_path = Unicode(config=True) def __init__(self, kwargs): super().__init__(kwargs)	simphony/simphony-remote	ae2c07cdf3906952600c57b4439d57d7ff4b2cc1	diff --git a/tests/cli/test_remoteappdb.py b/tests/cli/test_remoteappdb.py index 004a99e..57db987 100644 --- a/tests/cli/test_remoteappdb.py +++ b/tests/cli/test_remoteappdb.py @@ -25,9 +25,23 @@ class TestRemoteAppDbCLI(TempMixin, unittest.TestCase): return result.exit_code, result.output + def test_is_sqlitedb_url(self): + self.assertTrue(remoteappdb.is_sqlitedb_url("sqlite:///foo.db")) + self.assertFalse(remoteappdb.is_sqlitedb_url("whatever:///foo.db")) + + def test_sqlite_present(self): + self.assertTrue(remoteappdb.sqlitedb_present( + "sqlite:///"+self.db)) + self.assertFalse(remoteappdb.sqlitedb_present( + "sqlite:///"+self.db+"whatever")) + def test_init_command(self): self.assertTrue(os.path.exists(self.db)) + # This should fail because the database is already present + exit_code, output = self._remoteappdb("init") + self.assertNotEqual(exit_code, 0) + def test_user_create(self): _, out = self._remoteappdb("user create foo") self.assertEqual(out, "1\n") @@ -174,3 +188,13 @@ class TestRemoteAppDbCLI(TempMixin, unittest.TestCase): _, out = self._remoteappdb("user list --show-apps --no-decoration") self.assertEqual(len(out.split('\n')), 2) self.assertNotIn("myapp", out) + + def test_commands_noinit(self): + # Remove the conveniently setup database + os.remove(self.db) + + exit_code, out = self._remoteappdb("user create foo") + self.assertNotEqual(exit_code, 0) + + exit_code, out = self._remoteappdb("app create foo") + self.assertNotEqual(exit_code, 0) diff --git a/tests/handlers/test_home_handler.py b/tests/handlers/test_home_handler.py index 596b8db..7a49d7f 100644 --- a/tests/handlers/test_home_handler.py +++ b/tests/handlers/test_home_handler.py @@ -184,3 +184,34 @@ class TestHomeHandler(TempMixin, utils.AsyncHTTPTestCase): self.assertTrue(self._app.reverse_proxy.register.called) self.assertTrue(redirect.called) + + def test_container_manager_does_not_return_container(self): + self._app.container_manager.container_from_url_id = \ + utils.mock_coro_factory(None) + res = self.fetch( + "/user/username/", + method="POST", + headers={ + "Cookie": "jupyter-hub-token-username=foo" + }, + body=urllib.parse.urlencode({ + 'action': 'view', + 'url_id': '12345' + }) + ) + + self.assertIn("ValueError", str(res.body)) + + res = self.fetch( + "/user/username/", + method="POST", + headers={ + "Cookie": "jupyter-hub-token-username=foo" + }, + body=urllib.parse.urlencode({ + 'action': 'stop', + 'url_id': '12345' + }) + ) + + self.assertIn("ValueError", str(res.body))	HomeHandler should not 'finish' in View and Stop but raise Let view and stop raise and then the HomeHandler.post will handle the logging. https://github.com/simphony/simphony-remote/blob/98ee374756694ef1855a9d38d78d3561ec6cc54e/remoteappmanager/handlers/home_handler.py#L155 https://github.com/simphony/simphony-remote/blob/98ee374756694ef1855a9d38d78d3561ec6cc54e/remoteappmanager/handlers/home_handler.py#L132	ae2c07cdf3906952600c57b4439d57d7ff4b2cc1	[ "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_commands_noinit", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_is_sqlitedb_url", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_sqlite_present", "tests/handlers/test_home_handler.py::TestHomeHandler::test_container_manager_does_not_return_container" ]	[ "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_with_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_wrong_name_with_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_wrong_name_without_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_init_command", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_user_create", "tests/handlers/test_home_handler.py::TestHomeHandler::test_failed_auth", "tests/handlers/test_home_handler.py::TestHomeHandler::test_home", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_failed_auth", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_start", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_stop", "tests/handlers/test_home_handler.py::TestHomeHandler::test_post_view" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-07-18 14:47:10+00:00	bsd-3-clause	5,508
simphony__simphony-remote-124	diff --git a/remoteappmanager/cli/remoteappdb/__main__.py b/remoteappmanager/cli/remoteappdb/__main__.py index ab76d4f..e4144ab 100644 --- a/remoteappmanager/cli/remoteappdb/__main__.py +++ b/remoteappmanager/cli/remoteappdb/__main__.py @@ -94,6 +94,24 @@ def get_docker_client(): return client +def is_sqlitedb_url(db_url): + """Returns True if the url refers to a sqlite database""" + return db_url.startswith("sqlite:///") + + +def sqlitedb_present(db_url): + """Checks if the db url is present. + Remote urls are always assumed to be present, so this method + concerns mostly sqlite databases.""" + + if not db_url.startswith("sqlite:///"): + raise ValueError("db_url {} does not refer to a " + "sqlite database.".format(db_url)) + + path = sqlite_url_to_path(db_url) + return os.path.exists(path) + + class RemoteAppDBContext(object): def __init__(self, db_url): db_url = normalise_to_url(db_url) @@ -120,11 +138,9 @@ def init(ctx): db_url = db.url # Check if the database already exists - if db_url.startswith("sqlite:///"): - path = sqlite_url_to_path(db_url) - if os.path.exists(path): - raise click.UsageError("Refusing to overwrite database " - "at {}".format(db_url)) + if is_sqlitedb_url(db_url) and sqlitedb_present(db_url): + raise click.UsageError("Refusing to overwrite database " + "at {}".format(db_url)) db.reset() @@ -133,9 +149,18 @@ def init(ctx): @cli.group() -def user(): [email protected]_context +def user(ctx): """Subcommand to manage users.""" - pass + db = ctx.obj.db + db_url = db.url + + # sqlite driver for sqlalchemy creates an empty file on commit as a side + # effect. We don't want this creation to happen, so before attempting + # the creation we stop short if we already find out that the file is + # missing and cannot possibly be initialized. + if is_sqlitedb_url(db_url) and not sqlitedb_present(db_url): + raise click.UsageError("Could not find database at {}".format(db_url)) @user.command() @@ -228,9 +253,14 @@ def list(ctx, no_decoration, show_apps): @cli.group() -def app(): [email protected]_context +def app(ctx): """Subcommand to manage applications.""" - pass + db = ctx.obj.db + db_url = db.url + + if is_sqlitedb_url(db_url) and not sqlitedb_present(db_url): + raise click.UsageError("Could not find database at {}".format(db_url)) @app.command() # noqa diff --git a/remoteappmanager/spawner.py b/remoteappmanager/spawner.py index a226fa9..8637879 100644 --- a/remoteappmanager/spawner.py +++ b/remoteappmanager/spawner.py @@ -20,7 +20,7 @@ class Spawner(LocalProcessSpawner): proxy = Any() #: The path of the configuration file for the cmd executable - config_file_path = Unicode() + config_file_path = Unicode(config=True) def __init__(self, kwargs): super().__init__(kwargs)	simphony/simphony-remote	ae2c07cdf3906952600c57b4439d57d7ff4b2cc1	diff --git a/tests/cli/test_remoteappdb.py b/tests/cli/test_remoteappdb.py index 004a99e..57db987 100644 --- a/tests/cli/test_remoteappdb.py +++ b/tests/cli/test_remoteappdb.py @@ -25,9 +25,23 @@ class TestRemoteAppDbCLI(TempMixin, unittest.TestCase): return result.exit_code, result.output + def test_is_sqlitedb_url(self): + self.assertTrue(remoteappdb.is_sqlitedb_url("sqlite:///foo.db")) + self.assertFalse(remoteappdb.is_sqlitedb_url("whatever:///foo.db")) + + def test_sqlite_present(self): + self.assertTrue(remoteappdb.sqlitedb_present( + "sqlite:///"+self.db)) + self.assertFalse(remoteappdb.sqlitedb_present( + "sqlite:///"+self.db+"whatever")) + def test_init_command(self): self.assertTrue(os.path.exists(self.db)) + # This should fail because the database is already present + exit_code, output = self._remoteappdb("init") + self.assertNotEqual(exit_code, 0) + def test_user_create(self): _, out = self._remoteappdb("user create foo") self.assertEqual(out, "1\n") @@ -174,3 +188,13 @@ class TestRemoteAppDbCLI(TempMixin, unittest.TestCase): _, out = self._remoteappdb("user list --show-apps --no-decoration") self.assertEqual(len(out.split('\n')), 2) self.assertNotIn("myapp", out) + + def test_commands_noinit(self): + # Remove the conveniently setup database + os.remove(self.db) + + exit_code, out = self._remoteappdb("user create foo") + self.assertNotEqual(exit_code, 0) + + exit_code, out = self._remoteappdb("app create foo") + self.assertNotEqual(exit_code, 0)	System user Spawner's config_file_path is not configurable Which is not consistent with the VirtualUserSpawner and the documentation. All it needs is a `config=True` in the traitlet's meta.	ae2c07cdf3906952600c57b4439d57d7ff4b2cc1	[ "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_commands_noinit", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_is_sqlitedb_url", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_sqlite_present" ]	[ "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_with_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_wrong_name_with_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_app_create_wrong_name_without_verify", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_init_command", "tests/cli/test_remoteappdb.py::TestRemoteAppDbCLI::test_user_create" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-07-19 08:16:24+00:00	bsd-3-clause	5,509
simphony__simphony-remote-133	diff --git a/remoteappmanager/docker/container.py b/remoteappmanager/docker/container.py index cb484b0..f92304c 100644 --- a/remoteappmanager/docker/container.py +++ b/remoteappmanager/docker/container.py @@ -56,7 +56,7 @@ class Container(HasTraits): ")>") @classmethod - def from_docker_containers_dict(cls, docker_dict): + def from_docker_dict(cls, docker_dict): """Returns a Container object with the info given by a docker Client. @@ -74,24 +74,66 @@ class Container(HasTraits): >>> # containers is a list of dict >>> containers = docker.Client().containers() - >>> Container.from_docker_containers_dict(containers[0]) + >>> Container.from_docker_dict(containers[0]) """ - ip = cls.ip.default_value - port = cls.port.default_value - - if docker_dict.get('Ports'): - ip = docker_dict['Ports'][0].get('IP', ip) - port = docker_dict['Ports'][0].get('PublicPort', port) - - labels = docker_dict.get("Labels", {}) - mapping_id = labels.get(SIMPHONY_NS+"mapping_id", "") - url_id = labels.get(SIMPHONY_NS+"url_id", "") - - return cls(docker_id=docker_dict.get('Id', ''), - name=docker_dict.get('Names', ('',))[0], - image_name=docker_dict.get('Image', ''), - image_id=docker_dict.get('ImageID', ''), - mapping_id=mapping_id, - ip=ip, - port=port, - url_id=url_id) + + is_inspect_container_output = ("Config" in docker_dict) + + kwargs = dict( + docker_id=docker_dict.get('Id') or '', + ip=cls.ip.default_value, + port=cls.port.default_value, + ) + + if is_inspect_container_output: + # It's a client.inspect_container() output + + network_settings = docker_dict.get("NetworkSettings") or {} + ports = network_settings.get("Ports") or {} + # unfortunately, in the case of a running container, we don't have + # a single list. Instead, we have a dict where the keys are + # the "port identifier" (e.g. 8888/tcp) and the value is a list + # of dictionaries. + # We assume that we only have one, as above + if len(ports) > 1: + raise ValueError("Container Ports had more than one element.") + + if len(ports): + port_values = list(ports.values())[0] + if len(port_values) > 1: + raise ValueError("Container Ports values had " + "more than one element.") + + if len(port_values): + kwargs["ip"] = port_values[0].get("HostIp") or kwargs["ip"] + kwargs["port"] = int(port_values[0].get("HostPort") or + kwargs["port"]) + + config = docker_dict.get("Config", {}) + labels = config.get("Labels") + + kwargs["image_name"] = config.get("Image") + kwargs["image_id"] = docker_dict["Image"] + kwargs["name"] = docker_dict["Name"] + else: + # It's a client.containers() output, so we have different rules. + ports = docker_dict.get('Ports') or [] + if len(ports) > 1: + raise ValueError("Container Ports had more than one element.") + + if len(ports): + kwargs["ip"] = ports[0].get('IP') or kwargs["ip"] + kwargs["port"] = int(ports[0].get('PublicPort') or + kwargs["port"]) + + labels = docker_dict.get("Labels") or {} + + kwargs["image_name"] = docker_dict.get('Image') or '' + kwargs["image_id"] = docker_dict.get("ImageID") or '' + names = docker_dict.get("Names") or ('', ) + kwargs["name"] = names[0] + + kwargs["mapping_id"] = labels.get(SIMPHONY_NS+"mapping_id") or "" + kwargs["url_id"] = labels.get(SIMPHONY_NS+"url_id") or "" + + return cls(**kwargs) diff --git a/remoteappmanager/docker/container_manager.py b/remoteappmanager/docker/container_manager.py index 1db82e5..7b85d53 100644 --- a/remoteappmanager/docker/container_manager.py +++ b/remoteappmanager/docker/container_manager.py @@ -166,8 +166,8 @@ class ContainerManager(LoggingMixin): infos = yield self.docker_client.containers(filters=filters) for info in infos: try: - container = Container.from_docker_containers_dict(info) - except Exception: + container = Container.from_docker_dict(info) + except ValueError: self.log.exception("Unable to parse container info.") continue diff --git a/remoteappmanager/restresources/container.py b/remoteappmanager/restresources/container.py index c3cd5e8..64bf36a 100644 --- a/remoteappmanager/restresources/container.py +++ b/remoteappmanager/restresources/container.py @@ -118,7 +118,7 @@ class Container(Resource): if not container_dict: return None - return DockerContainer.from_docker_containers_dict(container_dict[0]) + return DockerContainer.from_docker_dict(container_dict[0]) @gen.coroutine def _start_container(self, user_name, app, policy, mapping_id):	simphony/simphony-remote	af0203df6cb3232a28b50fa1023baf73e234aa6d	diff --git a/tests/docker/test_container.py b/tests/docker/test_container.py index f5223dc..249eac9 100644 --- a/tests/docker/test_container.py +++ b/tests/docker/test_container.py @@ -1,7 +1,8 @@ from unittest import TestCase from remoteappmanager.docker.container import Container -from tests.utils import assert_containers_equal +from tests.utils import assert_containers_equal, \ + mock_docker_client_with_running_containers class TestContainer(TestCase): @@ -42,7 +43,7 @@ class TestContainer(TestCase): 'Status': 'Up 56 minutes'} # Container with public port - actual = Container.from_docker_containers_dict(container_dict) + actual = Container.from_docker_dict(container_dict) expected = Container( docker_id='248e45e717cd740ae763a1c565', name='/remoteexec-user-empty-ubuntu_3Alatest', @@ -75,7 +76,7 @@ class TestContainer(TestCase): 'Status': 'Up 56 minutes'} # Container without public port - actual = Container.from_docker_containers_dict(container_dict) + actual = Container.from_docker_dict(container_dict) expected = Container( docker_id='812c765d0549be0ab831ae8348', name='/remoteexec-user-empty-ubuntu_3Alatest', @@ -86,3 +87,57 @@ class TestContainer(TestCase): url_id="8e2fe66d5de74db9bbab50c0d2f92b33") assert_containers_equal(self, actual, expected) + + def test_from_docker_dict_inspect_container(self): + client = mock_docker_client_with_running_containers() + actual = Container.from_docker_dict( + client.inspect_container("id")) + + expected = Container( + docker_id='35d88fe321c3d575ec3be64f54b8967ef49c0dc92395bf4c1e511ed3e6ae0c79', # noqa + name='/remoteexec-username-simphonyproject_2Fsimphonic-mayavi_5F1', + image_name='simphonyproject/simphonic-mayavi', + image_id='sha256:f43b749341ee37b56e7bd8d99f09629f311aaec35a8045a39185b5659edef169', # noqa + ip='0.0.0.0', + port=32782, + url_id="55555555555555555555555555555555", + mapping_id="1c08c87878634e90af43d799e90f61d2") + + assert_containers_equal(self, actual, expected) + + def test_multiple_ports_data(self): + client = mock_docker_client_with_running_containers() + docker_dict = client.inspect_container("id") + docker_dict["NetworkSettings"]["Ports"] = { + '8888/tcp': [{'HostIp': '0.0.0.0', 'HostPort': '32782'}], + '8889/tcp': [{'HostIp': '0.0.0.0', 'HostPort': '32783'}] + } + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) + + docker_dict["NetworkSettings"]["Ports"] = { + '8888/tcp': [ + {'HostIp': '0.0.0.0', 'HostPort': '32782'}, + {'HostIp': '0.0.0.0', 'HostPort': '32783'} + ] + } + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) + + docker_dict = client.containers()[0] + docker_dict["Ports"] = [ + { + 'IP': '0.0.0.0', + 'PublicIP': 34567, + 'PrivatePort': 22, + 'Type': 'tcp' + }, + { + 'IP': '0.0.0.0', + 'PublicIP': 34562, + 'PrivatePort': 21, + 'Type': 'tcp' + } + ] + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) diff --git a/tests/utils.py b/tests/utils.py index 9279636..2556bcd 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -110,6 +110,30 @@ def mock_docker_client_with_running_containers(): 'State': 'running', 'Status': 'Up About an hour'}, ] + client.inspect_container.return_value = { + 'Config': { + 'Image': 'simphonyproject/simphonic-mayavi', + 'Labels': {'eu.simphony-project.docker.description': 'Ubuntu ' + 'machine ' + 'with ' + 'simphony ' + 'framework ' + 'preinstalled', + 'eu.simphony-project.docker.mapping_id': '1c08c87878634e90af43d799e90f61d2', + 'eu.simphony-project.docker.ui_name': 'Simphony ' + 'Framework ' + '(w/ mayavi)', + 'eu.simphony-project.docker.url_id': '55555555555555555555555555555555', + 'eu.simphony-project.docker.user': 'username'}, + }, + 'Id': '35d88fe321c3d575ec3be64f54b8967ef49c0dc92395bf4c1e511ed3e6ae0c79', + 'Image': 'sha256:f43b749341ee37b56e7bd8d99f09629f311aaec35a8045a39185b5659edef169', + 'Name': '/remoteexec-username-simphonyproject_2Fsimphonic-mayavi_5F1', + 'NetworkSettings': { + 'Ports': {'8888/tcp': [{'HostIp': '0.0.0.0', + 'HostPort': '32782'}]}, + }, + } return client	Image.from_docker_dict and Container.from_docker_dict take inconsistent inputs `Container.from_docker_dict` assumes inputs from the result of `docker.client.containers` but not `docker.client.inspect_container`, whilst `Image.from_docker_dict` can take inputs from both. It would be useful and neater if `Container.from_docker_dict` accepts input from the result `docker.client.inspect_container` as well. Follows #79	af0203df6cb3232a28b50fa1023baf73e234aa6d	[ "tests/docker/test_container.py::TestContainer::test_from_docker_dict_inspect_container", "tests/docker/test_container.py::TestContainer::test_from_docker_dict_with_public_port", "tests/docker/test_container.py::TestContainer::test_from_docker_dict_without_public_port", "tests/docker/test_container.py::TestContainer::test_multiple_ports_data" ]	[ "tests/docker/test_container.py::TestContainer::test_host_url", "tests/docker/test_container.py::TestContainer::test_url" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2016-07-20 15:25:43+00:00	bsd-3-clause	5,510
simphony__simphony-remote-134	diff --git a/remoteappmanager/docker/container.py b/remoteappmanager/docker/container.py index cb484b0..f92304c 100644 --- a/remoteappmanager/docker/container.py +++ b/remoteappmanager/docker/container.py @@ -56,7 +56,7 @@ class Container(HasTraits): ")>") @classmethod - def from_docker_containers_dict(cls, docker_dict): + def from_docker_dict(cls, docker_dict): """Returns a Container object with the info given by a docker Client. @@ -74,24 +74,66 @@ class Container(HasTraits): >>> # containers is a list of dict >>> containers = docker.Client().containers() - >>> Container.from_docker_containers_dict(containers[0]) + >>> Container.from_docker_dict(containers[0]) """ - ip = cls.ip.default_value - port = cls.port.default_value - - if docker_dict.get('Ports'): - ip = docker_dict['Ports'][0].get('IP', ip) - port = docker_dict['Ports'][0].get('PublicPort', port) - - labels = docker_dict.get("Labels", {}) - mapping_id = labels.get(SIMPHONY_NS+"mapping_id", "") - url_id = labels.get(SIMPHONY_NS+"url_id", "") - - return cls(docker_id=docker_dict.get('Id', ''), - name=docker_dict.get('Names', ('',))[0], - image_name=docker_dict.get('Image', ''), - image_id=docker_dict.get('ImageID', ''), - mapping_id=mapping_id, - ip=ip, - port=port, - url_id=url_id) + + is_inspect_container_output = ("Config" in docker_dict) + + kwargs = dict( + docker_id=docker_dict.get('Id') or '', + ip=cls.ip.default_value, + port=cls.port.default_value, + ) + + if is_inspect_container_output: + # It's a client.inspect_container() output + + network_settings = docker_dict.get("NetworkSettings") or {} + ports = network_settings.get("Ports") or {} + # unfortunately, in the case of a running container, we don't have + # a single list. Instead, we have a dict where the keys are + # the "port identifier" (e.g. 8888/tcp) and the value is a list + # of dictionaries. + # We assume that we only have one, as above + if len(ports) > 1: + raise ValueError("Container Ports had more than one element.") + + if len(ports): + port_values = list(ports.values())[0] + if len(port_values) > 1: + raise ValueError("Container Ports values had " + "more than one element.") + + if len(port_values): + kwargs["ip"] = port_values[0].get("HostIp") or kwargs["ip"] + kwargs["port"] = int(port_values[0].get("HostPort") or + kwargs["port"]) + + config = docker_dict.get("Config", {}) + labels = config.get("Labels") + + kwargs["image_name"] = config.get("Image") + kwargs["image_id"] = docker_dict["Image"] + kwargs["name"] = docker_dict["Name"] + else: + # It's a client.containers() output, so we have different rules. + ports = docker_dict.get('Ports') or [] + if len(ports) > 1: + raise ValueError("Container Ports had more than one element.") + + if len(ports): + kwargs["ip"] = ports[0].get('IP') or kwargs["ip"] + kwargs["port"] = int(ports[0].get('PublicPort') or + kwargs["port"]) + + labels = docker_dict.get("Labels") or {} + + kwargs["image_name"] = docker_dict.get('Image') or '' + kwargs["image_id"] = docker_dict.get("ImageID") or '' + names = docker_dict.get("Names") or ('', ) + kwargs["name"] = names[0] + + kwargs["mapping_id"] = labels.get(SIMPHONY_NS+"mapping_id") or "" + kwargs["url_id"] = labels.get(SIMPHONY_NS+"url_id") or "" + + return cls(**kwargs) diff --git a/remoteappmanager/docker/container_manager.py b/remoteappmanager/docker/container_manager.py index 1db82e5..7b85d53 100644 --- a/remoteappmanager/docker/container_manager.py +++ b/remoteappmanager/docker/container_manager.py @@ -166,8 +166,8 @@ class ContainerManager(LoggingMixin): infos = yield self.docker_client.containers(filters=filters) for info in infos: try: - container = Container.from_docker_containers_dict(info) - except Exception: + container = Container.from_docker_dict(info) + except ValueError: self.log.exception("Unable to parse container info.") continue diff --git a/remoteappmanager/file_config.py b/remoteappmanager/file_config.py index 2f93478..8966ed8 100644 --- a/remoteappmanager/file_config.py +++ b/remoteappmanager/file_config.py @@ -3,7 +3,6 @@ import os import tornado.options from docker import tls from traitlets import HasTraits, Int, Unicode, Bool, Dict -from traitlets.utils.sentinel import Sentinel from remoteappmanager import paths from remoteappmanager.traitlets import set_traits_from_dict @@ -110,12 +109,7 @@ class FileConfig(HasTraits): for traitlet_name, traitlet in self.traits().items(): # tornado.OptionParser defines an option with a Python type # and performs type validation. - # traitlet.default_value may be a Sentinel value (e.g. Tuple, - # Dict, Instance), in which case we use the repr - default_value = traitlet.default_value - - if type(default_value) is Sentinel: - default_value = eval(traitlet.default_value_repr()) + default_value = getattr(self, traitlet_name) file_line_parser.define( traitlet_name, diff --git a/remoteappmanager/restresources/container.py b/remoteappmanager/restresources/container.py index c3cd5e8..64bf36a 100644 --- a/remoteappmanager/restresources/container.py +++ b/remoteappmanager/restresources/container.py @@ -118,7 +118,7 @@ class Container(Resource): if not container_dict: return None - return DockerContainer.from_docker_containers_dict(container_dict[0]) + return DockerContainer.from_docker_dict(container_dict[0]) @gen.coroutine def _start_container(self, user_name, app, policy, mapping_id):	simphony/simphony-remote	af0203df6cb3232a28b50fa1023baf73e234aa6d	diff --git a/tests/docker/test_container.py b/tests/docker/test_container.py index f5223dc..249eac9 100644 --- a/tests/docker/test_container.py +++ b/tests/docker/test_container.py @@ -1,7 +1,8 @@ from unittest import TestCase from remoteappmanager.docker.container import Container -from tests.utils import assert_containers_equal +from tests.utils import assert_containers_equal, \ + mock_docker_client_with_running_containers class TestContainer(TestCase): @@ -42,7 +43,7 @@ class TestContainer(TestCase): 'Status': 'Up 56 minutes'} # Container with public port - actual = Container.from_docker_containers_dict(container_dict) + actual = Container.from_docker_dict(container_dict) expected = Container( docker_id='248e45e717cd740ae763a1c565', name='/remoteexec-user-empty-ubuntu_3Alatest', @@ -75,7 +76,7 @@ class TestContainer(TestCase): 'Status': 'Up 56 minutes'} # Container without public port - actual = Container.from_docker_containers_dict(container_dict) + actual = Container.from_docker_dict(container_dict) expected = Container( docker_id='812c765d0549be0ab831ae8348', name='/remoteexec-user-empty-ubuntu_3Alatest', @@ -86,3 +87,57 @@ class TestContainer(TestCase): url_id="8e2fe66d5de74db9bbab50c0d2f92b33") assert_containers_equal(self, actual, expected) + + def test_from_docker_dict_inspect_container(self): + client = mock_docker_client_with_running_containers() + actual = Container.from_docker_dict( + client.inspect_container("id")) + + expected = Container( + docker_id='35d88fe321c3d575ec3be64f54b8967ef49c0dc92395bf4c1e511ed3e6ae0c79', # noqa + name='/remoteexec-username-simphonyproject_2Fsimphonic-mayavi_5F1', + image_name='simphonyproject/simphonic-mayavi', + image_id='sha256:f43b749341ee37b56e7bd8d99f09629f311aaec35a8045a39185b5659edef169', # noqa + ip='0.0.0.0', + port=32782, + url_id="55555555555555555555555555555555", + mapping_id="1c08c87878634e90af43d799e90f61d2") + + assert_containers_equal(self, actual, expected) + + def test_multiple_ports_data(self): + client = mock_docker_client_with_running_containers() + docker_dict = client.inspect_container("id") + docker_dict["NetworkSettings"]["Ports"] = { + '8888/tcp': [{'HostIp': '0.0.0.0', 'HostPort': '32782'}], + '8889/tcp': [{'HostIp': '0.0.0.0', 'HostPort': '32783'}] + } + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) + + docker_dict["NetworkSettings"]["Ports"] = { + '8888/tcp': [ + {'HostIp': '0.0.0.0', 'HostPort': '32782'}, + {'HostIp': '0.0.0.0', 'HostPort': '32783'} + ] + } + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) + + docker_dict = client.containers()[0] + docker_dict["Ports"] = [ + { + 'IP': '0.0.0.0', + 'PublicIP': 34567, + 'PrivatePort': 22, + 'Type': 'tcp' + }, + { + 'IP': '0.0.0.0', + 'PublicIP': 34562, + 'PrivatePort': 21, + 'Type': 'tcp' + } + ] + with self.assertRaises(ValueError): + Container.from_docker_dict(docker_dict) diff --git a/tests/test_file_config.py b/tests/test_file_config.py index 22ce879..484d1b9 100644 --- a/tests/test_file_config.py +++ b/tests/test_file_config.py @@ -151,3 +151,15 @@ class TestFileConfig(TempMixin, unittest.TestCase): config = FileConfig(tls=True) self.assertNotEqual(config.tls_key, '') self.assertNotEqual(config.tls_cert, '') + + def test_file_parsing_not_overriding_bug_131(self): + docker_config = textwrap.dedent(''' + tls = True + ''') + with open(self.config_file, 'w') as fhandle: + print(docker_config, file=fhandle) + + config = FileConfig() + config.parse_config(self.config_file) + self.assertNotEqual(config.tls_key, '') + self.assertNotEqual(config.tls_cert, '') diff --git a/tests/utils.py b/tests/utils.py index 9279636..2556bcd 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -110,6 +110,30 @@ def mock_docker_client_with_running_containers(): 'State': 'running', 'Status': 'Up About an hour'}, ] + client.inspect_container.return_value = { + 'Config': { + 'Image': 'simphonyproject/simphonic-mayavi', + 'Labels': {'eu.simphony-project.docker.description': 'Ubuntu ' + 'machine ' + 'with ' + 'simphony ' + 'framework ' + 'preinstalled', + 'eu.simphony-project.docker.mapping_id': '1c08c87878634e90af43d799e90f61d2', + 'eu.simphony-project.docker.ui_name': 'Simphony ' + 'Framework ' + '(w/ mayavi)', + 'eu.simphony-project.docker.url_id': '55555555555555555555555555555555', + 'eu.simphony-project.docker.user': 'username'}, + }, + 'Id': '35d88fe321c3d575ec3be64f54b8967ef49c0dc92395bf4c1e511ed3e6ae0c79', + 'Image': 'sha256:f43b749341ee37b56e7bd8d99f09629f311aaec35a8045a39185b5659edef169', + 'Name': '/remoteexec-username-simphonyproject_2Fsimphonic-mayavi_5F1', + 'NetworkSettings': { + 'Ports': {'8888/tcp': [{'HostIp': '0.0.0.0', + 'HostPort': '32782'}]}, + }, + } return client	FileConfig with tls=True or tls_verify=False only, leads to docker TLSParameterError On Linux, if my file config for the `remoteappmanager_config.py` ONLY contains the following: ``` $ cat remoteappmanager_config.py tls = True ``` or ``` $ cat remoteappmanager_config.py tls_verify = True ``` Then starting remoteappmanager gives this error ``` $ remoteappmanager --user=kit --port=45707 --cookie-name=jupyter-hub-token-kit --base-urlpath=/user/kit --hub-host= --hub-prefix=/hub/ --hub-api-url=http://172.16.253.129:8081/hub/api --ip=127.0.0.1 --proxy-api-url=http://127.0.0.1:8001/api/routes/ --config-file=remoteappmanager_config.py ... [E 160720 14:33:43 web:1548] Uncaught exception GET /user/kit/ (127.0.0.1) HTTPServerRequest(protocol='http', host='127.0.0.1:8000', method='GET', uri='/user/kit/', version='HTTP/1.1', remote_ip='127.0.0.1', headers={'X-Forwarded-Proto': 'https', 'Accept-Language': 'en-US,en;q=0.5', 'X-Forwarded-For': '127.0.0.1', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8', 'If-None-Match': '"dfba4089bef9b2e40bbd2a75ba5413bb8edbdd83"', 'Host': '127.0.0.1:8000', 'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:39.0) Gecko/20100101 Firefox/39.0', 'Referer': 'https://127.0.0.1:8000/hub/login', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'X-Forwarded-Port': '8000', 'Cookie': 'jupyter-hub-token-kit="2\|1:0\|10:1469021623\|21:jupyter-hub-token-kit\|44:M2UzMjRlOGNhNDBjNGQ5ZWEwYjg3Njk0N2U0ODY4MmE=\|1ec021fdad25b335a6b11b22ff198ce0860a0742a4d95c46a33a6d659d5f4e2d"'}) Traceback (most recent call last): File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/traitlets/traitlets.py", line 501, in get value = obj._trait_values[self.name] KeyError: 'container_manager' During handling of the above exception, another exception occurred: Traceback (most recent call last): File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/web.py", line 1469, in _execute result = yield result File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1015, in run value = future.result() File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/concurrent.py", line 237, in result raise_exc_info(self._exc_info) File "<string>", line 3, in raise_exc_info File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1021, in run yielded = self.gen.throw(*exc_info) File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/handlers/home_handler.py", line 21, in get images_info = yield self._get_images_info() File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 1015, in run value = future.result() File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/concurrent.py", line 237, in result raise_exc_info(self._exc_info) File "<string>", line 3, in raise_exc_info File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/tornado/gen.py", line 285, in wrapper yielded = next(result) File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/handlers/home_handler.py", line 184, in _get_images_info container_manager = self.application.container_manager File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/traitlets/traitlets.py", line 529, in __get__ return self.get(obj, cls) File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/traitlets/traitlets.py", line 508, in get value = self._validate(obj, dynamic_default()) File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/application.py", line 81, in _container_manager_default docker_config=self.file_config.docker_config() File "/mnt/hgfs/VM_shared/SimPhoNy/simphony-remote/remoteappmanager/file_config.py", line 155, in docker_config assert_hostname=True, File "/home/kit/.virtualenv/simremote/lib/python3.4/site-packages/docker/tls.py", line 47, in __init__ 'Path to a certificate and key files must be provided' docker.errors.TLSParameterError: Path to a certificate and key files must be provided through the client_config param. TLS configurations should map the Docker CLI client configurations. See https://docs.docker.com/engine/articles/https/ for API details. ```	af0203df6cb3232a28b50fa1023baf73e234aa6d	[ "tests/docker/test_container.py::TestContainer::test_from_docker_dict_inspect_container", "tests/docker/test_container.py::TestContainer::test_from_docker_dict_with_public_port", "tests/docker/test_container.py::TestContainer::test_from_docker_dict_without_public_port", "tests/docker/test_container.py::TestContainer::test_multiple_ports_data", "tests/test_file_config.py::TestFileConfig::test_file_parsing_not_overriding_bug_131" ]	[ "tests/docker/test_container.py::TestContainer::test_host_url", "tests/docker/test_container.py::TestContainer::test_url", "tests/test_file_config.py::TestFileConfig::test_initialization_on_local_docker_machine", "tests/test_file_config.py::TestFileConfig::test_initialization_on_nonlocal_docker_machine", "tests/test_file_config.py::TestFileConfig::test_initialization_with_default_accounting", "tests/test_file_config.py::TestFileConfig::test_initialization_with_good_accounting", "tests/test_file_config.py::TestFileConfig::test_overriding", "tests/test_file_config.py::TestFileConfig::test_tls_init", "tests/test_file_config.py::TestFileConfig::test_tls_no_verify" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_git_commit_hash", "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2016-07-20 16:23:49+00:00	bsd-3-clause	5,511
simphony__simphony-remote-171	diff --git a/jupyterhub/remoteappmanager_config.py b/jupyterhub/remoteappmanager_config.py index 436d01b..684b1df 100644 --- a/jupyterhub/remoteappmanager_config.py +++ b/jupyterhub/remoteappmanager_config.py @@ -15,23 +15,19 @@ # # TLS configuration # # ----------------- # # -# # Set this to True only if your docker machine has a certificate signed by -# # a recognised CA. -# # If using self-signed certificates, using tls as True will produce an error -# # of incorrect CA validation. As a consequence, the default tls setting is -# # False, and tls_verify is according to the current environment (likely True -# # with default setup on OSX), honoring docker documentation. -# # See https://docs.docker.com/engine/security/https/ for additional details +# # Set this to True to enable TLS connection with the docker client # # tls = True # # # Enables verification of the certificates. By default, this is the -# # result of the DOCKER_TLS_VERIFY envvar +# # result of the DOCKER_TLS_VERIFY envvar. Set to False to skip verification/ # # tls_verify = True # # # Full paths of the CA certificate, certificate and key of the docker -# # machine. Normally these are computed from the DOCKER_CERT_PATH +# # machine. Normally these are computed from the DOCKER_CERT_PATH. +# # If you want to use a recognised CA for verification, set the tls_ca to +# # an empty string # # tls_ca = "/path/to/ca.pem" # tls_cert = "/path/to/cert.pem" diff --git a/remoteappmanager/file_config.py b/remoteappmanager/file_config.py index 9f26882..de1b834 100644 --- a/remoteappmanager/file_config.py +++ b/remoteappmanager/file_config.py @@ -15,19 +15,12 @@ class FileConfig(HasTraits): ########## # Configuration file options. All of these come from the config file. - - #: Enable tls, with a twist. If self-signed certificates are used, - #: setting tls as True will produce an error of incorrect CA validation. - #: As a consequence, defaults to False. TLS secure connection will still - #: happen thanks to tls_verify and tls[_cert\|_key\|_ca] being defined. - #: See https://docs.docker.com/engine/security/https/ - #: Verification can be enabled simply by issuing tls=True in the - #: config file tls = Bool(False, - help="If True, connect to docker with --tls") + help="If True, connect to docker with tls") - tls_verify = Bool(False, - help="If True, connect to docker with --tlsverify") + tls_verify = Bool(True, + help="If True, verify the CA certificate against a " + "known or self-signed CA certificate") tls_ca = Unicode("", help="Path to CA certificate for docker TLS") @@ -39,7 +32,7 @@ class FileConfig(HasTraits): accounting_class = Unicode( default_value="remoteappmanager.db.orm.AppAccounting", - help="The import path to a subclass of ABCAccounting.") + help="The import path to a subclass of ABCAccounting") accounting_kwargs = Dict( default_value={'url': 'sqlite:///remoteappmanager.db'}, @@ -48,7 +41,7 @@ class FileConfig(HasTraits): login_url = Unicode(default_value="/hub", help=("The url to be redirected to if the user is not " "authenticated for pages that require " - "authentication.")) + "authentication")) # The network timeout for any async operation we have to perform, # in seconds. 30 seconds is plenty enough. @@ -77,10 +70,10 @@ class FileConfig(HasTraits): self.docker_host = "unix://var/run/docker.sock" self.tls_verify = (env.get("DOCKER_TLS_VERIFY", "") != "") + # We don't have an envvar way of saying TLS = True, so we rely on + # TLS_VERIFY set status + self.tls = self.tls_verify - # Note that certificate paths can still be present even if tls_verify - # is false: that is the case of using certificates signed by an - # authoritative CA. cert_path = env.get("DOCKER_CERT_PATH", os.path.join(os.path.expanduser("~"), ".docker")) @@ -88,7 +81,7 @@ class FileConfig(HasTraits): self.tls_key = os.path.join(cert_path, 'key.pem') self.tls_ca = os.path.join(cert_path, 'ca.pem') - if self.tls_verify or self.tls: + if self.tls: self.docker_host = self.docker_host.replace('tcp://', 'https://') # ------------------------------------------------------------------------- @@ -142,17 +135,18 @@ class FileConfig(HasTraits): # present at the specified paths. # Note that the tls flag takes precedence against tls verify. # This is docker behavior. - if self.tls: - params["tls"] = tls.TLSConfig( - client_cert=(self.tls_cert, self.tls_key), - ) - elif self.tls_verify: - params["tls"] = tls.TLSConfig( - client_cert=(self.tls_cert, self.tls_key), - ca_cert=self.tls_ca, - verify=True, - ) - params["version"] = "auto" + if not self.tls: + return params + + tls_kwargs = {} + tls_kwargs["client_cert"] = (self.tls_cert, self.tls_key) + tls_kwargs["verify"] = self.tls_verify + + if self.tls_verify and self.tls_ca: + tls_kwargs["ca_cert"] = self.tls_ca + + params["tls"] = tls.TLSConfig(**tls_kwargs) + return params	simphony/simphony-remote	524ed02f5610ede6cb2e60250431c82d49180786	diff --git a/tests/test_file_config.py b/tests/test_file_config.py index 307702a..bc9150c 100644 --- a/tests/test_file_config.py +++ b/tests/test_file_config.py @@ -83,7 +83,7 @@ class TestFileConfig(TempMixin, unittest.TestCase): config.parse_config(self.config_file) docker_dict = config.docker_config() self.assertIn("tls", docker_dict) - self.assertEqual(docker_dict["tls"].verify, None) + self.assertEqual(docker_dict["tls"].verify, False) self.assertEqual(docker_dict["tls"].ca_cert, None) def test_initialization_with_good_accounting(self): @@ -106,8 +106,7 @@ class TestFileConfig(TempMixin, unittest.TestCase): with envvars(envs): config = FileConfig() - # False by default, as we don't want CA verification - self.assertEqual(config.tls, False) + self.assertEqual(config.tls, True) self.assertEqual(config.tls_verify, True) self.assertEqual(config.tls_ca, os.path.join(self.tempdir, "ca.pem")) @@ -141,9 +140,9 @@ class TestFileConfig(TempMixin, unittest.TestCase): with envvars(envs): config = FileConfig() + config.tls = False config.tls_verify = False config.docker_host = "tcp://192.168.99.100:31337" - # False by default, as we don't want CA verification docker_config = config.docker_config() self.assertNotIn("tls", docker_config) self.assertEqual(docker_config["base_url"],	Our FileConfig may not be consistent with the docker config Referring to http://docker-py.readthedocs.io/en/latest/tls/ If one wants to use TLS but with self-signed certificate, docker `tls` should be set to `True` but `tls_verify` set to `False`. Whilst in our FileConfig, we would set`tls`to `False` and `tls_verify` to `True` (and then we assumed a CA file provide in the cert path so we verify against ourselves.)	524ed02f5610ede6cb2e60250431c82d49180786	[ "tests/test_file_config.py::TestFileConfig::test_initialization_on_nonlocal_docker_machine", "tests/test_file_config.py::TestFileConfig::test_tls_no_verify" ]	[ "tests/test_file_config.py::TestFileConfig::test_overriding", "tests/test_file_config.py::TestFileConfig::test_initialization_on_local_docker_machine", "tests/test_file_config.py::TestFileConfig::test_initialization_with_default_accounting", "tests/test_file_config.py::TestFileConfig::test_tls_init", "tests/test_file_config.py::TestFileConfig::test_file_parsing_not_overriding_bug_131", "tests/test_file_config.py::TestFileConfig::test_initialization_with_good_accounting" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-07-26 15:20:39+00:00	bsd-3-clause	5,512
simphony__tornado-webapi-17	diff --git a/tornadowebapi/__init__.py b/tornadowebapi/__init__.py index 12f7bda..f080b6e 100644 --- a/tornadowebapi/__init__.py +++ b/tornadowebapi/__init__.py @@ -1,10 +1,9 @@ -from .handler import ResourceHandler, CollectionHandler -from .utils import url_path_join, with_end_slash +from . import registry MAJOR = 0 -MINOR = 1 +MINOR = 2 MICRO = 0 -IS_RELEASED = True +IS_RELEASED = False __version__ = '%d.%d.%d' % (MAJOR, MINOR, MICRO) @@ -30,13 +29,4 @@ def api_handlers(base_urlpath, version="v1"): The current implementation does not support multiple API versions yet. The version option is only provided for futureproofing. """ - return [ - (with_end_slash( - url_path_join(base_urlpath, "api", version, "(.)", "(.)")), - ResourceHandler - ), - (with_end_slash( - url_path_join(base_urlpath, "api", version, "(.)")), - CollectionHandler - ), - ] + return registry.registry.api_handlers(base_urlpath, version) diff --git a/tornadowebapi/handler.py b/tornadowebapi/handler.py index f9c8956..609a1c5 100644 --- a/tornadowebapi/handler.py +++ b/tornadowebapi/handler.py @@ -4,11 +4,14 @@ from tornado.log import app_log from . import exceptions from .http import httpstatus from .http.payloaded_http_error import PayloadedHTTPError -from .registry import registry from .utils import url_path_join, with_end_slash class BaseHandler(web.RequestHandler): + def initialize(self, registry): + """Initialization method for when the class is instantiated.""" + self._registry = registry + @gen.coroutine def prepare(self): """Runs before any specific handler. """ @@ -17,8 +20,8 @@ class BaseHandler(web.RequestHandler): @property def registry(self): - """Returns the global class vs Resource registry""" - return registry + """Returns the class vs Resource registry""" + return self._registry @property def log(self): diff --git a/tornadowebapi/registry.py b/tornadowebapi/registry.py index c5bac97..ee6bfe0 100644 --- a/tornadowebapi/registry.py +++ b/tornadowebapi/registry.py @@ -1,3 +1,5 @@ +from .handler import ResourceHandler, CollectionHandler +from .utils import url_path_join, with_end_slash from .resource import Resource from .authenticator import NullAuthenticator @@ -63,5 +65,36 @@ class Registry: """If the registry contains the given item""" return item in self._registered_types + def api_handlers(self, base_urlpath, version="v1"): + """Returns the API handlers for the interface. + Add these handlers to your application to provide an + interface to your Resources. + + + Parameters + ---------- + base_urlpath: str + The base url path to serve + version: str + A string identifying the version of the API. + + Notes + ----- + The current implementation does not support multiple API versions yet. + The version option is only provided for futureproofing. + """ + return [ + (with_end_slash( + url_path_join(base_urlpath, "api", version, "(.)", "(.)")), + ResourceHandler, + dict(registry=self) + ), + (with_end_slash( + url_path_join(base_urlpath, "api", version, "(.)")), + CollectionHandler, + dict(registry=self) + ), + ] + #: global registry for registration of the classes. registry = Registry()	simphony/tornado-webapi	5dd0c146089cc0a348a9798e2021447aa4ee311e	diff --git a/tornadowebapi/tests/test_registry.py b/tornadowebapi/tests/test_registry.py index 1dc5433..0b793df 100644 --- a/tornadowebapi/tests/test_registry.py +++ b/tornadowebapi/tests/test_registry.py @@ -42,3 +42,11 @@ class TestRegistry(unittest.TestCase): reg = Registry() self.assertIsNotNone(reg.authenticator) + + def test_api_handlers(self): + reg = Registry() + api_handlers = reg.api_handlers("/foo") + self.assertEqual(len(api_handlers), 2) + + self.assertEqual(api_handlers[0][2]["registry"], reg) + self.assertEqual(api_handlers[1][2]["registry"], reg) diff --git a/tornadowebapi/tests/test_webapi.py b/tornadowebapi/tests/test_webapi.py index d756ece..3a3c8e5 100644 --- a/tornadowebapi/tests/test_webapi.py +++ b/tornadowebapi/tests/test_webapi.py @@ -6,6 +6,7 @@ from unittest import mock import tornadowebapi from tornadowebapi import registry, exceptions from tornadowebapi.http import httpstatus +from tornadowebapi.registry import Registry from tornadowebapi.resource import Resource from tornadowebapi.handler import ResourceHandler, CollectionHandler from tornadowebapi.tests.utils import AsyncHTTPTestCase @@ -56,6 +57,16 @@ class Student(Resource): return list(self.collection.keys()) +class Teacher(Resource): + @gen.coroutine + def retrieve(self, identifier): + return {} + + @gen.coroutine + def items(self): + return [] + + class UnsupportAll(Resource): pass @@ -399,3 +410,23 @@ class TestRESTFunctions(unittest.TestCase): self.assertEqual(handlers[0][1], ResourceHandler) self.assertEqual(handlers[1][0], "/foo/api/v1/(.*)/") self.assertEqual(handlers[1][1], CollectionHandler) + + +class TestNonGlobalRegistry(AsyncHTTPTestCase): + def setUp(self): + super().setUp() + Student.collection = OrderedDict() + Student.id = 0 + + def get_app(self): + self.registry = Registry() + self.registry.register(Teacher) + handlers = self.registry.api_handlers('/') + app = web.Application(handlers=handlers) + return app + + def test_non_global_registry(self): + res = self.fetch("/api/v1/teachers/") + self.assertEqual(res.code, httpstatus.OK) + self.assertEqual(escape.json_decode(res.body), + {"items": []})	Support multiple registries The current global registry is convenient for a single application, but it's a global object. This introduces major problems when testing. We need to be able to handle multiple registers, each one providing its own api.	5dd0c146089cc0a348a9798e2021447aa4ee311e	[ "tornadowebapi/tests/test_registry.py::TestRegistry::test_api_handlers", "tornadowebapi/tests/test_webapi.py::TestNonGlobalRegistry::test_non_global_registry" ]	[ "tornadowebapi/tests/test_registry.py::TestRegistry::test_authenticator", "tornadowebapi/tests/test_registry.py::TestRegistry::test_instantiation", "tornadowebapi/tests/test_webapi.py::TestREST::test_broken", "tornadowebapi/tests/test_webapi.py::TestREST::test_create", "tornadowebapi/tests/test_webapi.py::TestREST::test_delete", "tornadowebapi/tests/test_webapi.py::TestREST::test_items", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_non_json", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_on_resource", "tornadowebapi/tests/test_webapi.py::TestREST::test_retrieve", "tornadowebapi/tests/test_webapi.py::TestREST::test_unexistent_resource_type", "tornadowebapi/tests/test_webapi.py::TestREST::test_unprocessable", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupported_methods", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupports_collections", "tornadowebapi/tests/test_webapi.py::TestREST::test_update", "tornadowebapi/tests/test_webapi.py::TestRESTFunctions::test_api_handlers" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2016-09-21 13:35:16+00:00	bsd-3-clause	5,513
simphony__tornado-webapi-19	diff --git a/tornadowebapi/exceptions.py b/tornadowebapi/exceptions.py index a5f3dd3..a2999b5 100644 --- a/tornadowebapi/exceptions.py +++ b/tornadowebapi/exceptions.py @@ -44,7 +44,7 @@ class NotFound(WebAPIException): return None -class BadRequest(WebAPIException): +class BadRepresentation(WebAPIException): """Exception raised when the resource representation is invalid or does not contain the appropriate keys. Raise this exception in your handlers when the received @@ -53,6 +53,10 @@ class BadRequest(WebAPIException): http_code = httpstatus.BAD_REQUEST +# Deprecated. Kept for compatibility +BadRequest = BadRepresentation + + class Unable(WebAPIException): """Exception raised when the request cannot be performed for whatever reason that is not dependent on the client. diff --git a/tox.ini b/tox.ini index 1147235..debc066 100644 --- a/tox.ini +++ b/tox.ini @@ -1,2 +1,2 @@ [flake8] -exclude = build/,venv/,doc/source/conf.py +exclude = build/,venv/*,doc/source/conf.py	simphony/tornado-webapi	95ad403cd70109fb94727a119545567593d8203d	diff --git a/tornadowebapi/tests/test_webapi.py b/tornadowebapi/tests/test_webapi.py index 3a3c8e5..e3f3b8b 100644 --- a/tornadowebapi/tests/test_webapi.py +++ b/tornadowebapi/tests/test_webapi.py @@ -74,19 +74,19 @@ class UnsupportAll(Resource): class Unprocessable(Resource): @gen.coroutine def create(self, representation): - raise exceptions.BadRequest("unprocessable", foo="bar") + raise exceptions.BadRepresentation("unprocessable", foo="bar") @gen.coroutine def update(self, identifier, representation): - raise exceptions.BadRequest("unprocessable", foo="bar") + raise exceptions.BadRepresentation("unprocessable", foo="bar") @gen.coroutine def retrieve(self, identifier): - raise exceptions.BadRequest("unprocessable", foo="bar") + raise exceptions.BadRepresentation("unprocessable", foo="bar") @gen.coroutine def items(self): - raise exceptions.BadRequest("unprocessable", foo="bar") + raise exceptions.BadRepresentation("unprocessable", foo="bar") class UnsupportsCollection(Resource): @@ -328,7 +328,7 @@ class TestREST(AsyncHTTPTestCase): self.assertEqual(res.code, httpstatus.BAD_REQUEST) self.assertEqual(res.headers["Content-Type"], 'application/json') self.assertEqual(escape.json_decode(res.body), { - "type": "BadRequest", + "type": "BadRepresentation", "message": "unprocessable", "foo": "bar", }) @@ -340,7 +340,7 @@ class TestREST(AsyncHTTPTestCase): self.assertEqual(res.code, httpstatus.BAD_REQUEST) self.assertEqual(res.headers["Content-Type"], 'application/json') self.assertEqual(escape.json_decode(res.body), { - "type": "BadRequest", + "type": "BadRepresentation", "message": "unprocessable", "foo": "bar", }) @@ -353,7 +353,7 @@ class TestREST(AsyncHTTPTestCase): self.assertEqual(res.code, httpstatus.BAD_REQUEST) self.assertEqual(res.headers["Content-Type"], 'application/json') self.assertEqual(escape.json_decode(res.body), { - "type": "BadRequest", + "type": "BadRepresentation", "message": "unprocessable", "foo": "bar", }) @@ -365,7 +365,7 @@ class TestREST(AsyncHTTPTestCase): self.assertEqual(res.code, httpstatus.BAD_REQUEST) self.assertEqual(res.headers["Content-Type"], 'application/json') self.assertEqual(escape.json_decode(res.body), { - "type": "BadRequest", + "type": "BadRepresentation", "message": "unprocessable", "foo": "bar", }) @@ -378,7 +378,7 @@ class TestREST(AsyncHTTPTestCase): self.assertEqual(res.code, httpstatus.BAD_REQUEST) self.assertEqual(res.headers["Content-Type"], 'application/json') self.assertEqual(escape.json_decode(res.body), { - "type": "BadRequest", + "type": "BadRepresentation", "message": "unprocessable", "foo": "bar", })	Change BadRequest error to BadRepresentation BadRequest is HTTP. It's technically a bad representation that the CRUD methods handle, and the exception should reflect that. Migrated from https://github.com/simphony/simphony-remote/issues/181	95ad403cd70109fb94727a119545567593d8203d	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_unprocessable" ]	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_broken", "tornadowebapi/tests/test_webapi.py::TestREST::test_create", "tornadowebapi/tests/test_webapi.py::TestREST::test_delete", "tornadowebapi/tests/test_webapi.py::TestREST::test_items", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_non_json", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_on_resource", "tornadowebapi/tests/test_webapi.py::TestREST::test_retrieve", "tornadowebapi/tests/test_webapi.py::TestREST::test_unexistent_resource_type", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupported_methods", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupports_collections", "tornadowebapi/tests/test_webapi.py::TestREST::test_update", "tornadowebapi/tests/test_webapi.py::TestRESTFunctions::test_api_handlers", "tornadowebapi/tests/test_webapi.py::TestNonGlobalRegistry::test_non_global_registry" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2016-10-03 12:47:29+00:00	bsd-3-clause	5,514
simphony__tornado-webapi-27	diff --git a/tornadowebapi/exceptions.py b/tornadowebapi/exceptions.py index 60bd639..64a3a2e 100644 --- a/tornadowebapi/exceptions.py +++ b/tornadowebapi/exceptions.py @@ -44,6 +44,19 @@ class NotFound(WebAPIException): return None +class Exists(WebAPIException): + """Represents a case where the resource could not be created + because it already exists. This is generally raised in the + create() method if the resource has uniqueness constraints on + things other than the exposed id.""" + + http_code = httpstatus.CONFLICT + + def representation(self): + """Exists does not have a representation, just an error status""" + return None + + class BadRepresentation(WebAPIException): """Exception raised when the resource representation is invalid or does not contain the appropriate keys. diff --git a/tornadowebapi/handler.py b/tornadowebapi/handler.py index 609a1c5..6b78df0 100644 --- a/tornadowebapi/handler.py +++ b/tornadowebapi/handler.py @@ -102,7 +102,7 @@ class CollectionHandler(BaseHandler): self.set_status(httpstatus.OK) # Need to convert into a dict for security issue tornado/1009 - self.write({"items": list(items)}) + self.write({"items": [str(item) for item in items]}) self.flush() @gen.coroutine @@ -134,7 +134,7 @@ class CollectionHandler(BaseHandler): raise web.HTTPError(httpstatus.INTERNAL_SERVER_ERROR) location = with_end_slash( - url_path_join(self.request.full_url(), resource_id)) + url_path_join(self.request.full_url(), str(resource_id))) self.set_status(httpstatus.CREATED) self.set_header("Location", location)	simphony/tornado-webapi	a09944d66e3090ad4ab8ce20f8dd1f92a14855b3	diff --git a/tornadowebapi/tests/test_webapi.py b/tornadowebapi/tests/test_webapi.py index e3f3b8b..3c707a1 100644 --- a/tornadowebapi/tests/test_webapi.py +++ b/tornadowebapi/tests/test_webapi.py @@ -26,8 +26,8 @@ class Student(Resource): @gen.coroutine def create(self, representation): - id = str(type(self).id) - self.collection[id] = representation + id = type(self).id + self.collection[str(id)] = representation type(self).id += 1 return id @@ -107,6 +107,12 @@ class Broken(Resource): items = boom +class AlreadyPresent(Resource): + @gen.coroutine + def create(self, *args): + raise exceptions.Exists() + + class TestREST(AsyncHTTPTestCase): def setUp(self): super().setUp() @@ -120,6 +126,7 @@ class TestREST(AsyncHTTPTestCase): registry.registry.register(Unprocessable) registry.registry.register(UnsupportsCollection) registry.registry.register(Broken) + registry.registry.register(AlreadyPresent) app = web.Application(handlers=handlers) app.hub = mock.Mock() return app @@ -138,7 +145,7 @@ class TestREST(AsyncHTTPTestCase): res = self.fetch("/api/v1/students/") self.assertEqual(res.code, httpstatus.OK) self.assertEqual(escape.json_decode(res.body), - {"items": [1, 2, 3]}) + {"items": ["1", "2", "3"]}) def test_create(self): res = self.fetch( @@ -402,6 +409,12 @@ class TestREST(AsyncHTTPTestCase): method="GET") self.assertEqual(res.code, httpstatus.METHOD_NOT_ALLOWED) + def test_exists(self): + collection_url = "/api/v1/alreadypresents/" + + res = self.fetch(collection_url, method="POST", body="{}") + self.assertEqual(res.code, httpstatus.CONFLICT) + class TestRESTFunctions(unittest.TestCase): def test_api_handlers(self):	Add Exists exception In case we generate a resource that already exists for whatever reason	a09944d66e3090ad4ab8ce20f8dd1f92a14855b3	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_create", "tornadowebapi/tests/test_webapi.py::TestREST::test_delete", "tornadowebapi/tests/test_webapi.py::TestREST::test_exists", "tornadowebapi/tests/test_webapi.py::TestREST::test_items", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_on_resource", "tornadowebapi/tests/test_webapi.py::TestREST::test_retrieve", "tornadowebapi/tests/test_webapi.py::TestREST::test_update" ]	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_broken", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_non_json", "tornadowebapi/tests/test_webapi.py::TestREST::test_unexistent_resource_type", "tornadowebapi/tests/test_webapi.py::TestREST::test_unprocessable", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupported_methods", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupports_collections", "tornadowebapi/tests/test_webapi.py::TestRESTFunctions::test_api_handlers", "tornadowebapi/tests/test_webapi.py::TestNonGlobalRegistry::test_non_global_registry" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2016-10-21 16:27:15+00:00	bsd-3-clause	5,515
simphony__tornado-webapi-28	diff --git a/tornadowebapi/handler.py b/tornadowebapi/handler.py index 609a1c5..6b78df0 100644 --- a/tornadowebapi/handler.py +++ b/tornadowebapi/handler.py @@ -102,7 +102,7 @@ class CollectionHandler(BaseHandler): self.set_status(httpstatus.OK) # Need to convert into a dict for security issue tornado/1009 - self.write({"items": list(items)}) + self.write({"items": [str(item) for item in items]}) self.flush() @gen.coroutine @@ -134,7 +134,7 @@ class CollectionHandler(BaseHandler): raise web.HTTPError(httpstatus.INTERNAL_SERVER_ERROR) location = with_end_slash( - url_path_join(self.request.full_url(), resource_id)) + url_path_join(self.request.full_url(), str(resource_id))) self.set_status(httpstatus.CREATED) self.set_header("Location", location)	simphony/tornado-webapi	a09944d66e3090ad4ab8ce20f8dd1f92a14855b3	diff --git a/tornadowebapi/tests/test_webapi.py b/tornadowebapi/tests/test_webapi.py index e3f3b8b..c67406d 100644 --- a/tornadowebapi/tests/test_webapi.py +++ b/tornadowebapi/tests/test_webapi.py @@ -26,8 +26,8 @@ class Student(Resource): @gen.coroutine def create(self, representation): - id = str(type(self).id) - self.collection[id] = representation + id = type(self).id + self.collection[str(id)] = representation type(self).id += 1 return id @@ -138,7 +138,7 @@ class TestREST(AsyncHTTPTestCase): res = self.fetch("/api/v1/students/") self.assertEqual(res.code, httpstatus.OK) self.assertEqual(escape.json_decode(res.body), - {"items": [1, 2, 3]}) + {"items": ["1", "2", "3"]}) def test_create(self): res = self.fetch(	Set the POST resource_id to string. The id should be converted to string before generating the resource URL, this way we can return integers from the REST handler and still work fine.	a09944d66e3090ad4ab8ce20f8dd1f92a14855b3	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_create", "tornadowebapi/tests/test_webapi.py::TestREST::test_delete", "tornadowebapi/tests/test_webapi.py::TestREST::test_items", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_on_resource", "tornadowebapi/tests/test_webapi.py::TestREST::test_retrieve", "tornadowebapi/tests/test_webapi.py::TestREST::test_update" ]	[ "tornadowebapi/tests/test_webapi.py::TestREST::test_broken", "tornadowebapi/tests/test_webapi.py::TestREST::test_post_non_json", "tornadowebapi/tests/test_webapi.py::TestREST::test_unexistent_resource_type", "tornadowebapi/tests/test_webapi.py::TestREST::test_unprocessable", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupported_methods", "tornadowebapi/tests/test_webapi.py::TestREST::test_unsupports_collections", "tornadowebapi/tests/test_webapi.py::TestRESTFunctions::test_api_handlers", "tornadowebapi/tests/test_webapi.py::TestNonGlobalRegistry::test_non_global_registry" ]	{ "failed_lite_validators": [ "has_short_problem_statement" ], "has_test_patch": true, "is_lite": false }	2016-10-21 16:35:47+00:00	bsd-3-clause	5,516
simple-salesforce__simple-salesforce-242	diff --git a/README.rst b/README.rst index e5722d6..2388168 100644 --- a/README.rst +++ b/README.rst @@ -15,7 +15,7 @@ You can find out more regarding the format of the results in the `Official Sales .. _Official Salesforce.com REST API Documentation: http://www.salesforce.com/us/developer/docs/api_rest/index.htm -Example +Examples ------- There are two ways to gain access to Salesforce @@ -51,23 +51,23 @@ To login using IP-whitelist Organization ID method, simply use your Salesforce u from simple_salesforce import Salesforce sf = Salesforce(password='password', username='[email protected]', organizationId='OrgId') -If you'd like to enter a sandbox, simply add ``sandbox=True`` to your ``Salesforce()`` call. +If you'd like to enter a sandbox, simply add ``domain='test'`` to your ``Salesforce()`` call. For example: .. code-block:: python from simple_salesforce import Salesforce - sf = Salesforce(username='[email protected]', password='password', security_token='token', sandbox=True) + sf = Salesforce(username='[email protected]', password='password', security_token='token', domain='test') -Note that specifying if you want to use a sandbox is only necessary if you are using the built-in username/password/security token authentication and is used exclusively during the authentication step. +Note that specifying if you want to use a domain is only necessary if you are using the built-in username/password/security token authentication and is used exclusively during the authentication step. If you'd like to keep track where your API calls are coming from, simply add ``client_id='My App'`` to your ``Salesforce()`` call. .. code-block:: python from simple_salesforce import Salesforce - sf = Salesforce(username='[email protected]', password='password', security_token='token', sandbox=True, client_id='My App') + sf = Salesforce(username='[email protected]', password='password', security_token='token', client_id='My App', domain='test') If you view the API calls in your Salesforce instance by Client Id it will be prefixed with ``RestForce/``, for example ``RestForce/My App``. @@ -310,7 +310,7 @@ Additional Features There are a few helper classes that are used internally and available to you. -Included in them are ``SalesforceLogin``, which takes in a username, password, security token, optional boolean sandbox indicator and optional version and returns a tuple of ``(session_id, sf_instance)`` where `session_id` is the session ID to use for authentication to Salesforce and ``sf_instance`` is the domain of the instance of Salesforce to use for the session. +Included in them are ``SalesforceLogin``, which takes in a username, password, security token, optional version and optional domain and returns a tuple of ``(session_id, sf_instance)`` where `session_id` is the session ID to use for authentication to Salesforce and ``sf_instance`` is the domain of the instance of Salesforce to use for the session. For example, to use SalesforceLogin for a sandbox account you'd use: @@ -321,9 +321,9 @@ For example, to use SalesforceLogin for a sandbox account you'd use: username='[email protected]', password='password', security_token='token', - sandbox=True) + domain='test') -Simply leave off the final ``True`` if you do not wish to use a sandbox. +Simply leave off the final domain if you do not wish to use a sandbox. Also exposed is the ``SFType`` class, which is used internally by the ``__getattr__()`` method in the ``Salesforce()`` class and represents a specific SObject type. ``SFType`` requires ``object_name`` (i.e. ``Contact``), ``session_id`` (an authentication ID), ``sf_instance`` (hostname of your Salesforce instance), and an optional ``sf_version`` diff --git a/docs/user_guide/additional_features.rst b/docs/user_guide/additional_features.rst index 15c3716..2b0f6f8 100644 --- a/docs/user_guide/additional_features.rst +++ b/docs/user_guide/additional_features.rst @@ -3,7 +3,7 @@ Additional Features There are a few helper classes that are used internally and available to you. -Included in them are ``SalesforceLogin``, which takes in a username, password, security token, optional boolean sandbox indicator and optional version and returns a tuple of ``(session_id, sf_instance)`` where `session_id` is the session ID to use for authentication to Salesforce and ``sf_instance`` is the domain of the instance of Salesforce to use for the session. +Included in them are ``SalesforceLogin``, which takes in a username, password, security token, optional version and optional domain and returns a tuple of ``(session_id, sf_instance)`` where `session_id` is the session ID to use for authentication to Salesforce and ``sf_instance`` is the domain of the instance of Salesforce to use for the session. For example, to use SalesforceLogin for a sandbox account you'd use: @@ -14,9 +14,9 @@ For example, to use SalesforceLogin for a sandbox account you'd use: username='[email protected]', password='password', security_token='token', - sandbox=True) + domain='test') -Simply leave off the final ``True`` if you do not wish to use a sandbox. +Simply leave off the final domain if you do not wish to use a sandbox. Also exposed is the ``SFType`` class, which is used internally by the ``__getattr__()`` method in the ``Salesforce()`` class and represents a specific SObject type. ``SFType`` requires ``object_name`` (i.e. ``Contact``), ``session_id`` (an authentication ID), ``sf_instance`` (hostname of your Salesforce instance), and an optional ``sf_version`` diff --git a/docs/user_guide/examples.rst b/docs/user_guide/examples.rst index 13472bb..b24d6e4 100644 --- a/docs/user_guide/examples.rst +++ b/docs/user_guide/examples.rst @@ -34,23 +34,23 @@ To login using IP-whitelist Organization ID method, simply use your Salesforce u from simple_salesforce import Salesforce sf = Salesforce(password='password', username='[email protected]', organizationId='OrgId') -If you'd like to enter a sandbox, simply add ``sandbox=True`` to your ``Salesforce()`` call. +If you'd like to enter a sandbox, simply add ``domain='test'`` to your ``Salesforce()`` call. For example: .. code-block:: python from simple_salesforce import Salesforce - sf = Salesforce(username='[email protected]', password='password', security_token='token', sandbox=True) + sf = Salesforce(username='[email protected]', password='password', security_token='token', domain='test') -Note that specifying if you want to use a sandbox is only necessary if you are using the built-in username/password/security token authentication and is used exclusively during the authentication step. +Note that specifying if you want to use a domain is only necessary if you are using the built-in username/password/security token authentication and is used exclusively during the authentication step. If you'd like to keep track where your API calls are coming from, simply add ``client_id='My App'`` to your ``Salesforce()`` call. .. code-block:: python from simple_salesforce import Salesforce - sf = Salesforce(username='[email protected]', password='password', security_token='token', sandbox=True, client_id='My App') + sf = Salesforce(username='[email protected]', password='password', security_token='token', client_id='My App', domain='test') If you view the API calls in your Salesforce instance by Client Id it will be prefixed with ``RestForce/``, for example ``RestForce/My App``. diff --git a/simple_salesforce/api.py b/simple_salesforce/api.py index 73c1afd..87af64f 100644 --- a/simple_salesforce/api.py +++ b/simple_salesforce/api.py @@ -59,8 +59,8 @@ class Salesforce(object): def __init__( self, username=None, password=None, security_token=None, session_id=None, instance=None, instance_url=None, - organizationId=None, sandbox=False, version=DEFAULT_API_VERSION, - proxies=None, session=None, client_id=None): + organizationId=None, sandbox=None, version=DEFAULT_API_VERSION, + proxies=None, session=None, client_id=None, domain=None): """Initialize the instance with the given parameters. Available kwargs @@ -70,8 +70,11 @@ class Salesforce(object): * username -- the Salesforce username to use for authentication * password -- the password for the username * security_token -- the security token for the username - * sandbox -- True if you want to login to `test.salesforce.com`, False - if you want to login to `login.salesforce.com`. + * sandbox -- DEPRECATED: Use domain instead. + * domain -- The domain to using for connecting to Salesforce. Use + common domains, such as 'login' or 'test', or + Salesforce My domain. If not used, will default to + 'login'. Direct Session and Instance Access: @@ -93,11 +96,26 @@ class Salesforce(object): exposed by simple_salesforce. """ + if (sandbox is not None) and (domain is not None): + raise ValueError("Both 'sandbox' and 'domain' arguments were " + "supplied. Either may be supplied, but not " + "both.") + + if sandbox is not None: + warnings.warn("'sandbox' argument is deprecated. Use " + "'domain' instead. Overriding 'domain' " + "with 'sandbox' value.", + DeprecationWarning) - # Determine if the user passed in the optional version and/or sandbox - # kwargs + domain = 'test' if sandbox else 'login' + + if domain is None: + domain = 'login' + + # Determine if the user passed in the optional version and/or + # domain kwargs self.sf_version = version - self.sandbox = sandbox + self.domain = domain self.session = session or requests.Session() self.proxies = self.session.proxies # override custom session proxies dance @@ -122,10 +140,10 @@ class Salesforce(object): username=username, password=password, security_token=security_token, - sandbox=self.sandbox, sf_version=self.sf_version, proxies=self.proxies, - client_id=client_id) + client_id=client_id, + domain=self.domain) elif all(arg is not None for arg in ( session_id, instance or instance_url)): @@ -149,20 +167,18 @@ class Salesforce(object): username=username, password=password, organizationId=organizationId, - sandbox=self.sandbox, sf_version=self.sf_version, proxies=self.proxies, - client_id=client_id) + client_id=client_id, + domain=self.domain) else: raise TypeError( 'You must provide login information or an instance and token' ) - if self.sandbox: - self.auth_site = 'https://test.salesforce.com' - else: - self.auth_site = 'https://login.salesforce.com' + self.auth_site = ('https://{domain}.salesforce.com' + .format(domain=self.domain)) self.headers = { 'Content-Type': 'application/json', @@ -272,7 +288,7 @@ class Salesforce(object): return self.set_password(user, password) # Generic Rest Function - def restful(self, path, params, method='GET'): + def restful(self, path, params=None, method='GET', *kwargs): """Allows you to make a direct REST call if you know the path Arguments: @@ -281,10 +297,12 @@ class Salesforce(object): Example: sobjects/User/ABC123/password' params: dict of parameters to pass to the path * method: HTTP request method, default GET + * other arguments supported by requests.request (e.g. json, timeout) """ url = self.base_url + path - result = self._call_salesforce(method, url, name=path, params=params) + result = self._call_salesforce(method, url, name=path, params=params, + *kwargs) json_result = result.json(object_pairs_hook=OrderedDict) if len(json_result) == 0: diff --git a/simple_salesforce/login.py b/simple_salesforce/login.py index 9106330..197f449 100644 --- a/simple_salesforce/login.py +++ b/simple_salesforce/login.py @@ -16,13 +16,14 @@ try: except ImportError: from cgi import escape import requests +import warnings # pylint: disable=invalid-name,too-many-arguments,too-many-locals def SalesforceLogin( username=None, password=None, security_token=None, - organizationId=None, sandbox=False, sf_version=DEFAULT_API_VERSION, - proxies=None, session=None, client_id=None): + organizationId=None, sandbox=None, sf_version=DEFAULT_API_VERSION, + proxies=None, session=None, client_id=None, domain=None): """Return a tuple of `(session_id, sf_instance)` where `session_id` is the session ID to use for authentication to Salesforce and `sf_instance` is the domain of the instance of Salesforce to use for the session. @@ -34,8 +35,7 @@ def SalesforceLogin( security_token -- the security token for the username * organizationId -- the ID of your organization NOTE: security_token an organizationId are mutually exclusive - * sandbox -- True if you want to login to `test.salesforce.com`, False if - you want to login to `login.salesforce.com`. + * sandbox -- DEPRECATED: Use domain instead. * sf_version -- the version of the Salesforce API to use, for example "27.0" * proxies -- the optional map of scheme to proxy server @@ -43,10 +43,28 @@ def SalesforceLogin( enables the use of requets Session features not otherwise exposed by simple_salesforce. * client_id -- the ID of this client + * domain -- The domain to using for connecting to Salesforce. Use + common domains, such as 'login' or 'test', or + Salesforce My domain. If not used, will default to + 'login'. """ + if (sandbox is not None) and (domain is not None): + raise ValueError("Both 'sandbox' and 'domain' arguments were " + "supplied. Either may be supplied, but not " + "both.") + + if sandbox is not None: + warnings.warn("'sandbox' argument is deprecated. Use " + "'domain' instead. Overriding 'domain' " + "with 'sandbox' value.", + DeprecationWarning) + + domain = 'test' if sandbox else 'login' + + if domain is None: + domain = 'login' soap_url = 'https://{domain}.salesforce.com/services/Soap/u/{sf_version}' - domain = 'test' if sandbox else 'login' if client_id: client_id = "{prefix}/{app_name}".format( @@ -55,7 +73,8 @@ def SalesforceLogin( else: client_id = DEFAULT_CLIENT_ID_PREFIX - soap_url = soap_url.format(domain=domain, sf_version=sf_version) + soap_url = soap_url.format(domain=domain, + sf_version=sf_version) # pylint: disable=E0012,deprecated-method username = escape(username)	simple-salesforce/simple-salesforce	679900daafee2d2b17b7aee890014e5592bb1960	diff --git a/simple_salesforce/tests/test_login.py b/simple_salesforce/tests/test_login.py index 4ab18cd..904ef18 100644 --- a/simple_salesforce/tests/test_login.py +++ b/simple_salesforce/tests/test_login.py @@ -32,6 +32,141 @@ class TestSalesforceLogin(unittest.TestCase): self.mockrequest = request_patcher.start() self.addCleanup(request_patcher.stop) + @responses.activate + def test_default_domain_success(self): + """Test default domain logic and login""" + responses.add( + responses.POST, + re.compile(r'^https://login.$'), + body=tests.LOGIN_RESPONSE_SUCCESS, + status=http.OK + ) + session_state = { + 'used': False, + } + + # pylint: disable=missing-docstring,unused-argument + def on_response(args, *kwargs): + session_state['used'] = True + + session = requests.Session() + session.hooks = { + 'response': on_response, + } + session_id, instance = SalesforceLogin( + session=session, + username='[email protected]', + password='password', + security_token='token') + self.assertTrue(session_state['used']) + self.assertEqual(session_id, tests.SESSION_ID) + self.assertEqual(instance, urlparse(tests.SERVER_URL).netloc) + + @responses.activate + def test_custom_domain_success(self): + """Test custom domain login""" + responses.add( + responses.POST, + re.compile(r'^https://testdomain.my.$'), + body=tests.LOGIN_RESPONSE_SUCCESS, + status=http.OK + ) + session_state = { + 'used': False, + } + + # pylint: disable=missing-docstring,unused-argument + def on_response(args, kwargs): + session_state['used'] = True + + session = requests.Session() + session.hooks = { + 'response': on_response, + } + session_id, instance = SalesforceLogin( + session=session, + username='[email protected]', + password='password', + security_token='token', + domain='testdomain.my') + self.assertTrue(session_state['used']) + self.assertEqual(session_id, tests.SESSION_ID) + self.assertEqual(instance, urlparse(tests.SERVER_URL).netloc) + + @responses.activate + def test_deprecated_sandbox_disabled_success(self): + """Test sandbox argument set to False""" + responses.add( + responses.POST, + re.compile(r'^https://login.$'), + body=tests.LOGIN_RESPONSE_SUCCESS, + status=http.OK + ) + session_state = { + 'used': False, + } + + # pylint: disable=missing-docstring,unused-argument + def on_response(args, kwargs): + session_state['used'] = True + + session = requests.Session() + session.hooks = { + 'response': on_response, + } + session_id, instance = SalesforceLogin( + session=session, + username='[email protected]', + password='password', + security_token='token', + sandbox=False) + self.assertTrue(session_state['used']) + self.assertEqual(session_id, tests.SESSION_ID) + self.assertEqual(instance, urlparse(tests.SERVER_URL).netloc) + + @responses.activate + def test_deprecated_sandbox_enabled_success(self): + """Test sandbox argument set to True""" + responses.add( + responses.POST, + re.compile(r'^https://test.$'), + body=tests.LOGIN_RESPONSE_SUCCESS, + status=http.OK + ) + session_state = { + 'used': False, + } + + # pylint: disable=missing-docstring,unused-argument + def on_response(args, *kwargs): + session_state['used'] = True + + session = requests.Session() + session.hooks = { + 'response': on_response, + } + session_id, instance = SalesforceLogin( + session=session, + username='[email protected]', + password='password', + security_token='token', + sandbox=True) + self.assertTrue(session_state['used']) + self.assertEqual(session_id, tests.SESSION_ID) + self.assertEqual(instance, urlparse(tests.SERVER_URL).netloc) + + def test_domain_sandbox_mutual_exclusion_failure(self): + """Test sandbox and domain mutual exclusion""" + + with self.assertRaises(ValueError): + SalesforceLogin( + username='[email protected]', + password='password', + security_token='token', + domain='login', + sandbox=False + ) + @responses.activate def test_custom_session_success(self): """Test custom session""" @@ -75,6 +210,6 @@ class TestSalesforceLogin(unittest.TestCase): username='[email protected]', password='password', security_token='token', - sandbox=True + domain='test' ) self.assertTrue(self.mockrequest.post.called)	Salesforce.restful call is broken for POST Specifying the method for `.restful` was recently added, however, the way the `params` end up getting passed down to the `requests` library needs to change depending on if it's a `GET` or `POST` request. Currently, if I call `Salesforce.restful(url, {'foo': 1}, method='POST')`, it results in the payload getting passed in as query parameters rather than the body.	679900daafee2d2b17b7aee890014e5592bb1960	[ "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_failure", "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_domain_sandbox_mutual_exclusion_failure", "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_custom_domain_success" ]	[ "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_deprecated_sandbox_enabled_success", "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_deprecated_sandbox_disabled_success", "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_default_domain_success", "simple_salesforce/tests/test_login.py::TestSalesforceLogin::test_custom_session_success" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2018-03-26 09:16:33+00:00	apache-2.0	5,517
singingwolfboy__flask-dance-107	diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 35a7a20..840bc74 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -3,7 +3,9 @@ Change Log unreleased ---------- -Nothing yet +* Accessing the ``access_token`` property on an instance of the + ``OAuth2Session`` class will now query the token backend, instead of + checking the client on the instance. 0.13.0 (2017-11-12) ------------------- diff --git a/flask_dance/consumer/requests.py b/flask_dance/consumer/requests.py index 6c93abe..cd711a8 100644 --- a/flask_dance/consumer/requests.py +++ b/flask_dance/consumer/requests.py @@ -102,6 +102,10 @@ class OAuth2Session(BaseOAuth2Session): return True return False + @property + def access_token(self): + return self.token and self.token.get("access_token") + @property def authorized(self): """ This is the property used when you have a statement in your code	singingwolfboy/flask-dance	588509a9ea35b9121680d7cccdafedc44d81b741	diff --git a/tests/consumer/test_requests.py b/tests/consumer/test_requests.py index 7cf3732..1476e87 100644 --- a/tests/consumer/test_requests.py +++ b/tests/consumer/test_requests.py @@ -7,11 +7,6 @@ from pkg_resources import parse_version import requests_oauthlib from flask_dance.consumer.requests import OAuth1Session, OAuth2Session -requires_requests_oauthlib_05 = pytest.mark.skipif( - parse_version(requests_oauthlib.__version__) < parse_version('0.5'), - reason="requires requests_oauthlib at version 0.5 or higher", -) - FAKE_OAUTH1_TOKEN = { "oauth_token": "abcdefg", @@ -24,14 +19,12 @@ FAKE_OAUTH2_TOKEN = { } -@requires_requests_oauthlib_05 def test_oauth1session_authorized(): bp = mock.Mock(token=FAKE_OAUTH1_TOKEN) sess = OAuth1Session(client_key="ckey", client_secret="csec", blueprint=bp) assert sess.authorized == True -@requires_requests_oauthlib_05 def test_oauth1session_not_authorized(): bp = mock.Mock(token=None) sess = OAuth1Session(client_key="ckey", client_secret="csec", blueprint=bp) @@ -48,3 +41,27 @@ def test_oauth2session_not_authorized(): bp = mock.Mock(token=None) sess = OAuth2Session(client_id="cid", blueprint=bp) assert sess.authorized == False + + +def test_oauth2session_token(): + bp = mock.Mock(token=FAKE_OAUTH2_TOKEN) + sess = OAuth2Session(client_id="cid", blueprint=bp) + assert sess.token == FAKE_OAUTH2_TOKEN + + +def test_oauth2session_unset_token(): + bp = mock.Mock(token=None) + sess = OAuth2Session(client_id="cid", blueprint=bp) + assert sess.token == None + + +def test_oauth2session_access_token(): + bp = mock.Mock(token=FAKE_OAUTH2_TOKEN) + sess = OAuth2Session(client_id="cid", blueprint=bp) + assert sess.access_token == "deadbeef" + + +def test_oauth2session_unset_access_token(): + bp = mock.Mock(token=None) + sess = OAuth2Session(client_id="cid", blueprint=bp) + assert sess.access_token == None	The github.access_token return None even if the access token is available A demonstration is in this app: https://github.com/giocalitri/flask-dance-github/blob/gdm_test/github.py After getting the token with the first endpoint, try to GET the second and you will have something like: ``` { "access_token": null, "token": { "access_token": "XXXXXXXXXXXXXXXXXXXXXXXXXX", "scope": [ "" ], "token_type": "bearer" } } ```	588509a9ea35b9121680d7cccdafedc44d81b741	[ "tests/consumer/test_requests.py::test_oauth2session_access_token" ]	[ "tests/consumer/test_requests.py::test_oauth1session_authorized", "tests/consumer/test_requests.py::test_oauth1session_not_authorized", "tests/consumer/test_requests.py::test_oauth2session_token", "tests/consumer/test_requests.py::test_oauth2session_authorized", "tests/consumer/test_requests.py::test_oauth2session_unset_token", "tests/consumer/test_requests.py::test_oauth2session_not_authorized", "tests/consumer/test_requests.py::test_oauth2session_unset_access_token" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2018-02-10 11:10:39+00:00	mit	5,518
sirMackk__py3tftp-15	diff --git a/.github/workflows/actions.yml b/.github/workflows/actions.yml new file mode 100644 index 0000000..8386936 --- /dev/null +++ b/.github/workflows/actions.yml @@ -0,0 +1,21 @@ +name: Run Python tests +on: [push] +jobs: + verify: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest] # TODO: add 'windows-latest' + python-version: ['3.5'] # TODO: add '3.9' + steps: + - uses: actions/checkout@v2 + - name: Setup Python + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + + # Install packages + - run: pip install coverage==4.1 flake8==3.5.0 + + # Run tests + - run: .github/workflows/test.sh diff --git a/.travis/run.sh b/.github/workflows/test.sh similarity index 95% rename from .travis/run.sh rename to .github/workflows/test.sh index f549b1f..7f24792 100755 --- a/.travis/run.sh +++ b/.github/workflows/test.sh @@ -22,4 +22,4 @@ timeout=15 timeout -s SIGINT "${timeout}" python -m py3tftp --host 127.0.0.1 &> /dev/null & sleep 1 -timeout -s SIGINT "${timeout}" python -m unittest discover -s tests/acceptance -p _test.py +timeout -s SIGINT "${timeout}" python -m unittest discover -s tests/acceptance -p _test.py \ No newline at end of file diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 5be3b48..0000000 --- a/.travis.yml +++ /dev/null @@ -1,10 +0,0 @@ -language: python -python: - - "3.5" - -install: pip install coverage==4.1 flake8==3.5.0 - -script: ./.travis/run.sh - -notifications: - email: false diff --git a/py3tftp/file_io.py b/py3tftp/file_io.py index ff17b31..edaf72a 100644 --- a/py3tftp/file_io.py +++ b/py3tftp/file_io.py @@ -1,5 +1,5 @@ import os -import os.path as opath +from pathlib import Path from .netascii import Netascii @@ -7,11 +7,21 @@ def sanitize_fname(fname): """ Ensures that fname is a path under the current working directory. """ - root_dir = os.getcwd() - return opath.join( - bytes(root_dir, encoding='ascii'), - opath.normpath( - b'/' + fname).lstrip(b'/')) + # Remove root (/) and parent (..) directory references. + path = os.fsdecode(fname).lstrip('./') + abs_path = Path.cwd() / path + + # Verify that the formed path is under the current working directory. + try: + abs_path.relative_to(Path.cwd()) + except ValueError: + raise FileNotFoundError + + # Verify that we are not accesing a reserved file. + if abs_path.is_reserved(): + raise FileNotFoundError + + return abs_path class FileReader(object): @@ -25,9 +35,9 @@ class FileReader(object): """ def __init__(self, fname, chunk_size=0, mode=None): + self._f = None self.fname = sanitize_fname(fname) self.chunk_size = chunk_size - self._f = None self._f = self._open_file() self.finished = False @@ -35,10 +45,10 @@ class FileReader(object): self._f = Netascii(self._f) def _open_file(self): - return open(self.fname, 'rb') + return self.fname.open('rb') def file_size(self): - return os.stat(self.fname).st_size + return self.fname.stat().st_size def read_chunk(self, size=None): size = size or self.chunk_size @@ -66,16 +76,16 @@ class FileWriter(object): When it goes out of scope, it ensures the file is closed. """ def __init__(self, fname, chunk_size, mode=None): + self._f = None self.fname = sanitize_fname(fname) self.chunk_size = chunk_size - self._f = None self._f = self._open_file() if mode == b'netascii': self._f = Netascii(self._f) def _open_file(self): - return open(self.fname, 'xb') + return self.fname.open('xb') def _flush(self): if self._f:	sirMackk/py3tftp	396a5438a70866ad3b04394429af7876953dc2b0	diff --git a/tests/unit/file_util_test.py b/tests/unit/file_util_test.py index 171e79e..7be4bf1 100644 --- a/tests/unit/file_util_test.py +++ b/tests/unit/file_util_test.py @@ -93,11 +93,8 @@ class FileWriterTest(t.TestCase): class TestSanitizeFname(t.TestCase): @classmethod def setUpClass(cls): - from os import getcwd - from os.path import join as path_join - cls.target_dir = bytes( - path_join(getcwd(), 'tmp/testfile'), - encoding='ascii') + from pathlib import Path + cls.target_dir = Path.cwd() / 'tmp/testfile' def test_under_root_dir(self): fname = b'/tmp/testfile'	local file not found error I'm running `py3tftp` on Windows 7 64bit and Python 3.7.0 When I run `pytftp` in a folder containing the file `myip.py`, I expect it to be able to serve that file. However, when I ran a tftp client (on the same machine) and requested this file, I got a `File Not Found` error. Am I doing something wrong? Also, how do I quit without having to kill the process in Task Manager? Ctrl+C etc doesn't work. Server invocation: ``` Directory of c:\dev 12/16/2018 10:59 AM <DIR> . 12/16/2018 10:59 AM <DIR> .. 12/16/2018 10:43 AM 246 myip.py 12/16/2018 11:01 AM 334 myports.py 12/16/2018 11:01 AM <DIR> nppBackup 07/13/2009 10:20 PM <DIR> PerfLogs 2 File(s) 580 bytes 4 Dir(s) 60,627,619,840 bytes free c:\dev>py3tftp -p 69 -v 2018-12-16 11:11:21,443 [INFO] Starting TFTP server on 0.0.0.0:69 2018-12-16 11:11:21,443 [DEBUG] Using selector: SelectSelector 2018-12-16 11:11:21,443 [INFO] Listening... 2018-12-16 11:11:25,819 [DEBUG] received: ☺myip.py octet tsize 0 2018-12-16 11:11:25,819 [DEBUG] Request: b'myip.py\x00octet\x00tsize\x000\x00' 2018-12-16 11:11:25,819 [DEBUG] b'tsize' 2018-12-16 11:11:25,819 [DEBUG] packet type: RRQ 2018-12-16 11:11:25,819 [DEBUG] Request: b'myip.py\x00octet\x00tsize\x000\x00' 2018-12-16 11:11:25,819 [DEBUG] b'tsize' 2018-12-16 11:11:25,819 [DEBUG] b'tsize' 2018-12-16 11:11:25,819 [INFO] Initiating RRQProtocol with ('127.0.0.1', 54144) 2018-12-16 11:11:25,819 [DEBUG] Initializing file transfer to ('127.0.0.1', 54144) 2018-12-16 11:11:25,819 [DEBUG] Set protocol attributes as {b'ack_timeout': 0.5, b'timeout': 3.0, b'blksize': 512, b'windowsize': 1, b'tsize': 0} 2018-12-16 11:11:25,819 [ERROR] File "b'myip.py'" does not exist! 2018-12-16 11:11:25,819 [DEBUG] opening pkt: <py3tftp.tftp_packet.TFTPErrPacket object at 0x00000000032E19B0> 2018-12-16 11:11:25,819 [INFO] Closing connection to ('127.0.0.1', 54144) due to error. "b'myip.py'" Not transmitted. 2018-12-16 11:11:25,819 [INFO] Connection to 127.0.0.1:54144 terminated ``` client invocation (using mobaxterm cygwin-like shell): ``` ➤ tftp -g -r myip.py 0.0.0.0 tftp: using blksize 512 using server '0.0.0.0:69', remote_file 'myip.py', local_file 'myip.py' sending 24 bytes 00 01 6d 79 69 70 2e 70 79 00 6f 63 74 65 74 00 74 73 69 7a 65 00 30 00 received 19 bytes: 0005 0001 tftp: server error: (1) File not found ```	396a5438a70866ad3b04394429af7876953dc2b0	[ "tests/unit/file_util_test.py::TestSanitizeFname::test_dir_traversal", "tests/unit/file_util_test.py::TestSanitizeFname::test_under_root_dir" ]	[ "tests/unit/file_util_test.py::FileReaderTest::test_fd_closed_after_reading", "tests/unit/file_util_test.py::FileReaderTest::test_raises_doesnt_exist_exc", "tests/unit/file_util_test.py::FileReaderTest::test_reads_file", "tests/unit/file_util_test.py::FileReaderTest::test_reads_n_bytes", "tests/unit/file_util_test.py::FileReaderTest::test_still_has_data_to_read", "tests/unit/file_util_test.py::FileWriterTest::test_doesnt_overwrite_file_raises_exc", "tests/unit/file_util_test.py::FileWriterTest::test_fd_closed_after_everything_written_out", "tests/unit/file_util_test.py::FileWriterTest::test_write_chunk_returns_no_bytes_written", "tests/unit/file_util_test.py::FileWriterTest::test_writes_full_file_to_disk" ]	{ "failed_lite_validators": [ "has_added_files", "has_removed_files", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2021-02-25 07:46:20+00:00	mit	5,519
ska-sa__aiokatcp-8	diff --git a/aiokatcp/core.py b/aiokatcp/core.py index fe49fe8..d040270 100644 --- a/aiokatcp/core.py +++ b/aiokatcp/core.py @@ -30,6 +30,7 @@ import re import io import logging import ipaddress +import numbers from typing import ( Match, Any, Callable, Union, Type, Iterable, Tuple, Generic, TypeVar, Optional, cast) @@ -178,17 +179,18 @@ class LogLevel(enum.IntEnum): class TypeInfo(Generic[_T_contra]): """Type database entry. Refer to :func:`register_type` for details.""" - def __init__(self, name: str, + def __init__(self, type_: Type[_T_contra], name: str, encode: Callable[[_T_contra], bytes], decode: Callable[[Type[_T_contra], bytes], _T_contra], default: Callable[[Type[_T_contra]], _T_contra]) -> None: + self.type_ = type_ self.name = name self.encode = encode self.decode = decode self.default = default -_types = {} # type: Dict[type, TypeInfo] +_types = [] # type: List[TypeInfo] def register_type(type_: Type[_T], name: str, @@ -214,27 +216,28 @@ def register_type(type_: Type[_T], name: str, Function to generate a default value of this type (used by the sensor framework). It is given the actual derived class as the first argument. """ - if type_ in _types: - raise ValueError('type {!r} is already registered') if default is None: default = _default_generic - _types[type_] = TypeInfo(name, encode, decode, default) + for info in _types: + if info.type_ == type_: + raise ValueError('{} is already registered'.format(type_)) + _types.append(TypeInfo(type_, name, encode, decode, default)) def get_type(type_: Type[_T]) -> TypeInfo[_T]: """Retrieve the type information previously registered with :func:`register_type`. - It returns the type info corresponding to `type_` or the most specific subclass - (according to method resolution order) for which there is a registration. + It returns the last type info registered that is a superclass of `type_` (according + to ``issubclass``. Raises ------ TypeError - if neither `type_` nor any of its bases is registered + if none of the registrations match `type_` """ - for t in type_.__mro__: - if t in _types: - return _types[t] + for info in reversed(_types): + if issubclass(type_, info.type_): + return info raise TypeError('{} is not registered'.format(type_)) @@ -278,12 +281,14 @@ def _default_enum(cls: Type[_E]) -> _E: return next(iter(cast(Iterable, cls))) -register_type(int, 'integer', - lambda value: str(value).encode('ascii'), - lambda cls, raw: cls(raw.decode('ascii'))) -register_type(float, 'float', - lambda value: repr(value).encode('ascii'), - lambda cls, raw: cls(raw.decode('ascii'))) +# mypy doesn't allow an abstract class to be passed to Type[], hence the +# suppressions. +register_type(numbers.Real, 'float', # type: ignore + lambda value: repr(float(value)).encode('ascii'), + lambda cls, raw: cls(float(raw.decode('ascii')))) # type: ignore +register_type(numbers.Integral, 'integer', # type: ignore + lambda value: str(int(value)).encode('ascii'), + lambda cls, raw: cls(int(raw.decode('ascii')))) # type: ignore register_type(bool, 'boolean', lambda value: b'1' if value else b'0', _decode_bool) register_type(bytes, 'string', @@ -300,7 +305,6 @@ register_type(Timestamp, 'timestamp', lambda value: repr(value).encode('ascii'), lambda cls, raw: cls(raw.decode('ascii'))) register_type(enum.Enum, 'discrete', _encode_enum, _decode_enum, _default_enum) -register_type(enum.IntEnum, 'discrete', _encode_enum, _decode_enum, _default_enum) def encode(value: Any) -> bytes:	ska-sa/aiokatcp	f5210d50ba01ff27f307f143ccbecaa2f53fa1cd	diff --git a/aiokatcp/test/test_core.py b/aiokatcp/test/test_core.py index 5d6458d..b9c6004 100644 --- a/aiokatcp/test/test_core.py +++ b/aiokatcp/test/test_core.py @@ -28,6 +28,7 @@ import enum import json import ipaddress +from fractions import Fraction import unittest import unittest.mock from typing import Union @@ -43,6 +44,11 @@ class MyEnum(enum.Enum): TWO_FACE = 3 +class MyIntEnum(enum.IntEnum): + A = 1 + B = 2 + + class OverrideEnum(enum.Enum): BATMAN = b'cheese' JOKER = b'carrot' @@ -119,11 +125,13 @@ class TestEncodeDecode(unittest.TestCase): (bool, False, b'0'), (float, -123.5, b'-123.5'), (float, 1e+20, b'1e+20'), + (Fraction, Fraction(5, 4), b'1.25'), (Timestamp, Timestamp(123.5), b'123.5'), (TimestampOrNow, Timestamp(123.5), b'123.5'), (TimestampOrNow, Now.NOW, b'now'), (Address, Address(ipaddress.ip_address('127.0.0.1')), b'127.0.0.1'), (MyEnum, MyEnum.TWO_FACE, b'two-face'), + (MyIntEnum, MyIntEnum.A, b'a'), (OverrideEnum, OverrideEnum.JOKER, b'carrot') ] @@ -132,10 +140,12 @@ class TestEncodeDecode(unittest.TestCase): (bool, b'2'), (int, b'123.0'), (float, b''), + (Fraction, b'5/4'), (Address, b'[127.0.0.1]'), (MyEnum, b'two_face'), (MyEnum, b'TWO-FACE'), (MyEnum, b'bad-value'), + (MyIntEnum, b'z'), (OverrideEnum, b'joker'), (TimestampOrNow, b'later'), (Union[int, float], b'123') @@ -158,7 +168,7 @@ class TestEncodeDecode(unittest.TestCase): msg='{} should not be valid for {}'.format(value, type_)): decode(type_, value) - @unittest.mock.patch.dict('aiokatcp.core._types') # type: ignore + @unittest.mock.patch('aiokatcp.core._types', []) # type: ignore def test_register_type(self) -> None: register_type( dict, 'string',	Improve support for integer-like types The type registration system currently only uses `__mro__`, which means it doesn't work with ABCs like `numbers.Integral`. In Python 3, types like `numpy.int64` don't inherit from `int`, so they currently crash if set as sensor values or otherwise used in katcp messages. One approach is to change the type registration system to work with `isinstance` and to register ABCs instead of concrete classes. That needs some investigation because mypy doesn't work well with the `numbers` ABCs. An alternative is to modify the sensor class to cast value updates to the sensor's registered type. That would fix the problem of setting a sensor to a numpy integer (but with the side effect that reading back the value gives you a different type of object from what you set), but wouldn't help for other messages.	f5210d50ba01ff27f307f143ccbecaa2f53fa1cd	[ "aiokatcp/test/test_core.py::TestEncodeDecode::test_encode", "aiokatcp/test/test_core.py::TestEncodeDecode::test_register_type" ]	[ "aiokatcp/test/test_core.py::TestAddress::test_bytes", "aiokatcp/test/test_core.py::TestAddress::test_eq", "aiokatcp/test/test_core.py::TestAddress::test_getters", "aiokatcp/test/test_core.py::TestAddress::test_hash", "aiokatcp/test/test_core.py::TestAddress::test_not_eq", "aiokatcp/test/test_core.py::TestAddress::test_parse", "aiokatcp/test/test_core.py::TestAddress::test_repr", "aiokatcp/test/test_core.py::TestAddress::test_str", "aiokatcp/test/test_core.py::TestEncodeDecode::test_default", "aiokatcp/test/test_core.py::TestEncodeDecode::test_unknown_class", "aiokatcp/test/test_core.py::TestMessage::test_bytes", "aiokatcp/test/test_core.py::TestMessage::test_bytes_mid", "aiokatcp/test/test_core.py::TestMessage::test_compare", "aiokatcp/test/test_core.py::TestMessage::test_inform", "aiokatcp/test/test_core.py::TestMessage::test_inform_reply", "aiokatcp/test/test_core.py::TestMessage::test_init_bad_mid", "aiokatcp/test/test_core.py::TestMessage::test_init_bad_name", "aiokatcp/test/test_core.py::TestMessage::test_init_basic", "aiokatcp/test/test_core.py::TestMessage::test_init_mid", "aiokatcp/test/test_core.py::TestMessage::test_parse", "aiokatcp/test/test_core.py::TestMessage::test_parse_bad_escape", "aiokatcp/test/test_core.py::TestMessage::test_parse_bad_mid", "aiokatcp/test/test_core.py::TestMessage::test_parse_bad_name", "aiokatcp/test/test_core.py::TestMessage::test_parse_bad_type", "aiokatcp/test/test_core.py::TestMessage::test_parse_cr", "aiokatcp/test/test_core.py::TestMessage::test_parse_empty", "aiokatcp/test/test_core.py::TestMessage::test_parse_leading_whitespace", "aiokatcp/test/test_core.py::TestMessage::test_parse_mid", "aiokatcp/test/test_core.py::TestMessage::test_parse_no_newline", "aiokatcp/test/test_core.py::TestMessage::test_parse_out_of_range_mid", "aiokatcp/test/test_core.py::TestMessage::test_parse_trailing_whitespace", "aiokatcp/test/test_core.py::TestMessage::test_parse_unescaped", "aiokatcp/test/test_core.py::TestMessage::test_reply", "aiokatcp/test/test_core.py::TestMessage::test_reply_ok", "aiokatcp/test/test_core.py::TestMessage::test_reply_to_request", "aiokatcp/test/test_core.py::TestMessage::test_repr", "aiokatcp/test/test_core.py::TestMessage::test_request" ]	{ "failed_lite_validators": [ "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2018-07-10 12:56:21+00:00	bsd-3-clause	5,520
ska-sa__fakenewsredis-3	diff --git a/fakenewsredis.py b/fakenewsredis.py index 6e8fdcc..79930f1 100644 --- a/fakenewsredis.py +++ b/fakenewsredis.py @@ -142,6 +142,18 @@ class _StrKeyDict(MutableMapping): value = self._dict[to_bytes(key)][0] self._dict[to_bytes(key)] = (value, timestamp) + def setx(self, key, value, src=None): + """Set a value, keeping the existing expiry time if any. If + `src` is specified, it is used as the source of the expiry + """ + if src is None: + src = key + try: + _, expiration = self._dict[to_bytes(src)] + except KeyError: + expiration = None + self._dict[to_bytes(key)] = (value, expiration) + def persist(self, key): try: value, _ = self._dict[to_bytes(key)] @@ -294,11 +306,12 @@ class FakeStrictRedis(object): def decr(self, name, amount=1): try: - self._db[name] = to_bytes(int(self._get_string(name, b'0')) - amount) + value = int(self._get_string(name, b'0')) - amount + self._db.setx(name, to_bytes(value)) except (TypeError, ValueError): raise redis.ResponseError("value is not an integer or out of " "range.") - return int(self._db[name]) + return value def exists(self, name): return name in self._db @@ -381,11 +394,12 @@ class FakeStrictRedis(object): if not isinstance(amount, int): raise redis.ResponseError("value is not an integer or out " "of range.") - self._db[name] = to_bytes(int(self._get_string(name, b'0')) + amount) + value = int(self._get_string(name, b'0')) + amount + self._db.setx(name, to_bytes(value)) except (TypeError, ValueError): raise redis.ResponseError("value is not an integer or out of " "range.") - return int(self._db[name]) + return value def incrby(self, name, amount=1): """ @@ -395,10 +409,11 @@ class FakeStrictRedis(object): def incrbyfloat(self, name, amount=1.0): try: - self._db[name] = to_bytes(float(self._get_string(name, b'0')) + amount) + value = float(self._get_string(name, b'0')) + amount + self._db.setx(name, to_bytes(value)) except (TypeError, ValueError): raise redis.ResponseError("value is not a valid float.") - return float(self._db[name]) + return value def keys(self, pattern=None): return [key for key in self._db @@ -457,7 +472,7 @@ class FakeStrictRedis(object): value = self._db[src] except KeyError: raise redis.ResponseError("No such key: %s" % src) - self._db[dst] = value + self._db.setx(dst, value, src=src) del self._db[src] return True @@ -512,7 +527,7 @@ class FakeStrictRedis(object): new_byte = byte_to_int(val[byte]) ^ (1 << actual_bitoffset) reconstructed = bytearray(val) reconstructed[byte] = new_byte - self._db[name] = bytes(reconstructed) + self._db.setx(name, bytes(reconstructed)) def setex(self, name, time, value): if isinstance(time, timedelta): @@ -541,7 +556,7 @@ class FakeStrictRedis(object): if len(val) < offset: val += b'\x00' * (offset - len(val)) val = val[0:offset] + to_bytes(value) + val[offset+len(value):] - self.set(name, val) + self._db.setx(name, val) return len(val) def strlen(self, name): @@ -800,7 +815,7 @@ class FakeStrictRedis(object): end = None else: end += 1 - self._db[name] = val[start:end] + self._db.setx(name, val[start:end]) return True def lindex(self, name, index): @@ -843,7 +858,7 @@ class FakeStrictRedis(object): if el is not None: el = to_bytes(el) dst_list.insert(0, el) - self._db[dst] = dst_list + self._db.setx(dst, dst_list) return el def blpop(self, keys, timeout=0):	ska-sa/fakenewsredis	771b41c2fb00ae84508e5a5df8f8b578b6650ac1	diff --git a/test_fakenewsredis.py b/test_fakenewsredis.py index d60751f..064d24f 100644 --- a/test_fakenewsredis.py +++ b/test_fakenewsredis.py @@ -201,6 +201,11 @@ class TestFakeStrictRedis(unittest.TestCase): with self.assertRaises(redis.ResponseError): self.redis.setbit('foo', 0, 1) + def test_setbit_expiry(self): + self.redis.set('foo', b'0x00', ex=10) + self.redis.setbit('foo', 1, 1) + self.assertGreater(self.redis.ttl('foo'), 0) + def test_bitcount(self): self.redis.delete('foo') self.assertEqual(self.redis.bitcount('foo'), 0) @@ -296,6 +301,11 @@ class TestFakeStrictRedis(unittest.TestCase): self.assertEqual(self.redis.incr('foo', 5), 20) self.assertEqual(self.redis.get('foo'), b'20') + def test_incr_expiry(self): + self.redis.set('foo', 15, ex=10) + self.redis.incr('foo', 5) + self.assertGreater(self.redis.ttl('foo'), 0) + def test_incr_bad_type(self): self.redis.set('foo', 'bar') with self.assertRaises(redis.ResponseError): @@ -326,6 +336,11 @@ class TestFakeStrictRedis(unittest.TestCase): self.assertEqual(self.redis.incrbyfloat('foo', 1.0), 1.0) self.assertEqual(self.redis.incrbyfloat('foo', 1.0), 2.0) + def test_incrbyfloat_expiry(self): + self.redis.set('foo', 1.5, ex=10) + self.redis.incrbyfloat('foo', 2.5) + self.assertGreater(self.redis.ttl('foo'), 0) + def test_incrbyfloat_bad_type(self): self.redis.set('foo', 'bar') with self.assertRaisesRegexp(redis.ResponseError, 'not a valid float'): @@ -348,6 +363,11 @@ class TestFakeStrictRedis(unittest.TestCase): self.redis.decr('foo') self.assertEqual(self.redis.get('foo'), b'-1') + def test_decr_expiry(self): + self.redis.set('foo', 10, ex=10) + self.redis.decr('foo', 5) + self.assertGreater(self.redis.ttl('foo'), 0) + def test_decr_badtype(self): self.redis.set('foo', 'bar') with self.assertRaises(redis.ResponseError): @@ -389,6 +409,12 @@ class TestFakeStrictRedis(unittest.TestCase): self.assertEqual(self.redis.get('foo'), b'unique value') self.assertEqual(self.redis.get('bar'), b'unique value2') + def test_rename_expiry(self): + self.redis.set('foo', 'value1', ex=10) + self.redis.set('bar', 'value2') + self.redis.rename('foo', 'bar') + self.assertGreater(self.redis.ttl('bar'), 0) + def test_mget(self): self.redis.set('foo', 'one') self.redis.set('bar', 'two') @@ -743,6 +769,12 @@ class TestFakeStrictRedis(unittest.TestCase): def test_ltrim_with_non_existent_key(self): self.assertTrue(self.redis.ltrim('foo', 0, -1)) + def test_ltrim_expiry(self): + self.redis.rpush('foo', 'one', 'two', 'three') + self.redis.expire('foo', 10) + self.redis.ltrim('foo', 1, 2) + self.assertGreater(self.redis.ttl('foo'), 0) + def test_ltrim_wrong_type(self): self.redis.set('foo', 'bar') with self.assertRaises(redis.ResponseError): @@ -834,6 +866,13 @@ class TestFakeStrictRedis(unittest.TestCase): self.assertEqual(self.redis.rpoplpush('foo', 'bar'), b'one') self.assertEqual(self.redis.rpop('bar'), b'one') + def test_rpoplpush_expiry(self): + self.redis.rpush('foo', 'one') + self.redis.rpush('bar', 'two') + self.redis.expire('bar', 10) + self.redis.rpoplpush('foo', 'bar') + self.assertGreater(self.redis.ttl('bar'), 0) + def test_rpoplpush_wrong_type(self): self.redis.set('foo', 'bar') self.redis.rpush('list', 'element') @@ -1273,6 +1312,11 @@ class TestFakeStrictRedis(unittest.TestCase): self.assertEqual(self.redis.setrange('bar', 2, 'test'), 6) self.assertEqual(self.redis.get('bar'), b'\x00\x00test') + def test_setrange_expiry(self): + self.redis.set('foo', 'test', ex=10) + self.redis.setrange('foo', 1, 'aste') + self.assertGreater(self.redis.ttl('foo'), 0) + def test_sinter(self): self.redis.sadd('foo', 'member1') self.redis.sadd('foo', 'member2')	Mutating operations incorrectly clear expiry A number of operations modify an existing value, then assign back to `self._db`, which has the side-effect of clearing the expiry time. According to the redis documentation, only operations that completely replace a key (rather than modifying it) clear the expiry. I haven't written any tests yet, but looking at the code, it is probably at least - decr, incr, incrby, incrbyfloat - setbit - ltrim - rpoplpush Some other operations where I'm not sure what redis will do - getset - rename, renamenx	771b41c2fb00ae84508e5a5df8f8b578b6650ac1	[ "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbit_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_setrange_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbit_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setrange_expiry" ]	[ "test_fakenewsredis.py::TestFakeStrictRedis::test_append", "test_fakenewsredis.py::TestFakeStrictRedis::test_append_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_append_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_basic_sort", "test_fakenewsredis.py::TestFakeStrictRedis::test_bitcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_bitcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_blocking_operations_when_empty", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_allow_single_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_single_list", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_single_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpoplpush_multi_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_contains", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_badtype", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_newkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_expire", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_multiple", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_echo", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_sort", "test_fakenewsredis.py::TestFakeStrictRedis::test_exists", "test_fakenewsredis.py::TestFakeStrictRedis::test_flushdb", "test_fakenewsredis.py::TestFakeStrictRedis::test_foo", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_invalid_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_with_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_getbit", "test_fakenewsredis.py::TestFakeStrictRedis::test_getbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_exists", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hdel", "test_fakenewsredis.py::TestFakeStrictRedis::test_hdel_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hexists", "test_fakenewsredis.py::TestFakeStrictRedis::test_hexists_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_empty_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_with_tuples", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_on_non_float_value_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_non_float_amount_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hkeys", "test_fakenewsredis.py::TestFakeStrictRedis::test_hkeys_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hlen", "test_fakenewsredis.py::TestFakeStrictRedis::test_hlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmget", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmget_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_convert_values", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_does_not_mutate_input_params", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmsetset", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmsetset_empty_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hscan", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_then_hget", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_update", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hsetnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_hvals", "test_fakenewsredis.py::TestFakeStrictRedis::test_hvals_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_bad_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_by", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_followed_by_mget", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_followed_by_mget_returns_strings", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_with_float", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_bad_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_with_noexist", "test_fakenewsredis.py::TestFakeStrictRedis::test_key_patterns", "test_fakenewsredis.py::TestFakeStrictRedis::test_lindex", "test_fakenewsredis.py::TestFakeStrictRedis::test_lindex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_after", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_before", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_no_pivot", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen_no_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop_empty_list", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_key_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_then_lrange_all", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_then_lrange_portion", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_with_nonstr_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpushx", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_default_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_positive_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_return_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset_index_out_of_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_with_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget_mixed_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_move_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset_accepts_kwargs", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_msetnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_multidb", "test_fakenewsredis.py::TestFakeStrictRedis::test_multiple_bits_set", "test_fakenewsredis.py::TestFakeStrictRedis::test_multiple_successful_watch_calls", "test_fakenewsredis.py::TestFakeStrictRedis::test_persist", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfmerge", "test_fakenewsredis.py::TestFakeStrictRedis::test_ping", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_ignore_errors", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_non_transactional", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_proxies_to_redis_object", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_raises_when_watched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_succeeds_despite_unwatched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_succeeds_when_watching_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_transaction_shortcut", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_transaction_value_from_callable", "test_fakenewsredis.py::TestFakeStrictRedis::test_pttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_binary_message", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_ignore_sub_messages_listen", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_listen", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_psubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_punsubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_subscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_unsubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_does_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_renamenx_doesnt_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpop", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_to_nonexistent_destination", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list1", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list2", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list3", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpushx", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd_as_str_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_non_ascii_chars_as_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_non_ascii_chars_as_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_unicode_type_as_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_unicode_type_as_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_all_in_single_call", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_multiple_pages", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_multiple_pages_with_match", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_single_page", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_multiple_pages_with_count_arg", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_single", "test_fakenewsredis.py::TestFakeStrictRedis::test_scard", "test_fakenewsredis.py::TestFakeStrictRedis::test_scard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_empty", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_one_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiffstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_None_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_ex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_existing_key_persists", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_float_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_px_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_then_get", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_using_timedelta_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbits_and_getkeys", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_float", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_setitem_getitem", "test_fakenewsredis.py::TestFakeStrictRedis::test_setnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_setrange", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter_bytes_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinterstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_sismember", "test_fakenewsredis.py::TestFakeStrictRedis::test_sismember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_smembers", "test_fakenewsredis.py::TestFakeStrictRedis::test_smembers_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_smove", "test_fakenewsredis.py::TestFakeStrictRedis::test_smove_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_alpha", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_descending", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_norange", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_range_and_desc", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_with_large_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_by_and_get_option", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_hash", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_set", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_store_option", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_spop", "test_fakenewsredis.py::TestFakeStrictRedis::test_spop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember_number", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_srem", "test_fakenewsredis.py::TestFakeStrictRedis::test_srem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sscan", "test_fakenewsredis.py::TestFakeStrictRedis::test_strlen", "test_fakenewsredis.py::TestFakeStrictRedis::test_strlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr_noexist_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunion", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunion_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunionstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_ttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_ttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_unset_bits", "test_fakenewsredis.py::TestFakeStrictRedis::test_watch_state_is_cleared_across_multiple_watches", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_errors", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_multiple", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_uses_str", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zincrby", "test_fakenewsredis.py::TestFakeStrictRedis::test_zincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_max", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_onekey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zlexcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_zlexcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_descending", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_descending_with_scores", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_same_score", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_with_positive_indices", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_slice", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_withscores", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebysore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_numeric_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_negative_indices", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_out_of_bounds", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange_sorted_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_max", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_min", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_sum", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_weights", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_wrong_type", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_immediately_with_millisecond_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_key", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_not_handle_floating_point_values", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_lock", "test_fakenewsredis.py::TestFakeRedis::test_lrem_default_value", "test_fakenewsredis.py::TestFakeRedis::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeRedis::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeRedis::test_lrem_postitive_count", "test_fakenewsredis.py::TestFakeRedis::test_lrem_return_value", "test_fakenewsredis.py::TestFakeRedis::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_expire_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_return_falsey_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_return_truthy_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_psetex_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_psetex_expire_value_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_pttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_pttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_set_ex_should_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_set_nx_doesnt_set_value_twice", "test_fakenewsredis.py::TestFakeRedis::test_set_px_should_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_set_xx_set_value_when_exists", "test_fakenewsredis.py::TestFakeRedis::test_setex", "test_fakenewsredis.py::TestFakeRedis::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_ttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_ttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_ttls_should_always_be_long", "test_fakenewsredis.py::TestFakeRedis::test_zadd_deprecated", "test_fakenewsredis.py::TestFakeRedis::test_zadd_missing_required_params", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_multiple_keypairs", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_name_is_non_string", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_single_keypair", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_basic_sort", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_bitcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_bitcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blocking_operations_when_empty", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_allow_single_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_single_list", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_single_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpoplpush_multi_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_contains", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_badtype", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_newkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_expire", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_multiple", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_echo", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_sort", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_exists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_flushdb", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_foo", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_invalid_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_with_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getbit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_exists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hdel", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hdel_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hexists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hexists_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_empty_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_with_tuples", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_on_non_float_value_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_non_float_amount_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hkeys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hkeys_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hlen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmget_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_convert_values", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_does_not_mutate_input_params", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmsetset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmsetset_empty_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hscan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_then_hget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_update", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hsetnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hvals", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hvals_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_bad_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_by", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_followed_by_mget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_followed_by_mget_returns_strings", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_with_float", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_bad_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_with_noexist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_key_patterns", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lindex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lindex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_after", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_before", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_no_pivot", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen_no_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop_empty_list", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_key_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_then_lrange_all", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_then_lrange_portion", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_with_nonstr_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpushx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_default_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_positive_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_return_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset_index_out_of_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_with_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget_mixed_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_move_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset_accepts_kwargs", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_msetnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multidb", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multiple_bits_set", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multiple_successful_watch_calls", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_persist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfmerge", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ping", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_ignore_errors", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_non_transactional", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_proxies_to_redis_object", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_raises_when_watched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_succeeds_despite_unwatched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_succeeds_when_watching_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_transaction_shortcut", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_transaction_value_from_callable", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_binary_message", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_ignore_sub_messages_listen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_listen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_psubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_punsubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_subscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_unsubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_does_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_renamenx_doesnt_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_to_nonexistent_destination", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list1", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list2", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list3", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpushx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd_as_str_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_non_ascii_chars_as_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_non_ascii_chars_as_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_unicode_type_as_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_unicode_type_as_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_all_in_single_call", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_multiple_pages", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_multiple_pages_with_match", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_single_page", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_multiple_pages_with_count_arg", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_single", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scard", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_empty", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_one_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiffstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_None_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_ex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_existing_key_persists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_float_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_px_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_then_get", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_using_timedelta_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbits_and_getkeys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_float", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setitem_getitem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setrange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter_bytes_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinterstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sismember", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sismember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smembers", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smembers_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smove", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smove_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_alpha", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_descending", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_norange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_range_and_desc", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_with_large_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_by_and_get_option", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_hash", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_set", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_store_option", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_spop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_spop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember_number", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sscan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_strlen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_strlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr_noexist_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunion", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunion_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunionstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_unset_bits", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_watch_state_is_cleared_across_multiple_watches", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_errors", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_multiple", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_uses_str", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zincrby", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_max", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_onekey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zlexcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zlexcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_descending", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_descending_with_scores", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_same_score", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_with_positive_indices", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_slice", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_withscores", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebysore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_numeric_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_negative_indices", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_out_of_bounds", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange_sorted_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_max", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_min", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_sum", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_weights", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_wrong_type", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_immediately_with_millisecond_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_not_handle_floating_point_values", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lock", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_default_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_postitive_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_return_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_expire_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_return_falsey_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_return_truthy_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_psetex_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_psetex_expire_value_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_ex_should_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_nx_doesnt_set_value_twice", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_px_should_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_xx_set_value_when_exists", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_setex", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttls_should_always_be_long", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_deprecated", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_missing_required_params", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_multiple_keypairs", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_name_is_non_string", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_single_keypair", "test_fakenewsredis.py::TestInitArgs::test_can_accept_any_kwargs", "test_fakenewsredis.py::TestInitArgs::test_can_pass_through_extra_args", "test_fakenewsredis.py::TestInitArgs::test_from_url", "test_fakenewsredis.py::TestInitArgs::test_from_url_db_value_error", "test_fakenewsredis.py::TestInitArgs::test_from_url_with_db_arg", "test_fakenewsredis.py::TestImportation::test_searches_for_c_stdlib_and_raises_if_missing" ]	{ "failed_lite_validators": [ "has_many_hunks", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2017-11-12 19:19:04+00:00	bsd-3-clause	5,521
ska-sa__fakenewsredis-8	diff --git a/fakenewsredis.py b/fakenewsredis.py index ce1e1ed..a104150 100644 --- a/fakenewsredis.py +++ b/fakenewsredis.py @@ -510,26 +510,25 @@ class FakeStrictRedis(object): def set(self, name, value, ex=None, px=None, nx=False, xx=False): if (not nx and not xx) or (nx and self._db.get(name, None) is None) \ or (xx and not self._db.get(name, None) is None): - self._db[name] = to_bytes(value) if ex is not None: if isinstance(ex, timedelta): ex = ex.seconds + ex.days * 24 * 3600 - if ex < 0: + if ex <= 0: raise ResponseError('invalid expire time in SETEX') - if ex > 0: - self._db.expire(name, datetime.now() + - timedelta(seconds=ex)) + self._db[name] = to_bytes(value) + self._db.expire(name, datetime.now() + + timedelta(seconds=ex)) elif px is not None: if isinstance(px, timedelta): ms = int(px.microseconds / 1000) px = (px.seconds + px.days * 24 * 3600) * 1000 + ms - if px < 0: + if px <= 0: raise ResponseError('invalid expire time in SETEX') - if px > 0: - self._db.expire(name, datetime.now() + - timedelta(milliseconds=px)) + self._db[name] = to_bytes(value) + self._db.expire(name, datetime.now() + + timedelta(milliseconds=px)) else: - self._db.persist(name) + self._db[name] = to_bytes(value) return True else: return None diff --git a/requirements.txt b/requirements.txt index df48512..12cc5c9 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ # Flake8 3.0.0 does not support Python 2.6. flake8<3.0.0 nose==1.3.4 -redis==2.10.5 +redis==2.10.6	ska-sa/fakenewsredis	0472a6e928d9502f7549b6c829dd86570ec00c0e	diff --git a/test_fakenewsredis.py b/test_fakenewsredis.py index 183591e..403d885 100644 --- a/test_fakenewsredis.py +++ b/test_fakenewsredis.py @@ -501,26 +501,44 @@ class TestFakeStrictRedis(unittest.TestCase): def test_set_raises_wrong_ex(self): with self.assertRaises(ResponseError): self.redis.set('foo', 'bar', ex=-100) + with self.assertRaises(ResponseError): + self.redis.set('foo', 'bar', ex=0) + self.assertFalse(self.redis.exists('foo')) def test_set_using_timedelta_raises_wrong_ex(self): with self.assertRaises(ResponseError): self.redis.set('foo', 'bar', ex=timedelta(seconds=-100)) + with self.assertRaises(ResponseError): + self.redis.set('foo', 'bar', ex=timedelta(seconds=0)) + self.assertFalse(self.redis.exists('foo')) def test_set_raises_wrong_px(self): with self.assertRaises(ResponseError): self.redis.set('foo', 'bar', px=-100) + with self.assertRaises(ResponseError): + self.redis.set('foo', 'bar', px=0) + self.assertFalse(self.redis.exists('foo')) def test_set_using_timedelta_raises_wrong_px(self): with self.assertRaises(ResponseError): self.redis.set('foo', 'bar', px=timedelta(milliseconds=-100)) + with self.assertRaises(ResponseError): + self.redis.set('foo', 'bar', px=timedelta(milliseconds=0)) + self.assertFalse(self.redis.exists('foo')) def test_setex_raises_wrong_ex(self): with self.assertRaises(ResponseError): self.redis.setex('foo', -100, 'bar') + with self.assertRaises(ResponseError): + self.redis.setex('foo', 0, 'bar') + self.assertFalse(self.redis.exists('foo')) def test_setex_using_timedelta_raises_wrong_ex(self): with self.assertRaises(ResponseError): self.redis.setex('foo', timedelta(seconds=-100), 'bar') + with self.assertRaises(ResponseError): + self.redis.setex('foo', timedelta(seconds=-100), 'bar') + self.assertFalse(self.redis.exists('foo')) def test_setnx(self): self.assertEqual(self.redis.setnx('foo', 'bar'), True) @@ -3142,7 +3160,7 @@ class TestFakeRedis(unittest.TestCase): @attr('slow') def test_set_ex_should_expire_value(self): - self.redis.set('foo', 'bar', ex=0) + self.redis.set('foo', 'bar') self.assertEqual(self.redis.get('foo'), b'bar') self.redis.set('foo', 'bar', ex=1) sleep(2)	Update to match redis-py 2.10.6 There are a few unit tests that fail when run against the latest redis-py (2.10.6): ``` ====================================================================== ERROR: test_set_ex_should_expire_value (test_fakenewsredis.TestRealRedis) ---------------------------------------------------------------------- Traceback (most recent call last): File "/home/bmerry/work/sdp/git/fakenewsredis/test_fakenewsredis.py", line 3145, in test_set_ex_should_expire_value self.redis.set('foo', 'bar', ex=0) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 1171, in set return self.execute_command('SET', pieces) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 668, in execute_command return self.parse_response(connection, command_name, options) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 680, in parse_response response = connection.read_response() File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/connection.py", line 629, in read_response raise response ResponseError: invalid expire time in set ====================================================================== ERROR: test_set_ex_should_expire_value (test_fakenewsredis.TestRealRedisDecodeResponses) ---------------------------------------------------------------------- Traceback (most recent call last): File "/home/bmerry/work/sdp/git/fakenewsredis/test_fakenewsredis.py", line 3145, in test_set_ex_should_expire_value self.redis.set('foo', 'bar', ex=0) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 1171, in set return self.execute_command('SET', pieces) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 668, in execute_command return self.parse_response(connection, command_name, **options) File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/client.py", line 680, in parse_response response = connection.read_response() File "/home/bmerry/work/sdp/env/local/lib/python2.7/site-packages/redis/connection.py", line 629, in read_response raise response ResponseError: invalid expire time in set ``` This is due to a change in how a zero expiry time is interpreted.	0472a6e928d9502f7549b6c829dd86570ec00c0e	[ "test_fakenewsredis.py::TestFakeStrictRedis::test_set_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_using_timedelta_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_using_timedelta_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_using_timedelta_raises_wrong_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_raises_wrong_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_timedelta_raises_wrong_ex" ]	[ "test_fakenewsredis.py::TestFakeStrictRedis::test_append", "test_fakenewsredis.py::TestFakeStrictRedis::test_append_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_append_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_basic_sort", "test_fakenewsredis.py::TestFakeStrictRedis::test_bitcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_bitcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_blocking_operations_when_empty", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_allow_single_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_single_list", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedis::test_blpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_single_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpoplpush_multi_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_brpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_contains", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_badtype", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_decr_newkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_expire", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_multiple", "test_fakenewsredis.py::TestFakeStrictRedis::test_delete_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_echo", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_hash", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_list", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_set", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_sort", "test_fakenewsredis.py::TestFakeStrictRedis::test_empty_zset", "test_fakenewsredis.py::TestFakeStrictRedis::test_exists", "test_fakenewsredis.py::TestFakeStrictRedis::test_flushdb", "test_fakenewsredis.py::TestFakeStrictRedis::test_foo", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_invalid_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_get_with_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_getbit", "test_fakenewsredis.py::TestFakeStrictRedis::test_getbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_exists", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_getset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hdel", "test_fakenewsredis.py::TestFakeStrictRedis::test_hdel_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hexists", "test_fakenewsredis.py::TestFakeStrictRedis::test_hexists_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_empty_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_with_tuples", "test_fakenewsredis.py::TestFakeStrictRedis::test_hgetall_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_on_non_float_value_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_non_float_amount_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedis::test_hincrbyfloat_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hkeys", "test_fakenewsredis.py::TestFakeStrictRedis::test_hkeys_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hlen", "test_fakenewsredis.py::TestFakeStrictRedis::test_hlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmget", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmget_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_convert_values", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_does_not_mutate_input_params", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmsetset", "test_fakenewsredis.py::TestFakeStrictRedis::test_hmsetset_empty_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_hscan", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_then_hget", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_update", "test_fakenewsredis.py::TestFakeStrictRedis::test_hset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_hsetnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_hvals", "test_fakenewsredis.py::TestFakeStrictRedis::test_hvals_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_bad_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_by", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_followed_by_mget", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_followed_by_mget_returns_strings", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_with_float", "test_fakenewsredis.py::TestFakeStrictRedis::test_incr_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_bad_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedis::test_incrbyfloat_with_noexist", "test_fakenewsredis.py::TestFakeStrictRedis::test_key_patterns", "test_fakenewsredis.py::TestFakeStrictRedis::test_lindex", "test_fakenewsredis.py::TestFakeStrictRedis::test_lindex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_after", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_before", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_no_pivot", "test_fakenewsredis.py::TestFakeStrictRedis::test_linsert_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen_no_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_llen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop_empty_list", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_key_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_then_lrange_all", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_then_lrange_portion", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_with_nonstr_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpushx", "test_fakenewsredis.py::TestFakeStrictRedis::test_lpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_default_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_positive_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_return_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset_index_out_of_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_lset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_with_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_ltrim_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget_mixed_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_mget_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_move_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset_accepts_kwargs", "test_fakenewsredis.py::TestFakeStrictRedis::test_mset_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_msetnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_multidb", "test_fakenewsredis.py::TestFakeStrictRedis::test_multiple_bits_set", "test_fakenewsredis.py::TestFakeStrictRedis::test_multiple_successful_watch_calls", "test_fakenewsredis.py::TestFakeStrictRedis::test_persist", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_pfmerge", "test_fakenewsredis.py::TestFakeStrictRedis::test_ping", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_ignore_errors", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_non_transactional", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_proxies_to_redis_object", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_raises_when_watched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_succeeds_despite_unwatched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_succeeds_when_watching_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_transaction_shortcut", "test_fakenewsredis.py::TestFakeStrictRedis::test_pipeline_transaction_value_from_callable", "test_fakenewsredis.py::TestFakeStrictRedis::test_pttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_binary_message", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_ignore_sub_messages_listen", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_listen", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_psubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_punsubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_subscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_pubsub_unsubscribe", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_does_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_rename_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_renamenx_doesnt_exist", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpop", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_one_to_self", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_to_nonexistent_destination", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list1", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list2", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_then_lrange_with_nested_list3", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpushx", "test_fakenewsredis.py::TestFakeStrictRedis::test_rpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd_as_str_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_non_ascii_chars_as_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_non_ascii_chars_as_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_unicode_type_as_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_saving_unicode_type_as_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_all_in_single_call", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_multiple_pages", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_multiple_pages_with_match", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_iter_single_page", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_multiple_pages_with_count_arg", "test_fakenewsredis.py::TestFakeStrictRedis::test_scan_single", "test_fakenewsredis.py::TestFakeStrictRedis::test_scard", "test_fakenewsredis.py::TestFakeStrictRedis::test_scard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_empty", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_one_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiff_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sdiffstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_None_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_ex", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_ex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_existing_key_persists", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_float_value", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_px", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_px_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_set_then_get", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbit_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_setbits_and_getkeys", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_float", "test_fakenewsredis.py::TestFakeStrictRedis::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedis::test_setitem_getitem", "test_fakenewsredis.py::TestFakeStrictRedis::test_setnx", "test_fakenewsredis.py::TestFakeStrictRedis::test_setrange", "test_fakenewsredis.py::TestFakeStrictRedis::test_setrange_expiry", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter_bytes_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinter_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sinterstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_sismember", "test_fakenewsredis.py::TestFakeStrictRedis::test_sismember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_smembers", "test_fakenewsredis.py::TestFakeStrictRedis::test_smembers_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_smove", "test_fakenewsredis.py::TestFakeStrictRedis::test_smove_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_alpha", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_descending", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_norange", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_offset_range_and_desc", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_range_with_large_range", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_by_and_get_option", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_hash", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_set", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_with_store_option", "test_fakenewsredis.py::TestFakeStrictRedis::test_sort_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_spop", "test_fakenewsredis.py::TestFakeStrictRedis::test_spop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember_number", "test_fakenewsredis.py::TestFakeStrictRedis::test_srandmember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_srem", "test_fakenewsredis.py::TestFakeStrictRedis::test_srem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sscan", "test_fakenewsredis.py::TestFakeStrictRedis::test_strlen", "test_fakenewsredis.py::TestFakeStrictRedis::test_strlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr_noexist_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_substr_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunion", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunion_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_sunionstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_ttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_ttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_unset_bits", "test_fakenewsredis.py::TestFakeStrictRedis::test_watch_state_is_cleared_across_multiple_watches", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_errors", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_multiple", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_uses_str", "test_fakenewsredis.py::TestFakeStrictRedis::test_zadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zincrby", "test_fakenewsredis.py::TestFakeStrictRedis::test_zincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_max", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_onekey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zinterstore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zlexcount", "test_fakenewsredis.py::TestFakeStrictRedis::test_zlexcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_descending", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_descending_with_scores", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_same_score", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_with_positive_indices", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_slice", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_withscores", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrangebysore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_numeric_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_negative_indices", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_out_of_bounds", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zremrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange_sorted_keys", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zrevrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedis::test_zscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_badkey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_max", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_min", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_sum", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_weights", "test_fakenewsredis.py::TestFakeStrictRedis::test_zunionstore_wrong_type", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_immediately_with_millisecond_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_key", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_not_handle_floating_point_values", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_expire_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_expireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_lock", "test_fakenewsredis.py::TestFakeRedis::test_lrem_default_value", "test_fakenewsredis.py::TestFakeRedis::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeRedis::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeRedis::test_lrem_postitive_count", "test_fakenewsredis.py::TestFakeRedis::test_lrem_return_value", "test_fakenewsredis.py::TestFakeRedis::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_expire_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_return_falsey_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpire_should_return_truthy_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedis::test_pexpireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedis::test_psetex_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_psetex_expire_value_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_pttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_pttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_set_ex_should_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_set_nx_doesnt_set_value_twice", "test_fakenewsredis.py::TestFakeRedis::test_set_px_should_expire_value", "test_fakenewsredis.py::TestFakeRedis::test_set_xx_set_value_when_exists", "test_fakenewsredis.py::TestFakeRedis::test_setex", "test_fakenewsredis.py::TestFakeRedis::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeRedis::test_ttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_ttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedis::test_ttls_should_always_be_long", "test_fakenewsredis.py::TestFakeRedis::test_zadd_deprecated", "test_fakenewsredis.py::TestFakeRedis::test_zadd_missing_required_params", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_multiple_keypairs", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_name_is_non_string", "test_fakenewsredis.py::TestFakeRedis::test_zadd_with_single_keypair", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_append_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_basic_sort", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_bitcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_bitcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blocking_operations_when_empty", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_allow_single_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_single_list", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_blpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_single_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_test_multiple_lists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpoplpush_multi_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_brpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_contains", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_badtype", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_decr_newkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_expire", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_multiple", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_delete_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_echo", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_hash", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_list", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_set", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_sort", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_empty_zset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_exists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_flushdb", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_foo", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_invalid_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_get_with_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getbit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_exists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_getset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hdel", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hdel_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hexists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hexists_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_empty_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_with_tuples", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hgetall_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_on_non_float_value_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_no_starting_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_non_float_amount_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_with_range_param", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hincrbyfloat_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hkeys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hkeys_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hlen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmget_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_convert_values", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_does_not_mutate_input_params", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmsetset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hmsetset_empty_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hscan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_then_hget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_update", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hsetnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hvals", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_hvals_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_bad_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_by", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_followed_by_mget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_followed_by_mget_returns_strings", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_with_float", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incr_with_no_preexisting_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_bad_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_precision", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_incrbyfloat_with_noexist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_key_patterns", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lindex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lindex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_after", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_before", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_no_pivot", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_linsert_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen_no_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_llen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop_empty_list", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_key_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_then_lrange_all", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_then_lrange_portion", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_with_nonstr_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpushx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_default_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_positive_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_return_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset_index_out_of_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_lset_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_with_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ltrim_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget_mixed_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mget_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_move_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset_accepts_kwargs", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_mset_with_no_keys_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_msetnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multidb", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multiple_bits_set", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_multiple_successful_watch_calls", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_persist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pfmerge", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ping", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_ignore_errors", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_non_transactional", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_proxies_to_redis_object", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_raises_when_watched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_succeeds_despite_unwatched_key_changed", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_succeeds_when_watching_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_transaction_shortcut", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pipeline_transaction_value_from_callable", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_binary_message", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_ignore_sub_messages_listen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_listen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_psubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_punsubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_subscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_pubsub_unsubscribe", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_does_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rename_nonexistent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_renamenx_doesnt_exist", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_one_to_self", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_to_nonexistent_destination", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpoplpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list1", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list2", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_then_lrange_with_nested_list3", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpush_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpushx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_rpushx_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd_as_str_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_non_ascii_chars_as_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_non_ascii_chars_as_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_unicode_type_as_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_saving_unicode_type_as_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_all_in_single_call", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_multiple_pages", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_multiple_pages_with_match", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_iter_single_page", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_multiple_pages_with_count_arg", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scan_single", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scard", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_scard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_empty", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_one_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiff_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sdiffstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_None_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_ex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_ex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_existing_key_persists", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_float_value", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_non_str_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_px", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_px_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_set_then_get", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbit_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbit_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setbits_and_getkeys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_float", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setitem_getitem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setnx", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setrange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_setrange_expiry", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter_bytes_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinter_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sinterstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sismember", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sismember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smembers", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smembers_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smove", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_smove_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_alpha", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_descending", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_norange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_offset_range_and_desc", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_range_with_large_range", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_by_and_get_option", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_hash", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_set", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_with_store_option", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sort_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_spop", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_spop_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember_number", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srandmember_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_srem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sscan", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_strlen", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_strlen_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr_noexist_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_substr_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunion", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunion_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_sunionstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ttl_should_return_minus_one_for_non_expiring_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_ttl_should_return_minus_two_for_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_unset_bits", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_watch_state_is_cleared_across_multiple_watches", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_errors", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_multiple", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_uses_str", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zadd_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard_non_existent_key", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcard_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zincrby", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zincrby_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_max", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_onekey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zinterstore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zlexcount", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zlexcount_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_descending", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_descending_with_scores", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_same_score", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_with_positive_indices", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_slice", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_withscores", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrangebysore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_numeric_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrem_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_negative_indices", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_out_of_bounds", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zremrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange_sorted_keys", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrange_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_with_limit", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebylex_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_exclusive", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_raises_error", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrangebyscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zrevrank_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore_non_existent_member", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zscore_wrong_type", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_badkey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_max", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_min", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_mixed_set_types", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_nokey", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_sum", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_weights", "test_fakenewsredis.py::TestFakeStrictRedisDecodeResponses::test_zunionstore_wrong_type", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_immediately_with_millisecond_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_not_handle_floating_point_values", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expire_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_expireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lock", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_default_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_does_not_exist", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_negative_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_postitive_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_return_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_lrem_zero_count", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_expire_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_expire_key_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_return_falsey_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpire_should_return_truthy_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_expire_key_by_datetime", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_expire_key_by_timestamp", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_return_false_for_missing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pexpireat_should_return_true_for_existing_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_psetex_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_psetex_expire_value_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_pttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_ex_should_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_nx_doesnt_set_value_twice", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_px_should_expire_value", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_set_xx_set_value_when_exists", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_setex", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_setex_using_timedelta", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttl_should_return_none_for_non_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttl_should_return_value_for_expiring_key", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_ttls_should_always_be_long", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_deprecated", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_missing_required_params", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_multiple_keypairs", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_name_is_non_string", "test_fakenewsredis.py::TestFakeRedisDecodeResponses::test_zadd_with_single_keypair", "test_fakenewsredis.py::TestInitArgs::test_can_accept_any_kwargs", "test_fakenewsredis.py::TestInitArgs::test_can_pass_through_extra_args", "test_fakenewsredis.py::TestInitArgs::test_from_url", "test_fakenewsredis.py::TestInitArgs::test_from_url_db_value_error", "test_fakenewsredis.py::TestInitArgs::test_from_url_with_db_arg", "test_fakenewsredis.py::TestImportation::test_searches_for_c_stdlib_and_raises_if_missing" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_pytest_match_arg" ], "has_test_patch": true, "is_lite": false }	2018-01-24 14:07:05+00:00	bsd-3-clause	5,522
sklarsa__django-sendgrid-v5-121	diff --git a/dev-requirements.txt b/dev-requirements.txt index 3c341bc..56e4923 100644 --- a/dev-requirements.txt +++ b/dev-requirements.txt @@ -10,5 +10,4 @@ pytest==6.2.5 pytest-cov==3.0.0 tox==3.8.5 twine==3.3.0 -typed-ast==1.5.1 wheel diff --git a/sendgrid_backend/mail.py b/sendgrid_backend/mail.py index dd63787..6e6afb7 100644 --- a/sendgrid_backend/mail.py +++ b/sendgrid_backend/mail.py @@ -471,6 +471,13 @@ class SendgridBackend(BaseEmailBackend): ) ) + if hasattr(msg, "reply_to_list") and SENDGRID_6: + from sendgrid.helpers.mail import ReplyTo + + mail.reply_to_list = [ + ReplyTo(*self._parse_email_address(e)) for e in msg.reply_to_list + ] + if hasattr(msg, "categories"): for cat in msg.categories: mail.add_category(Category(cat))	sklarsa/django-sendgrid-v5	1ced2eb8bb8c7a6eb2299f31ccea5eb817e142b2	diff --git a/test/test_mail.py b/test/test_mail.py index 55ede5e..bb7862a 100644 --- a/test/test_mail.py +++ b/test/test_mail.py @@ -727,3 +727,28 @@ class TestMailGeneration(SimpleTestCase): assert not tracking_settings["click_tracking"]["enable"] assert "ganalytics" in tracking_settings assert tracking_settings["ganalytics"]["utm_source"] == "my-source" + + def test_reply_to_list(self): + msg = EmailMessage( + subject="Hello, World!", + body="Hello, World!", + from_email="Sam Smith <[email protected]>", + to=["John Doe <[email protected]>", "[email protected]"], + cc=["Stephanie Smith <[email protected]>"], + bcc=["Sarah Smith <[email protected]>"], + ) + + msg.reply_to_list = ["John Doe <[email protected]>", "[email protected]"] + + mail = self.backend._build_sg_mail(msg) + + reply_to_list = mail.get("reply_to_list") + if SENDGRID_5: + assert not reply_to_list + else: + assert reply_to_list + assert len(reply_to_list) == 2 + assert reply_to_list[0].get("email") == "[email protected]" + assert reply_to_list[0].get("name") == "John Doe" + assert reply_to_list[1].get("email") == "[email protected]" + assert not reply_to_list[1].get("name")	Add the ability to reply_to_list for Sendgrid Since [this](https://github.com/sendgrid/sendgrid-oai/blob/main/CHANGELOG.md#2021-09-22-version-180) version, SendGrid has incorporated the ability to reply to a list of emails. It would be beneficial to integrate this capability into this library without any workarounds.	1ced2eb8bb8c7a6eb2299f31ccea5eb817e142b2	[ "test/test_mail.py::TestMailGeneration::test_reply_to_list" ]	[ "test/test_mail.py::TestMailGeneration::test_EmailMessage", "test/test_mail.py::TestMailGeneration::test_EmailMessage_attributes", "test/test_mail.py::TestMailGeneration::test_EmailMessage_custom_args", "test/test_mail.py::TestMailGeneration::test_EmailMultiAlternatives", "test/test_mail.py::TestMailGeneration::test_EmailMultiAlternatives__unicode_attachment", "test/test_mail.py::TestMailGeneration::test_asm", "test/test_mail.py::TestMailGeneration::test_build_personalization_errors", "test/test_mail.py::TestMailGeneration::test_dict_to_personalization", "test/test_mail.py::TestMailGeneration::test_mail_config", "test/test_mail.py::TestMailGeneration::test_mime", "test/test_mail.py::TestMailGeneration::test_personalizations_resolution", "test/test_mail.py::TestMailGeneration::test_reply_to", "test/test_mail.py::TestMailGeneration::test_templating_sendgrid", "test/test_mail.py::TestMailGeneration::test_templating_sendgrid_v5", "test/test_mail.py::TestMailGeneration::test_tracking_config" ]	{ "failed_lite_validators": [ "has_short_problem_statement", "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2023-11-08 14:14:08+00:00	mit	5,523
sktime__sktime-3561	diff --git a/sktime/annotation/hmm_learn/base.py b/sktime/annotation/hmm_learn/base.py index e688bdd16..c4b6fb0da 100644 --- a/sktime/annotation/hmm_learn/base.py +++ b/sktime/annotation/hmm_learn/base.py @@ -22,7 +22,7 @@ __all__ = ["BaseHMMLearn"] class BaseHMMLearn(BaseSeriesAnnotator): """Base class for all HMM wrappers, handles required overlap between packages.""" - __tags = { + _tags = { "univariate-only": True, "fit_is_empty": True, "python_dependencies": "hmmlearn", diff --git a/sktime/regression/deep_learning/cnn.py b/sktime/regression/deep_learning/cnn.py index 37d7020af..d7773ef7c 100644 --- a/sktime/regression/deep_learning/cnn.py +++ b/sktime/regression/deep_learning/cnn.py @@ -1,9 +1,11 @@ # -- coding: utf-8 -- """Time Convolutional Neural Network (CNN) for regression.""" -__author__ = ["AurumnPegasus"] +__author__ = ["AurumnPegasus", "achieveordie"] __all__ = ["CNNRegressor"] +from sklearn.utils import check_random_state + from sktime.networks.cnn import CNNNetwork from sktime.regression.deep_learning.base import BaseDeepRegressor from sktime.utils.validation._dependencies import _check_dl_dependencies @@ -34,7 +36,12 @@ class CNNRegressor(BaseDeepRegressor): whether to output extra information loss : string, default="mean_squared_error" fit parameter for the keras model - optimizer : keras.optimizer, default=keras.optimizers.Adam(), + activation : keras.activations or string, default `linear` + function to use in the output layer. + optimizer : keras.optimizers or string, default `None`. + when `None`, internally uses `keras.optimizers.Adam(0.01)` + use_bias : bool, default=True + whether to use bias in the output layer. metrics : list of strings, default=["accuracy"], Notes @@ -58,7 +65,10 @@ class CNNRegressor(BaseDeepRegressor): verbose=False, loss="mean_squared_error", metrics=None, - random_seed=0, + random_state=0, + activation="linear", + use_bias=True, + optimizer=None, ): _check_dl_dependencies(severity="error") super(CNNRegressor, self).__init__( @@ -73,7 +83,11 @@ class CNNRegressor(BaseDeepRegressor): self.verbose = verbose self.loss = loss self.metrics = metrics - self.random_seed = random_seed + self.random_state = random_state + self.activation = activation + self.use_bias = use_bias + self.optimizer = optimizer + self.history = None self._network = CNNNetwork() def build_model(self, input_shape, kwargs): @@ -96,7 +110,7 @@ class CNNRegressor(BaseDeepRegressor): import tensorflow as tf from tensorflow import keras - tf.random.set_seed(self.random_seed) + tf.random.set_seed(self.random_state) if self.metrics is None: metrics = ["accuracy"] @@ -105,13 +119,23 @@ class CNNRegressor(BaseDeepRegressor): input_layer, output_layer = self._network.build_network(input_shape, kwargs) - output_layer = keras.layers.Dense(units=1, activation="sigmoid")(output_layer) + output_layer = keras.layers.Dense( + units=1, + activation=self.activation, + use_bias=self.use_bias, + )(output_layer) + + self.optimizer_ = ( + keras.optimizers.Adam(learning_rate=0.01) + if self.optimizer is None + else self.optimizer + ) model = keras.models.Model(inputs=input_layer, outputs=output_layer) model.compile( loss=self.loss, - optimizer=keras.optimizers.Adam(), + optimizer=self.optimizer_, metrics=metrics, ) return model @@ -136,6 +160,7 @@ class CNNRegressor(BaseDeepRegressor): # Transpose to conform to Keras input style. X = X.transpose(0, 2, 1) + check_random_state(self.random_state) self.input_shape = X.shape[1:] self.model_ = self.build_model(self.input_shape) if self.verbose: diff --git a/sktime/transformations/hierarchical/aggregate.py b/sktime/transformations/hierarchical/aggregate.py index 9e32e6482..79fb305e2 100644 --- a/sktime/transformations/hierarchical/aggregate.py +++ b/sktime/transformations/hierarchical/aggregate.py @@ -147,7 +147,7 @@ class Aggregator(BaseTransformer): df_out.reset_index(level=-1).loc[new_index].set_index(nm, append=True) ).rename_axis(X.index.names, axis=0) - df_out.sort_index(inplace=True) + df_out = df_out.sort_index() return df_out diff --git a/sktime/utils/sampling.py b/sktime/utils/sampling.py index de6f7dcab..bfe8581cf 100644 --- a/sktime/utils/sampling.py +++ b/sktime/utils/sampling.py @@ -26,7 +26,7 @@ def stratified_resample(X_train, y_train, X_test, y_test, random_state): X_test : pd.DataFrame test data attributes in sktime pandas format. y_test : np.array - test data class labes as np array. + test data class labels as np array. random_state : int seed to enable reproducable resamples Returns @@ -71,12 +71,9 @@ def stratified_resample(X_train, y_train, X_test, y_test, random_state): X_test = pd.concat([X_test, test_instances]) y_train = np.concatenate([y_train, train_labels], axis=None) y_test = np.concatenate([y_test, test_labels], axis=None) - # get the counts of the new train and test resample - unique_train_new, counts_train_new = np.unique(y_train, return_counts=True) - unique_test_new, counts_test_new = np.unique(y_test, return_counts=True) - # make sure they match the original distribution of data - assert list(counts_train_new) == list(counts_train) - assert list(counts_test_new) == list(counts_test) + # reset indexes to conform to sktime format. + X_train = X_train.reset_index(drop=True) + X_test = X_test.reset_index(drop=True) return X_train, y_train, X_test, y_test	sktime/sktime	13239f38ec9ac8157f70aa2c70487c7978e38ac9	diff --git a/sktime/benchmarking/tests/test_experiments.py b/sktime/benchmarking/tests/test_experiments.py index 968078fac..e065cdd0a 100644 --- a/sktime/benchmarking/tests/test_experiments.py +++ b/sktime/benchmarking/tests/test_experiments.py @@ -65,25 +65,3 @@ def test_run_classification_experiment(tmp_path): # remove files test_path.unlink() train_path.unlink() - - -# def test_load_and_run_clustering_experiment(): -# """Test loading, running and saving. -# -# Currently it just checks that the files have been created, then deletes them. -# Later it can be enhanced to check the results can be loaded. -# """ -# load_and_run_clustering_experiment( -# overwrite=True, -# problem_path="../../datasets/data/", -# results_path="../Temp/", -# cls_name="kmeans", -# dataset="UnitTest", -# resample_id=0, -# train_file=True, -# ) -# assert os.path.isfile("../Temp/kmeans/Predictions/UnitTest/testResample0.csv") -# assert os.path.isfile("../Temp/kmeans/Predictions/UnitTest/trainResample0.csv") -# os.remove("../Temp/kmeans/Predictions/UnitTest/testResample0.csv") -# os.remove("../Temp/kmeans/Predictions/UnitTest/trainResample0.csv") -# diff --git a/sktime/utils/tests/test_sampling.py b/sktime/utils/tests/test_sampling.py index 3d17cca37..85fca8bfb 100644 --- a/sktime/utils/tests/test_sampling.py +++ b/sktime/utils/tests/test_sampling.py @@ -1,10 +1,13 @@ # -- coding: utf-8 -- """Testing sampling utilities.""" +import numpy as np import pytest +from sktime.datasets import load_unit_test +from sktime.datatypes import check_is_scitype from sktime.utils._testing.deep_equals import deep_equals -from sktime.utils.sampling import random_partition +from sktime.utils.sampling import random_partition, stratified_resample NK_FIXTURES = [(10, 3), (15, 5), (19, 6), (3, 1), (1, 2)] SEED_FIXTURES = [42, 0, 100, -5] @@ -42,3 +45,23 @@ def test_seed(n, k, seed): part2 = random_partition(n, k, seed) assert deep_equals(part, part2) + + +def test_stratified_resample(): + """Test resampling returns valid data structure and maintains class distribution.""" + trainX, trainy = load_unit_test(split="TRAIN") + testX, testy = load_unit_test(split="TEST") + new_trainX, new_trainy, new_testX, new_testy = stratified_resample( + trainX, trainy, testX, testy, 0 + ) + + valid_train = check_is_scitype(new_trainX, scitype="Panel") + valid_test = check_is_scitype(new_testX, scitype="Panel") + assert valid_test and valid_train + # count class occurrences + unique_train, counts_train = np.unique(trainy, return_counts=True) + unique_test, counts_test = np.unique(testy, return_counts=True) + unique_train_new, counts_train_new = np.unique(new_trainy, return_counts=True) + unique_test_new, counts_test_new = np.unique(new_testy, return_counts=True) + assert list(counts_train_new) == list(counts_train) + assert list(counts_test_new) == list(counts_test)	[BUG] `CNNRegressor` missing essential initializing parameters Describe the bug <!-- A clear and concise description of what the bug is. --> `CNNRegressor` misses parameters like `optimizer` in its constructor. There might be more things which don't coincide with `CNNClassifier` which should be added but since I'm not sure what all things might be missing, I'm opening this issue to bring it to notice.	13239f38ec9ac8157f70aa2c70487c7978e38ac9	[ "sktime/utils/tests/test_sampling.py::test_stratified_resample" ]	[ "sktime/utils/tests/test_sampling.py::test_partition[15-5]", "sktime/utils/tests/test_sampling.py::test_seed[19-6-100]", "sktime/utils/tests/test_sampling.py::test_seed[3-1-100]", "sktime/utils/tests/test_sampling.py::test_seed[3-1-0]", "sktime/utils/tests/test_sampling.py::test_seed[3-1-42]", "sktime/utils/tests/test_sampling.py::test_partition[3-1]", "sktime/utils/tests/test_sampling.py::test_seed[1-2-0]", "sktime/utils/tests/test_sampling.py::test_seed[19-6--5]", "sktime/utils/tests/test_sampling.py::test_seed[10-3-42]", "sktime/utils/tests/test_sampling.py::test_seed[10-3-0]", "sktime/utils/tests/test_sampling.py::test_seed[19-6-0]", "sktime/utils/tests/test_sampling.py::test_seed[15-5-42]", "sktime/utils/tests/test_sampling.py::test_partition[19-6]", "sktime/utils/tests/test_sampling.py::test_seed[3-1--5]", "sktime/utils/tests/test_sampling.py::test_seed[19-6-42]", "sktime/utils/tests/test_sampling.py::test_seed[15-5--5]", "sktime/utils/tests/test_sampling.py::test_seed[10-3--5]", "sktime/utils/tests/test_sampling.py::test_seed[10-3-100]", "sktime/utils/tests/test_sampling.py::test_seed[1-2-42]", "sktime/utils/tests/test_sampling.py::test_partition[10-3]", "sktime/utils/tests/test_sampling.py::test_partition[1-2]", "sktime/utils/tests/test_sampling.py::test_seed[1-2--5]", "sktime/utils/tests/test_sampling.py::test_seed[15-5-0]", "sktime/utils/tests/test_sampling.py::test_seed[1-2-100]", "sktime/utils/tests/test_sampling.py::test_seed[15-5-100]", "sktime/benchmarking/tests/test_experiments.py::test_run_classification_experiment", "sktime/benchmarking/tests/test_experiments.py::test_run_clustering_experiment" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-10-10 05:54:30+00:00	bsd-3-clause	5,524
sktime__sktime-3927	diff --git a/docs/source/get_started.rst b/docs/source/get_started.rst index ce8ab2dd6..0e6ffc82d 100644 --- a/docs/source/get_started.rst +++ b/docs/source/get_started.rst @@ -124,7 +124,7 @@ Time Series Clustering >>> from sklearn.model_selection import train_test_split >>> from sktime.clustering.k_means import TimeSeriesKMeans - >>> from sktime.clustering.evaluation._plot_clustering import plot_cluster_algorithm + >>> from sktime.clustering.utils.plotting._plot_partitions import plot_cluster_algorithm >>> from sktime.datasets import load_arrow_head >>> X, y = load_arrow_head() diff --git a/sktime/classification/distance_based/_time_series_neighbors.py b/sktime/classification/distance_based/_time_series_neighbors.py index 04eabd93f..cf5d91cd7 100644 --- a/sktime/classification/distance_based/_time_series_neighbors.py +++ b/sktime/classification/distance_based/_time_series_neighbors.py @@ -263,6 +263,9 @@ class KNeighborsTimeSeriesClassifier(BaseClassifier): """ self.check_is_fitted() + # boilerplate input checks for predict-like methods + X = self._check_convert_X_for_predict(X) + # self._X should be the stored _X dist_mat = self._distance(X, self._X) diff --git a/sktime/regression/distance_based/_time_series_neighbors.py b/sktime/regression/distance_based/_time_series_neighbors.py index 9e286cb2d..7d8e41290 100644 --- a/sktime/regression/distance_based/_time_series_neighbors.py +++ b/sktime/regression/distance_based/_time_series_neighbors.py @@ -210,6 +210,11 @@ class KNeighborsTimeSeriesRegressor(BaseRegressor): ind : array Indices of the nearest points in the population matrix. """ + self.check_is_fitted() + + # boilerplate input checks for predict-like methods + X = self._check_convert_X_for_predict(X) + # self._X should be the stored _X dist_mat = self._distance(X, self._X) diff --git a/sktime/transformations/series/detrend/_detrend.py b/sktime/transformations/series/detrend/_detrend.py index b1a32cae9..4a5e84eca 100644 --- a/sktime/transformations/series/detrend/_detrend.py +++ b/sktime/transformations/series/detrend/_detrend.py @@ -4,7 +4,7 @@ """Implements transformations to detrend a time series.""" __all__ = ["Detrender"] -__author__ = ["mloning", "SveaMeyer13"] +__author__ = ["mloning", "SveaMeyer13", "KishManani"] import pandas as pd @@ -38,6 +38,11 @@ class Detrender(BaseTransformer): The forecasting model to remove the trend with (e.g. PolynomialTrendForecaster). If forecaster is None, PolynomialTrendForecaster(degree=1) is used. + model : {"additive", "multiplicative"}, default="additive" + If `model="additive"` the `forecaster` is fit to the original time + series and the `transform` method subtracts the trend from the time series. + If `model="multiplicative"` the `forecaster` is fit to the original time + series and the `transform` method divides the trend from the time series. Attributes ---------- @@ -74,8 +79,9 @@ class Detrender(BaseTransformer): "transform-returns-same-time-index": True, } - def __init__(self, forecaster=None): + def __init__(self, forecaster=None, model="additive"): self.forecaster = forecaster + self.model = model self.forecaster_ = None super(Detrender, self).__init__() @@ -118,6 +124,10 @@ class Detrender(BaseTransformer): else: raise TypeError("X must be pd.Series or pd.DataFrame") + allowed_models = ("additive", "multiplicative") + if self.model not in allowed_models: + raise ValueError("`model` must be 'additive' or 'multiplicative'") + return self def _transform(self, X, y=None): @@ -143,8 +153,10 @@ class Detrender(BaseTransformer): if isinstance(X, pd.Series): # note: the y in the transformer is exogeneous in the forecaster, i.e., X X_pred = self.forecaster_.predict(fh=fh, X=y) - Xt = X - X_pred - return Xt + if self.model == "additive": + return X - X_pred + elif self.model == "multiplicative": + return X / X_pred # multivariate: X is pd.DataFrame elif isinstance(X, pd.DataFrame): Xt = X.copy() @@ -159,7 +171,10 @@ class Detrender(BaseTransformer): ) for colname in Xt.columns: X_pred = self.forecaster_[colname].predict(fh=fh, X=y) - Xt[colname] = Xt[colname] - X_pred + if self.model == "additive": + Xt[colname] = Xt[colname] - X_pred + elif self.model == "multiplicative": + Xt[colname] = Xt[colname] / X_pred return Xt else: raise TypeError("X must be pd.Series or pd.DataFrame") @@ -185,7 +200,10 @@ class Detrender(BaseTransformer): if isinstance(X, pd.Series): # note: the y in the transformer is exogeneous in the forecaster, i.e., X X_pred = self.forecaster_.predict(fh=fh, X=y) - return X + X_pred + if self.model == "additive": + return X + X_pred + elif self.model == "multiplicative": + return X * X_pred # multivariate: X is pd.DataFrame if isinstance(X, pd.DataFrame): X = X.copy() @@ -200,7 +218,11 @@ class Detrender(BaseTransformer): ) for colname in X.columns: X_pred = self.forecaster_[colname].predict(fh=fh, X=y) - X[colname] = X[colname] + X_pred + if self.model == "additive": + X[colname] = X[colname] + X_pred + elif self.model == "multiplicative": + X[colname] = X[colname] * X_pred + return X def _update(self, X, y=None, update_params=True):	sktime/sktime	c10cedbf3135d0fa791bb146adf8172dd676f0d4	diff --git a/sktime/classification/distance_based/tests/test_time_series_neighbors.py b/sktime/classification/distance_based/tests/test_time_series_neighbors.py index 60bf880ea..de7afd851 100644 --- a/sktime/classification/distance_based/tests/test_time_series_neighbors.py +++ b/sktime/classification/distance_based/tests/test_time_series_neighbors.py @@ -1,6 +1,7 @@ # -- coding: utf-8 -- -"""Test function of elastic distance nearest neighbour classifiers.""" +"""Tests for KNeighborsTimeSeriesClassifier.""" import numpy as np +import pandas as pd import pytest from sktime.alignment.dtw_python import AlignerDTW @@ -109,3 +110,26 @@ def test_knn_with_aggrdistance(): clf = KNeighborsTimeSeriesClassifier(distance=aggr_dist) clf.fit(X, y) + + +def test_knn_kneighbors(): + """Tests kneighbors method and absence of bug #3798.""" + from sktime.utils._testing.hierarchical import _make_hierarchical + + Xtrain = _make_hierarchical(hierarchy_levels=(3,), n_columns=3) + Xtest = _make_hierarchical(hierarchy_levels=(5,), n_columns=3) + + ytrain = pd.Series(["label_1", "label_2", "label_3"]) + + kntsc = KNeighborsTimeSeriesClassifier(n_neighbors=1) + kntsc.fit(Xtrain, ytrain) + + ret = kntsc.kneighbors(Xtest) + assert isinstance(ret, tuple) + assert len(ret) == 2 + + dist, ind = ret + assert isinstance(dist, np.ndarray) + assert dist.shape == (5, 1) + assert isinstance(ind, np.ndarray) + assert ind.shape == (5, 1) diff --git a/sktime/regression/distance_based/tests/__init__.py b/sktime/regression/distance_based/tests/__init__.py new file mode 100644 index 000000000..18fca48ad --- /dev/null +++ b/sktime/regression/distance_based/tests/__init__.py @@ -0,0 +1,2 @@ +# -- coding: utf-8 -- +"""Distance based test code.""" diff --git a/sktime/regression/distance_based/tests/test_time_series_neighbors.py b/sktime/regression/distance_based/tests/test_time_series_neighbors.py new file mode 100644 index 000000000..6be87cc9c --- /dev/null +++ b/sktime/regression/distance_based/tests/test_time_series_neighbors.py @@ -0,0 +1,31 @@ +# -- coding: utf-8 -- +"""Tests for KNeighborsTimeSeriesRegressor.""" +import numpy as np +import pandas as pd + +from sktime.regression.distance_based._time_series_neighbors import ( + KNeighborsTimeSeriesRegressor, +) + + +def test_knn_kneighbors(): + """Tests kneighbors method and absence of bug #3798.""" + from sktime.utils._testing.hierarchical import _make_hierarchical + + Xtrain = _make_hierarchical(hierarchy_levels=(3,), n_columns=3) + Xtest = _make_hierarchical(hierarchy_levels=(5,), n_columns=3) + + ytrain = pd.Series([1, 1.5, 2]) + + kntsc = KNeighborsTimeSeriesRegressor(n_neighbors=1) + kntsc.fit(Xtrain, ytrain) + + ret = kntsc.kneighbors(Xtest) + assert isinstance(ret, tuple) + assert len(ret) == 2 + + dist, ind = ret + assert isinstance(dist, np.ndarray) + assert dist.shape == (5, 1) + assert isinstance(ind, np.ndarray) + assert ind.shape == (5, 1) diff --git a/sktime/transformations/series/detrend/tests/test_detrend.py b/sktime/transformations/series/detrend/tests/test_detrend.py index 4641a3427..50ff9e676 100644 --- a/sktime/transformations/series/detrend/tests/test_detrend.py +++ b/sktime/transformations/series/detrend/tests/test_detrend.py @@ -1,17 +1,29 @@ # -- coding: utf-8 -- """Test detrenders.""" +import numpy as np +import pandas as pd +import pytest -__author__ = ["mloning"] +from sktime.datasets import load_airline +from sktime.forecasting.tests.test_trend import get_expected_polynomial_coefs +from sktime.forecasting.trend import PolynomialTrendForecaster +from sktime.transformations.series.detrend import Detrender + +__author__ = ["mloning", "KishManani"] __all__ = [] -def test_polynomial_detrending(): - import numpy as np - import pandas as pd [email protected]() +def y_series(): + return load_airline() + - from sktime.forecasting.tests.test_trend import get_expected_polynomial_coefs - from sktime.forecasting.trend import PolynomialTrendForecaster - from sktime.transformations.series.detrend import Detrender [email protected]() +def y_dataframe(): + return load_airline().to_frame() + + +def test_polynomial_detrending(): y = pd.Series(np.arange(20) * 0.5) + np.random.normal(0, 1, size=20) forecaster = PolynomialTrendForecaster(degree=1, with_intercept=True) @@ -34,3 +46,79 @@ def test_polynomial_detrending(): actual = transformer.transform(y) expected = y - expected_trend np.testing.assert_array_almost_equal(actual, expected) + + +def test_multiplicative_detrending_series(y_series): + """Tests we get the expected result when setting `model=multiplicative`.""" + # Load test dataset + y = y_series + + # Get the trend + forecaster = PolynomialTrendForecaster(degree=1, with_intercept=True) + trend = forecaster.fit_predict(y, fh=y.index) + + # De-trend the time series + detrender = Detrender(forecaster, model="multiplicative") + y_transformed = detrender.fit_transform(y) + + # Compute the expected de-trended time series + expected = y / trend + + pd.testing.assert_series_equal(y_transformed, expected) + + +def test_multiplicative_detrending_dataframe(y_dataframe): + """Tests we get the expected result when setting `model=multiplicative`.""" + # Load test dataset + y = y_dataframe + + # Get the trend + forecaster = PolynomialTrendForecaster(degree=1, with_intercept=True) + trend = forecaster.fit_predict(y, fh=y.index) + + # De-trend the time series + detrender = Detrender(forecaster, model="multiplicative") + y_transformed = detrender.fit_transform(y) + + # Compute the expected de-trended time series + expected = y / trend + + pd.testing.assert_frame_equal(y_transformed, expected) + + +def test_additive_detrending_series(y_series): + """Tests we get the expected result when setting `model=additive`.""" + # Load test dataset + y = y_series + + # Get the trend + forecaster = PolynomialTrendForecaster(degree=1, with_intercept=True) + trend = forecaster.fit_predict(y, fh=y.index) + + # De-trend the time series + detrender = Detrender(forecaster, model="additive") + y_transformed = detrender.fit_transform(y) + + # Compute the expected de-trended time series + expected = y - trend + + pd.testing.assert_series_equal(y_transformed, expected) + + +def test_additive_detrending_dataframe(y_dataframe): + """Tests we get the expected result when setting `model=additive`.""" + # Load test dataset + y = y_dataframe + + # Get the trend + forecaster = PolynomialTrendForecaster(degree=1, with_intercept=True) + trend = forecaster.fit_predict(y, fh=y.index) + + # De-trend the time series + detrender = Detrender(forecaster, model="additive") + y_transformed = detrender.fit_transform(y) + + # Compute the expected de-trended time series + expected = y - trend + + pd.testing.assert_frame_equal(y_transformed, expected)	[BUG] 'kneighbors' method of KNeighborsTimeSeriesClassifier results in TypingError Describe the bug After a KNeighborsTimeSeriesClassifier has been successfully fit and successfully used to classify toy data, an attempt to use the 'kneighbors' method fails due to a TypingError. The method should return the indices of and distances to the neighbors of each point. To Reproduce ```python from sktime.classification.distance_based import KNeighborsTimeSeriesClassifier from sktime.datatypes import convert_to Xtrain = convert_to(pd.DataFrame(data = { 'sensor_a': [pd.Series([1,1,1]), pd.Series([2,2,2]), pd.Series([3,3,3])], 'sensor_b': [pd.Series([4,4,4]), pd.Series([5,5,5]), pd.Series([6,6,6])], 'sensor_c': [pd.Series([7,7,7]), pd.Series([8,8,8]), pd.Series([9,9,9])], }), 'pd-multiindex') ytrain = pd.Series(['label_1','label_2','label_3']) kntsc = KNeighborsTimeSeriesClassifier(n_neighbors = 1) kntsc.fit(Xtrain, ytrain) Xtest = convert_to(pd.DataFrame({ 'sensor_a': [pd.Series([2.1,2,2]), pd.Series([1.1,1,1]), pd.Series([3.1,3,3])], 'sensor_b': [pd.Series([5.1,5,5]), pd.Series([4.1,4,4]), pd.Series([6.1,6,6])], 'sensor_c': [pd.Series([8.1,8,8]), pd.Series([7.1,7,7]), pd.Series([9.1,9,9])] }), 'pd-multiindex') display(kntsc.predict(Xtest)) print(kntsc.kneighbors(Xtest)) ``` Expected behavior The final line should print the indices of and distances to the neighbors of each point. Additional context The 'fit' and 'predict' function correctly. The 'kneighbors' method returns the equivalent of an intermediate step of the 'predict' method. The code provided has data in the 'pd-multiindex' mtype. The original code was written for data in 'nested_univ' mtype, and removing the 'convert_to' will demonstrate that the 'kneighbors' method doesn't work for 'nested_univ' mtype either. I had used the 'kneighbors' method of sklearn.neighbors.KNeighborsClassifier in the code that I have been refactoring to use with sktime. The panel data format in my previous code was my own inefficient design and the code I wrote to handle it with sklearn pipelines is too lengthy and convoluted to provide here. However, sktime's KNeighborsTimeSeriesClassifier is described in the DocString as "An adapted version of the scikit-learn KNeighborsClassifier for time series data," so it should function the same way. This is the call stack trace: (also, each time the Jupyter notebook cell is executed, the last two lines are repeated an additional time) ```python --------------------------------------------------------------------------- TypingError Traceback (most recent call last) Cell In [43], line 31 23 Xtest = convert_to(pd.DataFrame({ 24 'sensor_a': [pd.Series([2.1,2,2]), pd.Series([1.1,1,1]), pd.Series([3.1,3,3])], 25 'sensor_b': [pd.Series([5.1,5,5]), pd.Series([4.1,4,4]), pd.Series([6.1,6,6])], 26 'sensor_c': [pd.Series([8.1,8,8]), pd.Series([7.1,7,7]), pd.Series([9.1,9,9])] 27 }), 'pd-multiindex') 29 display(kntsc.predict(Xtest)) ---> 31 kntsc.kneighbors(Xtest) File ~\Anaconda3\envs\capstone_20221111\lib\site-packages\sktime\classification\distance_based\_time_series_neighbors.py:267, in KNeighborsTimeSeriesClassifier.kneighbors(self, X, n_neighbors, return_distance) 264 self.check_is_fitted() 266 # self._X should be the stored _X --> 267 dist_mat = self._distance(X, self._X) 269 result = self.knn_estimator_.kneighbors( 270 dist_mat, n_neighbors=n_neighbors, return_distance=return_distance 271 ) 273 # result is either dist, or (dist, ind) pair, depending on return_distance File ~\Anaconda3\envs\capstone_20221111\lib\site-packages\sktime\classification\distance_based\_time_series_neighbors.py:199, in KNeighborsTimeSeriesClassifier._distance(self, X, X2) 196 distance_params = {} 198 if isinstance(distance, str): --> 199 return pairwise_distance(X, X2, distance, distance_params) 200 else: 201 if X2 is not None: File ~\Anaconda3\envs\capstone_20221111\lib\site-packages\sktime\distances\_distance.py:2050, in pairwise_distance(x, y, metric, kwargs) 1960 def pairwise_distance( 1961 x: np.ndarray, 1962 y: np.ndarray = None, (...) 1971 *kwargs: Any, 1972 ) -> np.ndarray: 1973 """Compute the pairwise distance matrix between two time series. 1974 1975 First the distance metric is 'resolved'. This means the metric that is passed (...) 2048 [ 58., 256.]]) 2049 """ -> 2050 _x = _make_3d_series(x) 2051 if y is None: 2052 y = x File ~\Anaconda3\envs\capstone_20221111\lib\site-packages\numba\core\dispatcher.py:468, in _DispatcherBase._compile_for_args(self, args, kws) 464 msg = (f"{str(e).rstrip()} \n\nThis error may have been caused " 465 f"by the following argument(s):\n{args_str}\n") 466 e.patch_message(msg) --> 468 error_rewrite(e, 'typing') 469 except errors.UnsupportedError as e: 470 # Something unsupported is present in the user code, add help info 471 error_rewrite(e, 'unsupported_error') File ~\Anaconda3\envs\capstone_20221111\lib\site-packages\numba\core\dispatcher.py:409, in _DispatcherBase._compile_for_args.<locals>.error_rewrite(e, issue_type) 407 raise e 408 else: --> 409 raise e.with_traceback(None) TypingError: Failed in nopython mode pipeline (step: nopython frontend) non-precise type pyobject During: typing of argument at C:\Users\wechs\Anaconda3\envs\capstone_20221111\lib\site-packages\sktime\distances\_numba_utils.py (34) File "..\..\..\..\Anaconda3\envs\capstone_20221111\lib\site-packages\sktime\distances\_numba_utils.py", line 34: def _make_3d_series(x: np.ndarray) -> np.ndarray: <source elided> """ num_dims = x.ndim ^ This error may have been caused by the following argument(s): - argument 0: Cannot determine Numba type of <class 'pandas.core.frame.DataFrame'> ``` Versions** System: python: 3.9.13 \| packaged by conda-forge \| (main, May 27 2022, 16:51:29) [MSC v.1929 64 bit (AMD64)] executable: C:\Users\wechs\Anaconda3\envs\capstone_20221111\python.exe machine: Windows-10-10.0.19044-SP0 Python dependencies: pip: 22.3.1 setuptools: 65.5.1 sklearn: 1.1.3 sktime: 0.14.0 statsmodels: 0.13.5 numpy: 1.23.3 scipy: 1.9.3 pandas: 1.4.4 matplotlib: 3.5.3 joblib: 1.2.0 numba: 0.56.3 pmdarima: 2.0.1 tsfresh: 0.19.0 <!-- Thanks for contributing! -->	c10cedbf3135d0fa791bb146adf8172dd676f0d4	[ "sktime/transformations/series/detrend/tests/test_detrend.py::test_multiplicative_detrending_series", "sktime/transformations/series/detrend/tests/test_detrend.py::test_additive_detrending_series", "sktime/transformations/series/detrend/tests/test_detrend.py::test_additive_detrending_dataframe", "sktime/transformations/series/detrend/tests/test_detrend.py::test_multiplicative_detrending_dataframe", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_kneighbors", "sktime/regression/distance_based/tests/test_time_series_neighbors.py::test_knn_kneighbors" ]	[ "sktime/transformations/series/detrend/tests/test_detrend.py::test_polynomial_detrending", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_with_aggrdistance", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[euclidean]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[lcss]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[euclidean]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[wdtw]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[erp]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[edr]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[wdtw]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[msm]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[dtw]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[edr]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[erp]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[msm]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_on_unit_test[dtw]", "sktime/classification/distance_based/tests/test_time_series_neighbors.py::test_knn_bounding_matrix[lcss]" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2022-12-12 00:31:53+00:00	bsd-3-clause	5,525
sktime__sktime-4681	diff --git a/docs/source/conf.py b/docs/source/conf.py index be43df43a..21b7f73e4 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -49,6 +49,7 @@ extensions = [ "myst_parser", "sphinx_design", "sphinx_issues", + "versionwarning.extension", ] # Recommended by sphinx_design when using the MyST Parser @@ -435,3 +436,15 @@ intersphinx_mapping = { # -- Options for _todo extension ---------------------------------------------- todo_include_todos = False + +# sphinx-version-warning config +versionwarning_messages = { + "latest": ( + "This document is for the development version. " + 'For the stable version documentation, see <a href="/en/stable/">here</a>.' + ) +} + +# Show warning at top of page +versionwarning_body_selector = "div.document" +versionwarning_banner_title = "" diff --git a/pyproject.toml b/pyproject.toml index 9f31dc096..93acba733 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -128,6 +128,7 @@ docs = [ "sphinx_issues==1.2.0", "sphinx-gallery==0.6.0", "sphinx-design==0.3.0", + "sphinx-version-warning", "sphinx==4.1.1", "tabulate", ] diff --git a/sktime/forecasting/base/_base.py b/sktime/forecasting/base/_base.py index e09e0ff28..c25c19d28 100644 --- a/sktime/forecasting/base/_base.py +++ b/sktime/forecasting/base/_base.py @@ -1129,10 +1129,7 @@ class BaseForecaster(BaseEstimator): y_pred = self.predict(fh=fh, X=X) if not type(y_pred) == type(y): - raise TypeError( - "y must have same type, dims, index as expected predict return. " - f"expected type {type(y_pred)}, but found {type(y)}" - ) + y = convert_to(y, self._y_mtype_last_seen) y_res = y - y_pred	sktime/sktime	73657f3ec16de96b5319049ef33d3ba5a99d02a2	diff --git a/sktime/forecasting/base/tests/test_base_bugs.py b/sktime/forecasting/base/tests/test_base_bugs.py index 6a92d3037..17d69c598 100644 --- a/sktime/forecasting/base/tests/test_base_bugs.py +++ b/sktime/forecasting/base/tests/test_base_bugs.py @@ -9,9 +9,11 @@ from sktime.forecasting.model_selection import ( ExpandingWindowSplitter, ForecastingGridSearchCV, ) +from sktime.forecasting.naive import NaiveForecaster from sktime.forecasting.reconcile import ReconcilerForecaster from sktime.forecasting.trend import PolynomialTrendForecaster from sktime.transformations.hierarchical.aggregate import Aggregator +from sktime.transformations.series.difference import Differencer from sktime.utils._testing.hierarchical import _make_hierarchical from sktime.utils.validation._dependencies import _check_estimator_deps @@ -58,3 +60,17 @@ def test_heterogeneous_get_fitted_params(): reconciler.fit(y_agg) reconciler.get_fitted_params() # triggers an error pre-fix + + +def test_predict_residuals_conversion(): + """Regression test for bugfix #4766, related to predict_residuals internal type.""" + from sktime.datasets import load_longley + from sktime.forecasting.model_selection import temporal_train_test_split + + y, X = load_longley() + y_train, y_test, X_train, X_test = temporal_train_test_split(y, X) + pipe = Differencer() * NaiveForecaster() + pipe.fit(y=y_train, X=X_train, fh=[1, 2, 3, 4]) + result = pipe.predict_residuals() + + assert type(result) == type(y_train)	[DOC] change default documentation version from `latest` (`main` branch) to `stable` (latest tag) in read-the-docs configuration Currently the [documentation website](https://www.sktime.net) defaults to `latest`, i.e. the `main` branch. So, it is possible that it shows some estimators or arguments which are not yet released and won't be available for the general users who download from `PyPI` or `conda-forge`. Read-the docs allow to change the default version, and it can be considered to switch to `stable` to refer to [latest semantic version](https://docs.readthedocs.io/en/stable/versions.html). This is likely to be what's used by most of the direct users of `sktime` (i.e. not through another framework whose dependency is `sktime`). To make the change, the read-the-docs owner can log in, go to `Admin`, go to `Advanced Settings`, change `Default version` and save the changes. It's likely to trigger a new build and then will be in effect once it's complete.	73657f3ec16de96b5319049ef33d3ba5a99d02a2	[ "sktime/forecasting/base/tests/test_base_bugs.py::test_predict_residuals_conversion" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-06-07 14:13:06+00:00	bsd-3-clause	5,526
sktime__sktime-4719	diff --git a/sktime/forecasting/compose/_pipeline.py b/sktime/forecasting/compose/_pipeline.py index 98a23c0d1..9d3aec071 100644 --- a/sktime/forecasting/compose/_pipeline.py +++ b/sktime/forecasting/compose/_pipeline.py @@ -1229,6 +1229,7 @@ class ForecastX(BaseForecaster): _tags = { "X_inner_mtype": SUPPORTED_MTYPES, "y_inner_mtype": SUPPORTED_MTYPES, + "scitype:y": "both", "X-y-must-have-same-index": False, "fit_is_empty": False, "ignores-exogeneous-X": False,	sktime/sktime	77f305ae691974f2bdf8bfffb836ed74fa211c48	diff --git a/sktime/forecasting/compose/tests/test_pipeline.py b/sktime/forecasting/compose/tests/test_pipeline.py index a9a11bb25..b818c76e6 100644 --- a/sktime/forecasting/compose/tests/test_pipeline.py +++ b/sktime/forecasting/compose/tests/test_pipeline.py @@ -480,3 +480,45 @@ def test_forecastx_logic(): # compare that test and comparison case results are equal assert np.allclose(y_pred, y_pred_manual) + + +def test_forecastx_attrib_broadcast(): + """Test ForecastX broadcasting and forecaster attributes.""" + from sktime.forecasting.compose import ForecastX + from sktime.forecasting.naive import NaiveForecaster + + df = pd.DataFrame( + { + "a": ["series_1", "series_1", "series_1"], + "b": pd.to_datetime(["2024-01-01", "2024-01-02", "2024-01-03"]), + "c": [1, 2, 3], + "d": [4, 5, 6], + "e": [7, 8, 9], + } + ) + df = df.set_index(["a", "b"]) + + model = ForecastX(NaiveForecaster(), NaiveForecaster()) + + model_1 = model.clone() + model_1.fit(df[["c"]], X=df[["d", "e"]], fh=[1, 2, 3]) + + assert hasattr(model_1, "forecaster_X_") + assert isinstance(model_1.forecaster_X_, NaiveForecaster) + assert model_1.forecaster_X_.is_fitted + + assert hasattr(model_1, "forecaster_y_") + assert isinstance(model_1.forecaster_y_, NaiveForecaster) + assert model_1.forecaster_y_.is_fitted + + model_2 = model.clone() + model_2.fit(df[["c", "d"]], X=df[["e"]], fh=[1, 2, 3]) + assert hasattr(model_2, "forecaster_X_") + + assert hasattr(model_2, "forecaster_X_") + assert isinstance(model_2.forecaster_X_, NaiveForecaster) + assert model_2.forecaster_X_.is_fitted + + assert hasattr(model_2, "forecaster_y_") + assert isinstance(model_2.forecaster_y_, NaiveForecaster) + assert model_2.forecaster_y_.is_fitted	[BUG] missing `forecaster_X_` attribute in `ForecastX` estimator in case of multivariate target Based on [documenation](https://www.sktime.net/en/stable/api_reference/auto_generated/sktime.forecasting.compose.ForecastX.html), `forecaster_X_` should be available whenever `behaviour="update"`, which is the default behaviour. It seems that is only true when `y` is univariate. ## Reproduible Example ```python3 import pandas from sktime.forecasting.compose import ForecastX from sktime.forecasting.naive import NaiveForecaster df = pandas.DataFrame( { "a": ["series_1", "series_1", "series_1"], "b": pandas.to_datetime(["2024-01-01", "2024-01-02", "2024-01-03"]), "c": [1, 2, 3], "d": [4, 5, 6], "e": [7, 8, 9], } ) df = df.set_index(["a", "b"]) model = ForecastX(NaiveForecaster(), NaiveForecaster()) model_1 = model.clone() model_1.fit(df[["c"]], X=df[["d", "e"]], fh=[1, 2, 3]) assert hasattr(model_1, "forecaster_X_") model_2 = model.clone() model_2.fit(df[["c", "d"]], X=df[["e"]], fh=[1, 2, 3]) assert not hasattr(model_2, "forecaster_X_") ``` The difference in `model_1` and `model_2` is only that the former is trained with univariate `y`, and the latter is trained with multivariate. Based on the two `assert` behaviours, the `forecaster_X_` attribute is present for `model_1`, but missing for `model_2`. ## Versions python 3.9.16, sktime 0.19.1, macOS/Ubuntu ## Context I was trying to get the `X` predictions which are used to eventually predict for `y`. Since there seemed to be no other public method, I was using this attribute to predict with same `fh` passed for `y` predictions. This was working for univariate target, but multivariate started to fail because of the above issue.	77f305ae691974f2bdf8bfffb836ed74fa211c48	[ "sktime/forecasting/compose/tests/test_pipeline.py::test_forecastx_attrib_broadcast" ]	[ "sktime/forecasting/compose/tests/test_pipeline.py::test_tag_handles_missing_data", "sktime/forecasting/compose/tests/test_pipeline.py::test_pipeline_with_detrender", "sktime/forecasting/compose/tests/test_pipeline.py::test_pipeline", "sktime/forecasting/compose/tests/test_pipeline.py::test_forecasting_pipeline_dunder_endog", "sktime/forecasting/compose/tests/test_pipeline.py::test_skip_inverse_transform", "sktime/forecasting/compose/tests/test_pipeline.py::test_pipeline_with_dimension_changing_transformer" ]	{ "failed_lite_validators": [ "has_hyperlinks" ], "has_test_patch": true, "is_lite": false }	2023-06-19 09:24:53+00:00	bsd-3-clause	5,527
sktime__sktime-4948	diff --git a/.all-contributorsrc b/.all-contributorsrc index dc55cf738..9e60b703e 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -2228,6 +2228,15 @@ "bug" ] }, + { + "login": "Gigi1111", + "name": "Chung-Fan Tsai", + "avatar_url": "https://avatars.githubusercontent.com/Gigi1111", + "profile": "https://github.com/Gigi1111", + "contributions": [ + "test" + ] + }, { "login": "eyjo", "name": "Eyjólfur Sigurðsson", @@ -2243,6 +2252,27 @@ "name": "Julia Kraus", "avatar_url": "https://avatars.githubusercontent.com/julia-kraus", "profile": "https://github.com/julia-kraus", + "contributions": [ + "doc", + "code", + "test" + ] + }, + { + "login": "davidgilbertson", + "name": "David Gilbertson", + "avatar_url": "https://avatars.githubusercontent.com/u/4443482?v=4", + "profile": "https://github.com/davidgilbertson", + "contributions": [ + "code", + "bug" + ] + }, + { + "login": "MBristle", + "name": "Mirko Bristle", + "avatar_url": "https://avatars.githubusercontent.com/MBristle", + "profile": "https://github.com/MBristle", "contributions": [ "doc" ] diff --git a/docs/source/api_reference/forecasting.rst b/docs/source/api_reference/forecasting.rst index 4e4dfbce6..d7e9148f0 100644 --- a/docs/source/api_reference/forecasting.rst +++ b/docs/source/api_reference/forecasting.rst @@ -428,6 +428,7 @@ Time series splitters can be used in both evaluation and tuning. SingleWindowSplitter SlidingWindowSplitter ExpandingWindowSplitter + ExpandingGreedySplitter .. autosummary:: :toctree: auto_generated/ diff --git a/sktime/forecasting/base/_base.py b/sktime/forecasting/base/_base.py index acd588550..0cb618146 100644 --- a/sktime/forecasting/base/_base.py +++ b/sktime/forecasting/base/_base.py @@ -1232,7 +1232,7 @@ class BaseForecaster(BaseEstimator): return y_res def score(self, y, X=None, fh=None): - """Scores forecast against ground truth, using MAPE. + """Scores forecast against ground truth, using MAPE (non-symmetric). Parameters ---------- @@ -1252,7 +1252,7 @@ class BaseForecaster(BaseEstimator): Returns ------- score : float - sMAPE loss of self.predict(fh, X) with respect to y_test. + MAPE loss of self.predict(fh, X) with respect to y_test. See Also -------- @@ -1260,12 +1260,12 @@ class BaseForecaster(BaseEstimator): """ # no input checks needed here, they will be performed # in predict and loss function - # symmetric=True is default for mean_absolute_percentage_error from sktime.performance_metrics.forecasting import ( mean_absolute_percentage_error, ) - return mean_absolute_percentage_error(y, self.predict(fh, X)) + # specify non-symmetric explicitly as it changed in the past + return mean_absolute_percentage_error(y, self.predict(fh, X), symmetric=False) def get_fitted_params(self, deep=True): """Get fitted parameters. diff --git a/sktime/forecasting/croston.py b/sktime/forecasting/croston.py index 9bf9aaf11..9c2186c78 100644 --- a/sktime/forecasting/croston.py +++ b/sktime/forecasting/croston.py @@ -167,7 +167,10 @@ class Croston(BaseForecaster): ------- params : dict or list of dict """ - params1 = {} - params2 = {"smoothing": 0.42} + params = [ + {}, + {"smoothing": 0}, + {"smoothing": 0.42}, + ] - return [params1, params2] + return params diff --git a/sktime/forecasting/exp_smoothing.py b/sktime/forecasting/exp_smoothing.py index a9f4c09d2..62ee6b991 100644 --- a/sktime/forecasting/exp_smoothing.py +++ b/sktime/forecasting/exp_smoothing.py @@ -215,18 +215,32 @@ class ExponentialSmoothing(_StatsModelsAdapter): `MyClass(params)` or `MyClass(params[i])` creates a valid test instance. `create_test_instance` uses the first (or only) dictionary in `params """ - params1 = {} - params2 = { - "trend": "mul", - "damped_trend": True, - "seasonal": "mul", - "sp": 2, - "use_boxcox": False, - "initialization_method": "heuristic", - "smoothing_level": 0.1, - "smoothing_trend": 0.1, - "damping_trend": 0.42, - "method": "least_squares", - } - - return [params1, params2] + params = [ + {}, + { + "trend": "mul", + "damped_trend": True, + "seasonal": "mul", + "sp": 2, + "use_boxcox": False, + "initialization_method": "heuristic", + "smoothing_level": 0.1, + "smoothing_trend": 0.1, + "damping_trend": 0.42, + "method": "least_squares", + }, + { + "trend": "add", + "damped_trend": False, + "seasonal": "add", + "sp": 2, + "use_boxcox": True, + "initialization_method": "estimated", + "smoothing_level": 0.3, + "smoothing_trend": 0.5, + "damping_trend": 0.28, + "method": "SLSQP", + }, + ] + + return params diff --git a/sktime/forecasting/model_selection/__init__.py b/sktime/forecasting/model_selection/__init__.py index 825bba210..c55f73960 100644 --- a/sktime/forecasting/model_selection/__init__.py +++ b/sktime/forecasting/model_selection/__init__.py @@ -9,6 +9,7 @@ __all__ = [ "SingleWindowSplitter", "SlidingWindowSplitter", "temporal_train_test_split", + "ExpandingGreedySplitter", "ExpandingWindowSplitter", "TestPlusTrainSplitter", "ForecastingGridSearchCV", @@ -18,6 +19,7 @@ __all__ = [ from sktime.forecasting.model_selection._split import ( CutoffSplitter, + ExpandingGreedySplitter, ExpandingWindowSplitter, SameLocSplitter, SingleWindowSplitter, diff --git a/sktime/forecasting/model_selection/_split.py b/sktime/forecasting/model_selection/_split.py index 5a058f5e1..5fb23b18e 100644 --- a/sktime/forecasting/model_selection/_split.py +++ b/sktime/forecasting/model_selection/_split.py @@ -3,6 +3,7 @@ """Implement dataset splitting for model evaluation and selection.""" __all__ = [ + "ExpandingGreedySplitter", "ExpandingWindowSplitter", "SlidingWindowSplitter", "CutoffSplitter", @@ -11,7 +12,14 @@ __all__ = [ "temporal_train_test_split", "TestPlusTrainSplitter", ] -__author__ = ["mloning", "kkoralturk", "khrapovs", "chillerobscuro", "fkiraly"] +__author__ = [ + "mloning", + "kkoralturk", + "khrapovs", + "chillerobscuro", + "fkiraly", + "davidgilbertson", +] from typing import Iterator, Optional, Tuple, Union @@ -1185,6 +1193,93 @@ class ExpandingWindowSplitter(BaseWindowSplitter): return self._split_windows_generic(expanding=True, *kwargs) +class ExpandingGreedySplitter(BaseSplitter): + """Splitter that uses all available data. + + Takes an integer `test_size` that defines the number of steps included in the + test set of each fold. The train set of each fold will contain all data before + the test set. If the data contains multiple instances, `test_size` is + _per instance_. + + If no `step_length` is defined, the test sets (one for each fold) will be + adjacent, taken from the end of the dataset. + + For example, with `test_size=7` and `folds=5`, the test sets in total will cover + the last 35 steps of the data with no overlap. + + Parameters + ---------- + test_size : int + The number of steps included in the test set of each fold. + folds : int, default = 5 + The number of folds. + step_length : int, optional + The number of steps advanced for each fold. Defaults to `test_size`. + + Examples + -------- + >>> import numpy as np + >>> from sktime.forecasting.model_selection import ExpandingGreedySplitter + + >>> ts = np.arange(10) + >>> splitter = ExpandingGreedySplitter(test_size=3, folds=2) + >>> list(splitter.split(ts)) # doctest: +SKIP + [ + (array([0, 1, 2, 3]), array([4, 5, 6])), + (array([0, 1, 2, 3, 4, 5, 6]), array([7, 8, 9])) + ] + """ + + _tags = {"split_hierarchical": True} + + def __init__(self, test_size: int, folds: int = 5, step_length: int = None): + super().__init__() + self.test_size = test_size + self.folds = folds + self.step_length = step_length + self.fh = np.arange(test_size) + 1 + + def _split(self, y: pd.Index) -> SPLIT_GENERATOR_TYPE: + if isinstance(y, pd.MultiIndex): + groups = pd.Series(index=y).groupby(y.names[:-1]) + reverse_idx = groups.transform("size") - groups.cumcount() - 1 + else: + reverse_idx = np.arange(len(y))[::-1] + + step_length = self.step_length or self.test_size + + for i in reversed(range(self.folds)): + tst_end = i step_length + trn_end = tst_end + self.test_size + trn_indices = np.flatnonzero(reverse_idx >= trn_end) + tst_indices = np.flatnonzero( + (reverse_idx < trn_end) & (reverse_idx >= tst_end) + ) + yield trn_indices, tst_indices + + @classmethod + def get_test_params(cls, parameter_set="default"): + """Return testing parameter settings for the splitter. + + Parameters + ---------- + parameter_set : str, default="default" + Name of the set of test parameters to return, for use in tests. If no + special parameters are defined for a value, will return `"default"` set. + + Returns + ------- + params : dict or list of dict, default = {} + Parameters to create testing instances of the class + Each dict are parameters to construct an "interesting" test instance, i.e., + `MyClass(params)` or `MyClass(params[i])` creates a valid test instance. + `create_test_instance` uses the first (or only) dictionary in `params` + """ + params1 = {"test_size": 1} + params2 = {"test_size": 3, "folds": 2, "step_length": 2} + return [params1, params2] + + class SingleWindowSplitter(BaseSplitter): r"""Single window splitter.	sktime/sktime	f4815d7fcd15e4d8936dce770066062e36ed82a8	diff --git a/sktime/forecasting/model_selection/tests/test_split.py b/sktime/forecasting/model_selection/tests/test_split.py index 3c9ecba60..887551003 100644 --- a/sktime/forecasting/model_selection/tests/test_split.py +++ b/sktime/forecasting/model_selection/tests/test_split.py @@ -11,6 +11,7 @@ from sktime.datatypes._utilities import get_cutoff from sktime.forecasting.base import ForecastingHorizon from sktime.forecasting.model_selection import ( CutoffSplitter, + ExpandingGreedySplitter, ExpandingWindowSplitter, SameLocSplitter, SingleWindowSplitter, @@ -325,6 +326,92 @@ def test_sliding_window_splitter_start_with_empty_window( ) +def test_expanding_greedy_splitter_lengths(): + """Test that ExpandingGreedySplitter returns the correct lengths.""" + y = np.arange(10) + cv = ExpandingGreedySplitter(test_size=2, folds=3) + + lengths = [(len(trn), len(tst)) for trn, tst in cv.split_series(y)] + assert lengths == [(4, 2), (6, 2), (8, 2)] + + +def test_expanding_greedy_splitter_dates(): + """Test that ExpandingGreedySplitter splits on dates correctly.""" + ts = _make_series(index_type="period") + first_date = ts.index[0] + last_date = ts.index[-1] + cv = ExpandingGreedySplitter(test_size=2, folds=3) + + train_starts = [] + train_ends = [] + test_starts = [] + test_ends = [] + + for trn, tst in cv.split_series(ts): + train_starts.append(trn.index[0]) + train_ends.append(trn.index[-1]) + test_starts.append(tst.index[0]) + test_ends.append(tst.index[-1]) + + assert train_starts == [first_date, first_date, first_date] + assert train_ends == [last_date - 6, last_date - 4, last_date - 2] + assert test_starts == [last_date - 5, last_date - 3, last_date - 1] + assert test_ends == [last_date - 4, last_date - 2, last_date] + + +def test_expanding_greedy_splitter_hierarchy(): + """Test that ExpandingGreedySplitter handles uneven hierarchical data.""" + y_panel = _make_hierarchical( + hierarchy_levels=(2, 4), + max_timepoints=20, + min_timepoints=10, + same_cutoff=False, + ) + + cv = ExpandingGreedySplitter(test_size=2, folds=3) + + # Since same_cutoff=False above, we will have a potentially different end date for + # each instance in the hierarchy. Below we test that the final fold ends at the + # correct end date for each instance + last_test_fold = list(cv.split_series(y_panel))[-1][1] + + last_test_dates_actual = ( + last_test_fold.reset_index(-1) + .groupby(last_test_fold.index.names[:-1]) + .tail(1)["time"] + ) + last_test_dates_expected = ( + y_panel.reset_index(-1).groupby(y_panel.index.names[:-1]).tail(1)["time"] + ) + + assert last_test_dates_actual.eq(last_test_dates_expected).all() + + +def test_expanding_greedy_splitter_consecutive(): + """Test that ExpandingGreedySplitter results in consecutive test periods.""" + y_panel = _make_hierarchical( + hierarchy_levels=(2, 4), + max_timepoints=20, + min_timepoints=10, + same_cutoff=False, + ) + + cv = ExpandingGreedySplitter(test_size=2, folds=3) + + test_dfs = [tst for _, tst in cv.split_series(y_panel)] + + combined_test_df = pd.concat(test_dfs).sort_index() + + # We check the .diff(). Equal diffs = uniformly spaced timestamps + has_consecutive_index = ( + combined_test_df.reset_index(-1) + .groupby(combined_test_df.index.names[:-1])["time"] + .agg(lambda s: len(s.diff().value_counts()) == 1) + ) + + assert has_consecutive_index.all() + + @pytest.mark.parametrize("y", TEST_YS) @pytest.mark.parametrize("fh", [TEST_FHS, TEST_FHS_TIMEDELTA]) @pytest.mark.parametrize("step_length", TEST_STEP_LENGTHS)	[DOC] BaseForecaster score function uses MAPE instead of sMAPE as metric #### Describe the issue linked to the documentation The [score function](https://github.com/sktime/sktime/blob/ed4efe9e47fa998ad6b21d63b0ac58f932ab1b3f/sktime/forecasting/base/_base.py#L1234C1-L1234C1) of the BaseForecaster suggests the metric that is used for evaluation is sMAPE: ``` Returns ------- score : float sMAPE loss of self.predict(fh, X) with respect to y_test. ``` The code calls the [mean_absolute_percentage_error function](https://github.com/sktime/sktime/blob/ed4efe9e47fa998ad6b21d63b0ac58f932ab1b3f/sktime/performance_metrics/forecasting/_functions.py#L1448) without any further parameters. ``` from sktime.performance_metrics.forecasting import ( mean_absolute_percentage_error, ) return mean_absolute_percentage_error(y, self.predict(fh, X)) ``` But the default values of the [mean_absolute_percentage_error function ](https://github.com/sktime/sktime/blob/ed4efe9e47fa998ad6b21d63b0ac58f932ab1b3f/sktime/performance_metrics/forecasting/_functions.py#L1448) are: ``` def mean_absolute_percentage_error( y_true, y_pred, horizon_weight=None, multioutput="uniform_average", symmetric=False, **kwargs, ): ``` and the doc states: ``` ... symmetric : bool, default=False Calculates symmetric version of metric if True. ... ``` Thus I conclude that instead of the sMAPE, MAPE is returned. #### Suggest a potential alternative/fix Either adjust the documentation such that it states that the MAPE metric is used or adjust the implementation by adding the symmetric parameter. I did not investigate if there are other places with the documentation error. ;) Many thanks!!	f4815d7fcd15e4d8936dce770066062e36ed82a8	[ "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_greater_than_window_length[ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-period-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-period-period-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-datetime-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-int-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_initial_window_smaller_than_window_raise_error", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-range-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_consecutive", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-timedelta-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-int-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_initial_window_start_with_empty_window_raises_error", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-range-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[-3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_hierarchy", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-timedelta-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_dates", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_lengths", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-int-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-period-period-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_greater_than_window_length[SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_series_hier", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_same_loc_splitter_hierarchical", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_same_loc_splitter", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_loc", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-int-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-range-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-period-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_smaller_than_window_length[ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-datetime-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-range-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_smaller_than_window_length[SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_series", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh10-y0]" ]	[]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-07-24 14:58:45+00:00	bsd-3-clause	5,528
sktime__sktime-4998	diff --git a/sktime/clustering/k_means.py b/sktime/clustering/k_means.py index a763875f4..1423a5d7f 100644 --- a/sktime/clustering/k_means.py +++ b/sktime/clustering/k_means.py @@ -19,9 +19,15 @@ class TimeSeriesKMeans(TimeSeriesLloyds): n_clusters: int, defaults = 8 The number of clusters to form as well as the number of centroids to generate. - init_algorithm: str, defaults = 'random' - Method for initializing cluster centers. Any of the following are valid: - ['kmeans++', 'random', 'forgy'] + init_algorithm: str, np.ndarray (3d array of shape (n_clusters, n_dimensions, + series_length)), defaults = 'random' + Method for initializing cluster centers or an array of initial cluster centers. + If string, any of the following strings are valid: + ['kmeans++', 'random', 'forgy']. + If 3D np.ndarray, initializes cluster centers with the provided array. The array + must have shape (n_clusters, n_dimensions, series_length) and the number of + clusters in the array must be the same as what is provided to the n_clusters + argument. metric: str or Callable, defaults = 'dtw' Distance metric to compute similarity between time series. Any of the following are valid: ['dtw', 'euclidean', 'erp', 'edr', 'lcss', 'squared', 'ddtw', 'wdtw', @@ -204,10 +210,20 @@ class TimeSeriesKMeans(TimeSeriesLloyds): `MyClass(params)` or `MyClass(params[i])` creates a valid test instance. `create_test_instance` uses the first (or only) dictionary in `params` """ - return { + params1 = { "n_clusters": 2, "metric": "euclidean", + "init_algorithm": "random", "n_init": 1, "max_iter": 10, "random_state": 0, } + params2 = { + "n_clusters": 3, + "metric": "dtw", + "init_algorithm": np.random.normal(size=(3, 4, 10)), + "n_init": 1, + "max_iter": 15, + "random_state": 1, + } + return [params1, params2] diff --git a/sktime/clustering/k_medoids.py b/sktime/clustering/k_medoids.py index c7b1e8c52..2eb531062 100755 --- a/sktime/clustering/k_medoids.py +++ b/sktime/clustering/k_medoids.py @@ -19,9 +19,15 @@ class TimeSeriesKMedoids(TimeSeriesLloyds): n_clusters: int, defaults = 8 The number of clusters to form as well as the number of centroids to generate. - init_algorithm: str, defaults = 'forgy' - Method for initializing cluster centers. Any of the following are valid: - ['kmeans++', 'random', 'forgy'] + init_algorithm: str, np.ndarray (3d array of shape (n_clusters, n_dimensions, + series_length)), defaults = 'forgy' + Method for initializing cluster centers or an array of initial cluster centers. + If string, any of the following strings are valid: + ['kmeans++', 'random', 'forgy']. + If 3D np.ndarray, initializes cluster centers with the provided array. The array + must have shape (n_clusters, n_dimensions, series_length) and the number of + clusters in the array must be the same as what is provided to the n_clusters + argument. metric: str or Callable, defaults = 'dtw' Distance metric to compute similarity between time series. Any of the following are valid: ['dtw', 'euclidean', 'erp', 'edr', 'lcss', 'squared', 'ddtw', 'wdtw', diff --git a/sktime/clustering/partitioning/_lloyds.py b/sktime/clustering/partitioning/_lloyds.py index 82f24bd4f..5d7a755c9 100755 --- a/sktime/clustering/partitioning/_lloyds.py +++ b/sktime/clustering/partitioning/_lloyds.py @@ -162,9 +162,10 @@ class TimeSeriesLloyds(BaseClusterer, ABC): n_clusters: int, defaults = 8 The number of clusters to form as well as the number of centroids to generate. - init_algorithm: str, defaults = 'forgy' - Method for initializing cluster centers. Any of the following are valid: - ['kmeans++', 'random', 'forgy'] + init_algorithm: str, np.ndarray (3d array of shape (n_clusters, n_dimensions, + series_length)), defaults = 'forgy' + Method for initializing cluster centers or an array of initial cluster centers. + Any of the following strings are valid: ['kmeans++', 'random', 'forgy'] metric: str or Callable, defaults = 'dtw' Distance metric to compute similarity between time series. Any of the following are valid: ['dtw', 'euclidean', 'erp', 'edr', 'lcss', 'squared', 'ddtw', 'wdtw', @@ -240,6 +241,7 @@ class TimeSeriesLloyds(BaseClusterer, ABC): self._random_state = None self._init_algorithm = None + self._initial_cluster_centers = None self._distance_params = distance_params if distance_params is None: @@ -264,14 +266,33 @@ class TimeSeriesLloyds(BaseClusterer, ABC): self._random_state = check_random_state(self.random_state) if isinstance(self.init_algorithm, str): - self._init_algorithm = self._init_algorithms.get(self.init_algorithm) - else: + if self.init_algorithm not in self._init_algorithms.keys(): + raise KeyError( + f"The string provided for init_algorithm: {self.init_algorithm} is " + f"invalid. The following are a list of valid init algorithms " + f"strings: {list(self._init_algorithms.keys())}" + ) + self._init_algorithm = self._init_algorithms[self.init_algorithm] + elif isinstance(self.init_algorithm, np.ndarray): + if self.init_algorithm.ndim != 3: + raise ValueError( + "The array provided to init_algorithm is invalid. It must be 3D." + ) + if self.init_algorithm.shape[0] != self.n_clusters: + raise ValueError( + f"The number of centers in init_algorithm and n_clusters must be " + f"the same. The number of centres in init_algorithm is " + f"{self.init_algorithm.shape[0]} but n_clusters is " + f"{self.n_clusters}" + ) self._init_algorithm = self.init_algorithm - - if not isinstance(self._init_algorithm, Callable): + elif isinstance(self._init_algorithm, Callable): + self._init_algorithm = self.init_algorithm + else: raise ValueError( - f"The value provided for init_algorim: {self.init_algorithm} is " - f"invalid. The following are a list of valid init algorithms strings: " + f"The value provided for init_algorithm: {self.init_algorithm} is " + f"invalid. It must be either a string, callable or 3D numpy array." + f" The following are a list of valid init algorithms strings: " f"{list(self._init_algorithms.keys())}" ) @@ -377,12 +398,15 @@ class TimeSeriesLloyds(BaseClusterer, ABC): Sum of squared distances of samples to their closest cluster center, weighted by the sample weights if provided. """ - cluster_centres = self._init_algorithm( - X, - self.n_clusters, - self._random_state, - distance_metric=self._distance_metric, - ) + if isinstance(self._init_algorithm, np.ndarray): + cluster_centres = self._init_algorithm + else: + cluster_centres = self._init_algorithm( + X, + self.n_clusters, + self._random_state, + distance_metric=self._distance_metric, + ) old_inertia = np.inf old_labels = None for i in range(self.max_iter): diff --git a/sktime/transformations/series/difference.py b/sktime/transformations/series/difference.py index a9f205107..47ba58295 100644 --- a/sktime/transformations/series/difference.py +++ b/sktime/transformations/series/difference.py @@ -142,10 +142,24 @@ def _inverse_diff(X, lags, X_diff_seq=None): # invert last lag index if X_diff_seq is not None: + # Get the train time series before the last difference X_diff_orig = X_diff_seq[len(lags)] + # Shift the differenced time series index by the last lag + # to match the original time series index X_ix_shift = _shift(X.index, -lag_last) + # Get the original time series values for the intersecting + # indices between the shifted index and the original index X_update = X_diff_orig.loc[X_ix_shift.intersection(X_diff_orig.index)] - + # Set the values of the differenced time series to nan for all indices + # that are in the indices of the original and the by the sum of all lags + # shifted original time series that are available in the differenced time + # series (intersection). These are the indices for which no valid differenced + # values exist. + X.loc[ + X_diff_orig.index.difference( + _shift(X_diff_orig.index, sum(lags) + lag_last) + ).intersection(X.index) + ] = np.nan X = X.combine_first(X_update) X_diff_last = X.copy()	sktime/sktime	9f0345bd404aaf332f865d16281730228f27307b	diff --git a/sktime/transformations/series/tests/test_differencer.py b/sktime/transformations/series/tests/test_differencer.py index fc2ee7a89..800f023c7 100644 --- a/sktime/transformations/series/tests/test_differencer.py +++ b/sktime/transformations/series/tests/test_differencer.py @@ -168,6 +168,17 @@ def test_differencer_cutoff(): gscv.fit(train_model, X=X_train) [email protected]("lags", lags_to_test) [email protected]("index_type", ["int", "datetime"]) +def test_inverse_train_data_fill_zero(lags, index_type): + y = y_airline + if index_type == "int": + y = y.reset_index(drop=True) + diff = Differencer(lags).fit(y) + result = diff.inverse_transform(diff.transform(y)) + _assert_array_almost_equal(result, y) + + def test_differencer_inverse_does_not_memorize(): """Tests that differencer inverse always computes inverse via cumsum.	[BUG] Wrong result for `predict_residuals` of`TransformedTargetForecaster` on training data Describe the bug If `predict_residuals` is called of a `TransformedTargetForecaster` on the training data, the results seems to be wrong. My guess it that internally, the `self._y` of the `TransformedTargetForecaster` is used to calculate the residuals instead of the transformed target data. To Reproduce <!-- Add a Minimal, Complete, and Verifiable example (for more details, see e.g. https://stackoverflow.com/help/mcve If the code is too long, feel free to put it in a public gist and link it in the issue: https://gist.github.com --> ```python from datasets import load_longley from forecasting.model_selection import temporal_train_test_split from forecasting.sarimax import SARIMAX from transformations.series.difference import Differencer method = "predict_residuals" y, X = load_longley() y_train, y_test, X_train, X_test = temporal_train_test_split(y, X) pipe = Differencer() * SARIMAX() pipe.fit(y=y_train.to_frame(), X=X_train, fh=[1, 2, 3, 4]) result = pipe.predict_residuals() result_test = pipe.predict_residuals(y=y_test, X=X_test) ``` In this example, result_test looks like residuals. However, result is far higher and not the residuals. Expected behavior <!-- A clear and concise description of what you expected to happen. --> Also on the training data the residuals should be calculated of the TransformedTargetForecaster applied on the training data. <!-- Thanks for contributing! -->	9f0345bd404aaf332f865d16281730228f27307b	[ "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-lags6]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-12]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-lags4]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-lags5]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-lags6]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-lags5]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-lags7]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-3]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-3]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-lags3]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-1]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-lags4]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-1]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[int-lags7]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-lags3]", "sktime/transformations/series/tests/test_differencer.py::test_inverse_train_data_fill_zero[datetime-12]" ]	[ "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-1-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_produces_expected_results[keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-3-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags7-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags3-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-12-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-12-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags6-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_produces_expected_results[drop_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_produces_expected_results[fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-1-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-3-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags3-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags5-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags7-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags6-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags4-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-1-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-1-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags4-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-1-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-12-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-12-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-12-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-12-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags7-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-12-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-3-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags4-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-12-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags4-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags5-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags7-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags4-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags6-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags3-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags5-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags6-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-12-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags7-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags4-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-1-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags4-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-1-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags5-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags7-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags5-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-12-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags3-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags7-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags3-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-1-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-3-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags4-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-12-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-12-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags4-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-1-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-12-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags5-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-1-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-1-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags6-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags5-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags5-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags6-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags4-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags4-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags6-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags7-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags7-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags5-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-12-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags3-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags4-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags5-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags5-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-3-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-3-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags6-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-3-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags6-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags6-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags6-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags7-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-1-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags5-y0-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags7-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags3-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-3-y0-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags3-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags5-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags4-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags7-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-12-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-1-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags4-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags6-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags6-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags5-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags5-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-1-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags7-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-3-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags5-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags3-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[int-lags6-y1-fill_zero]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags6-y0]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-12-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-1-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-1-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[int-lags7-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags4-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_remove_missing_false[datetime-lags7-y1-keep_na]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_same_series[datetime-lags4-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[datetime-lags6-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_prediction[int-lags7-y1]", "sktime/transformations/series/tests/test_differencer.py::test_differencer_inverse_does_not_memorize" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-08-01 08:55:26+00:00	bsd-3-clause	5,529
sktime__sktime-5012	diff --git a/.all-contributorsrc b/.all-contributorsrc index 3441d6560..ed91edebc 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -1740,6 +1740,7 @@ "name": "Benedikt Heidrich", "profile": "https://github.com/benheid", "contributions": [ + "bug", "code" ] }, diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index ad94a9858..238a9a1e6 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -50,7 +50,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d <tr> <td align="center" valign="top" width="11.11%"><a href="https://github.com/BandaSaiTejaReddy"><img src="https://avatars0.githubusercontent.com/u/31387911?v=4?s=100" width="100px;" alt="BANDASAITEJAREDDY"/><br /><sub><b>BANDASAITEJAREDDY</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=BandaSaiTejaReddy" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=BandaSaiTejaReddy" title="Documentation">📖</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/badrmarani"><img src="https://avatars.githubusercontent.com/badrmarani?s=100" width="100px;" alt="Badr-Eddine Marani"/><br /><sub><b>Badr-Eddine Marani</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=badrmarani" title="Code">💻</a></td> - <td align="center" valign="top" width="11.11%"><a href="https://github.com/benheid"><img src="?s=100" width="100px;" alt="Benedikt Heidrich"/><br /><sub><b>Benedikt Heidrich</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=benheid" title="Code">💻</a></td> + <td align="center" valign="top" width="11.11%"><a href="https://github.com/benheid"><img src="?s=100" width="100px;" alt="Benedikt Heidrich"/><br /><sub><b>Benedikt Heidrich</b></sub></a><br /><a href="https://github.com/sktime/sktime/issues?q=author%3Abenheid" title="Bug reports">🐛</a> <a href="https://github.com/sktime/sktime/commits?author=benheid" title="Code">💻</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/benjaminbluhm"><img src="?s=100" width="100px;" alt="Benjamin Bluhm"/><br /><sub><b>Benjamin Bluhm</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=benjaminbluhm" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=benjaminbluhm" title="Documentation">📖</a> <a href="#example-benjaminbluhm" title="Examples">💡</a></td> <td align="center" valign="top" width="11.11%"><a href="https://haskarb.github.io/"><img src="https://avatars.githubusercontent.com/u/20501023?v=4?s=100" width="100px;" alt="Bhaskar Dhariyal"/><br /><sub><b>Bhaskar Dhariyal</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=haskarb" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=haskarb" title="Tests">⚠️</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/BINAYKUMAR943"><img src="https://avatars.githubusercontent.com/u/38756834?v=4?s=100" width="100px;" alt="Binay Kumar"/><br /><sub><b>Binay Kumar</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Documentation">📖</a> <a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Tests">⚠️</a></td> diff --git a/sktime/forecasting/model_selection/_split.py b/sktime/forecasting/model_selection/_split.py index 9fca2a4da..81f7c2907 100644 --- a/sktime/forecasting/model_selection/_split.py +++ b/sktime/forecasting/model_selection/_split.py @@ -1089,12 +1089,38 @@ class BaseWindowSplitter(BaseSplitter): n_splits : int The number of splits. """ + from sktime.datatypes import check_is_scitype, convert + if y is None: raise ValueError( f"{self.__class__.__name__} requires `y` to compute the " f"number of splits." ) - return len(self.get_cutoffs(y)) + + multi_scitypes = ["Hierarchical", "Panel"] + is_non_single, _, metadata = check_is_scitype(y, multi_scitypes, []) + + # n_splits based on the first instance of the lowest level series cutoffs + if is_non_single: + from_mtype = metadata.get("mtype") + scitype = metadata.get("scitype") + if scitype == "Panel": + to_mtype = "pd-multiindex" + else: + to_mtype = "pd_multiindex_hier" + + y = convert(y, from_type=from_mtype, to_type=to_mtype, as_scitype=scitype) + + index = self._coerce_to_index(y) + for _, values in y.groupby(index.droplevel(-1)): + # convert to a single ts + instance_series = values.reset_index().iloc[:, -2:] + instance_series.set_index(instance_series.columns[0], inplace=True) + n_splits = len(self.get_cutoffs(instance_series)) + break + else: + n_splits = len(self.get_cutoffs(y)) + return n_splits def get_cutoffs(self, y: Optional[ACCEPTED_Y_TYPES] = None) -> np.ndarray: """Return the cutoff points in .iloc[] context. diff --git a/sktime/transformations/series/subset.py b/sktime/transformations/series/subset.py index a578e966d..d82b6a0ee 100644 --- a/sktime/transformations/series/subset.py +++ b/sktime/transformations/series/subset.py @@ -160,6 +160,7 @@ class ColumnSelect(BaseTransformer): "fit_is_empty": True, "univariate-only": False, "capability:inverse_transform": False, + "skip-inverse-transform": True, } def __init__(self, columns=None, integer_treatment="col", index_treatment="remove"):	sktime/sktime	ff6f059c5d78af345c061209147fd42c1c7d6cdf	diff --git a/sktime/forecasting/model_selection/tests/test_split.py b/sktime/forecasting/model_selection/tests/test_split.py index 82f1e03c4..12e9955fc 100644 --- a/sktime/forecasting/model_selection/tests/test_split.py +++ b/sktime/forecasting/model_selection/tests/test_split.py @@ -32,6 +32,7 @@ from sktime.forecasting.tests._config import ( ) from sktime.utils._testing.forecasting import _make_fh from sktime.utils._testing.hierarchical import _make_hierarchical +from sktime.utils._testing.panel import _make_panel from sktime.utils._testing.series import _make_series from sktime.utils.datetime import _coerce_duration_to_int from sktime.utils.validation import ( @@ -43,6 +44,10 @@ from sktime.utils.validation import ( from sktime.utils.validation.forecasting import check_fh N_TIMEPOINTS = 30 +TEST_Y_PANEL_HIERARCHICAL = [ + _make_hierarchical((2, 2), N_TIMEPOINTS, N_TIMEPOINTS), + _make_panel(n_instances=2, n_timepoints=N_TIMEPOINTS), +] def _get_windows(cv, y): @@ -722,3 +727,32 @@ def test_hierachical_singlewindowsplitter(): splitter = SingleWindowSplitter(fh=[1, 2], window_length=10) splits = list(splitter.split(y)) assert len(splits) == 1, "Should only be one split" + + [email protected]("CV", [SlidingWindowSplitter, ExpandingWindowSplitter]) [email protected]("fh", [TEST_FHS, TEST_FHS_TIMEDELTA]) [email protected]("window_length", TEST_WINDOW_LENGTHS) [email protected]("step_length", TEST_STEP_LENGTHS) +def test_windowbase_splitter_get_n_split_hierarchical( + CV, fh, window_length, step_length +): + """Test that WindowBaseSplitter.get_n_splits works for hierarchical data.""" + # see bugs 4971 + y = TEST_Y_PANEL_HIERARCHICAL[0] # hierachical data + if _inputs_are_supported([fh, window_length, step_length]): + cv = CV(fh, window_length, step_length) + assert cv.get_n_splits(y) == len( + list(cv.split(y)) + ), "get_n_splits does not equal the number of splits in the output." + + [email protected]("y", TEST_Y_PANEL_HIERARCHICAL) [email protected]("CV", [SlidingWindowSplitter, ExpandingWindowSplitter]) +def test_windowbase_splitter_get_n_split_unequal_series(y, CV): + y_unequal = y.copy() # avoid changing original dataset + y_unequal.iloc[:3, :] = None # make the first series shorter than the rest + y_unequal.dropna(inplace=True) + cv = CV([1], 24, 1) + assert cv.get_n_splits(y_unequal) == len( + list(cv.split(y_unequal)) + ), "get_n_splits does not equal the number of splits in the output." diff --git a/sktime/transformations/series/tests/test_subset.py b/sktime/transformations/series/tests/test_subset.py index 2137b95e5..f400a5794 100644 --- a/sktime/transformations/series/tests/test_subset.py +++ b/sktime/transformations/series/tests/test_subset.py @@ -7,6 +7,7 @@ import pandas as pd import pytest from sktime.datasets import load_airline, load_longley +from sktime.forecasting.naive import NaiveForecaster from sktime.transformations.series.subset import ColumnSelect, IndexSubset @@ -49,3 +50,10 @@ def test_columnselect_int(): X_subset = transformer.fit_transform(X=X) assert X_subset.columns.equals(X.columns[[0, 2, 4]]) + + +def test_columnselect_as_first_step_in_transformedtargetforecaster(): + y = load_longley()[1][["GNP", "UNEMP"]] + fc = ColumnSelect(["GNP"]) * NaiveForecaster() + fc.fit(y) + fc.predict(fh=[1])	[BUG] get_n_splits of window splitter does not reflect the number of splits for hierarchical data Describe the bug <!-- A clear and concise description of what the bug is. --> `get_n_splits` method returns the wrong number of splits when hierarchical data is passed into window based splitter. To Reproduce ```python from sktime.utils._testing.hierarchical import _make_hierarchical from sktime.forecasting.model_selection import ExpandingWindowSplitter, SlidingWindowSplitter y_hierarchical = _make_hierarchical(hierarchy_levels=(2, 3), min_timepoints=12, max_timepoints=12, random_state=0) fh = [1] step_length = 1 window_length = 10 # each unique series (lowest hierachical level) should have two splits cv = ExpandingWindowSplitter(initial_window=window_length, fh=fh, step_length=step_length) sliding = SlidingWindowSplitter(fh=fh, window_length=window_length, step_length=step_length, start_with_window=True) n_splits_cv = cv.get_n_splits(y_hierarchical) n_splits_sliding = sliding.get_n_splits(y_hierarchical) print(f"Expanding Window splits : {n_splits_cv}") print(f"Sliding Window Number of splits : {n_splits_sliding}") ``` Output ``` Expanding Window Number of splits : 62 Sliding Window Number of splits : 62 ``` Expected behavior <!-- A clear and concise description of what you expected to happen. --> Shouldnt the number of split is based on either of these two?: 1. Return number of splits based on datatype train/test splits which is two in this case ```python print(f"Expanding Window splits: {len(list(cv.split(y_hierarchical)))}") print(f"Sliding Window splits: {len(list(sliding.split(y_hierarchical)))}") ``` 2. Return number of splits based on splits of the lowest hierachical level series. In this case it will be 6 * 2 = 12 Versions <details> System: python: 3.9.17 (main, Jul 5 2023, 20:47:11) [MSC v.1916 64 bit (AMD64)] machine: Windows-10-10.0.19045-SP0 Python dependencies: pip: 23.2.1 sktime: 0.21.0 sklearn: 1.3.0 skbase: 0.4.6 numpy: 1.24.3 scipy: 1.11.1 pandas: 2.0.3 matplotlib: 3.7.2 joblib: 1.3.1 statsmodels: 0.14.0 numba: 0.57.1 pmdarima: 2.0.3 tsfresh: 0.20.1 tensorflow: 2.13.0 tensorflow_probability: None </details>	ff6f059c5d78af345c061209147fd42c1c7d6cdf	[ "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_unequal_series[ExpandingWindowSplitter-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_unequal_series[SlidingWindowSplitter-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_unequal_series[SlidingWindowSplitter-y1]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_unequal_series[ExpandingWindowSplitter-y1]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh5-ExpandingWindowSplitter]", "sktime/transformations/series/tests/test_subset.py::test_columnselect_as_first_step_in_transformedtargetforecaster" ]	[ "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_series_hier", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_hierachical_singlewindowsplitter", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_lengths", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_same_loc_splitter_hierarchical", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-period-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_series", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_initial_window_start_with_empty_window_raises_error", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-datetime-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_smaller_than_window_length[ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-range-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-range-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-int-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-timedelta-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-period-period-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-period-period-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_initial_window_smaller_than_window_raise_error", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-int-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-datetime-datetime-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_greater_than_window_length[SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_loc", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length2-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_greater_than_window_length[ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_same_loc_splitter", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-datetime-timedelta-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-period-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4--3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length3-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-0-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_window_splitter_in_sample_fh_smaller_than_window_length[SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh9-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length4--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh9-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[1-int-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-range-int-False]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh5-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-range-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_consecutive", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-1-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length5-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh10-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh6-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-1-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh8-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_split_by_fh[values1-int-int-True]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh6-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length2-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length4-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length3--3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh11-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh9-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-0-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh10-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh6-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length3-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh3-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length2-fh1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh5-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_dates", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh10-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-1-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh6-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3-0-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length4-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_greedy_splitter_hierarchy", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length3--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-window_length5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-5-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-1-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh11-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh9-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length3-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length4-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length5-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh5-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length3-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-window_length3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length3-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh1-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-window_length5--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length2-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[5-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-0-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-5-fh7-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh7-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-initial_window3-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh3-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-5-window_length3-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[1-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-5-fh8-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh8-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length5-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length3--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter[window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length4-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length4-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-1-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length2-window_length3-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-1-window_length4-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-0-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh8-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length4-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-1-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length3-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length3-1-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length4-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length2-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-initial_window5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length3-fh1-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh7-cutoffs2-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[1-initial_window3-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5--3-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-window_length3-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length2-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-1-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length4-window_length3-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_initial_window_zero[step_length4-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length3-1-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length5-1-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-1-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length5-fh10-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-1-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length5-5-0-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-5-fh7-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length2-initial_window2-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length5-fh6-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-1--3-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-1--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh1-cutoffs3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-window_length5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-1-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-5-1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length3-window_length3-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length2-1-fh11-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length4-fh10-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2--3-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[1-fh5-cutoffs4-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-1-5-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length4-window_length3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh8-SlidingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[5-window_length2-fh5-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-5-window_length4-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length4-window_length4-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[5-5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[5-initial_window3-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-1-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-1-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[1-5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length5-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length4-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length2-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length2-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-window_length5--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-5-1-fh3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length2-5-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-1-fh5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length3-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[1-window_length4-fh9-ExpandingWindowSplitter]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window4--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[5-fh5-cutoffs5-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length2-initial_window2--3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length5-0-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[5-initial_window5-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-1-window_length5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length2-1-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter_start_with_empty_window[step_length4-initial_window5-fh1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-step_length4-window_length2-fh7-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length4-window_length3-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length3-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_single_window_splitter_default_window_length[-3-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-5-fh10-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_cutoff_window_splitter[window_length2-fh11-cutoffs1-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length3-5-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_expanding_window_splitter[step_length3-initial_window2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length3-window_length4-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length5-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-5-window_length3-fh1-y0]", "sktime/transformations/series/tests/test_subset.py::test_columnselect_int", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window2-step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[10-step_length2-window_length2-fh9-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length2-window_length2-fh6-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[7-1-window_length2-1-y0]", "sktime/transformations/series/tests/test_subset.py::test_indexsubset_indextreatment[remove]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter[step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window3-step_length5-window_length2-fh8-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_windowbase_splitter_get_n_split_hierarchical[step_length3-5-fh6-ExpandingWindowSplitter]", "sktime/transformations/series/tests/test_subset.py::test_columnselect_indextreatment[keep]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window4-step_length5-window_length3-fh11-y0]", "sktime/transformations/series/tests/test_subset.py::test_indexsubset_indextreatment[keep]", "sktime/transformations/series/tests/test_subset.py::test_columnselect_indextreatment[remove]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_start_with_empty_window[step_length5-window_length5-fh11-y0]", "sktime/forecasting/model_selection/tests/test_split.py::test_sliding_window_splitter_with_initial_window[initial_window5-step_length4-window_length5-fh8-y0]" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-08-03 00:45:56+00:00	bsd-3-clause	5,530
sktime__sktime-5169	diff --git a/examples/02a_classification_multivariate_cnn.ipynb b/examples/02a_classification_multivariate_cnn.ipynb index c2a097c52..f4b464240 100644 --- a/examples/02a_classification_multivariate_cnn.ipynb +++ b/examples/02a_classification_multivariate_cnn.ipynb @@ -71,7 +71,7 @@ "metadata": {}, "outputs": [], "source": [ - "network = CNNClassifier(n_epochs=200, verbose=True)\n", + "network = CNNClassifier(n_epochs=50, verbose=True)\n", "network.fit(X_train, y_train)\n", "network.score(X_test, y_test)" ] @@ -97,7 +97,7 @@ "outputs": [], "source": [ "param_grid = {\"kernel_size\": [7, 9], \"avg_pool_size\": [3, 5]}\n", - "grid = GridSearchCV(network, param_grid=param_grid, cv=5)\n", + "grid = GridSearchCV(network, param_grid=param_grid, cv=3)\n", "grid.fit(X_train, y_train)\n", "\n", "print(\"Best cross-validation accuracy: {:.2f}\".format(grid.best_score_))\n", @@ -133,5 +133,4 @@ }, "nbformat": 4, "nbformat_minor": 2 - } diff --git a/examples/02b_classification_multivariate_lstmfcn.ipynb b/examples/02b_classification_multivariate_lstmfcn.ipynb index b11ec338b..c7486fc88 100644 --- a/examples/02b_classification_multivariate_lstmfcn.ipynb +++ b/examples/02b_classification_multivariate_lstmfcn.ipynb @@ -75,7 +75,7 @@ "metadata": {}, "outputs": [], "source": [ - "network = LSTMFCNClassifier(n_epochs=200, verbose=0)\n", + "network = LSTMFCNClassifier(n_epochs=65, verbose=0)\n", "network.fit(X_train, y_train)\n", "network.score(X_test, y_test)" ] diff --git a/examples/02c_classification_multivariate_inceptiontime.ipynb b/examples/02c_classification_multivariate_inceptiontime.ipynb index 5bf5c433c..6094630fd 100644 --- a/examples/02c_classification_multivariate_inceptiontime.ipynb +++ b/examples/02c_classification_multivariate_inceptiontime.ipynb @@ -87,7 +87,7 @@ }, "outputs": [], "source": [ - "network = InceptionTimeClassifier(n_epochs=200, verbose=False)\n", + "network = InceptionTimeClassifier(n_epochs=75, verbose=False)\n", "network.fit(X_train, y_train)\n", "network.score(X_test, y_test)" ] @@ -126,9 +126,9 @@ "metadata": { "file_extension": ".py", "kernelspec": { - "name": "python3", + "display_name": "Python 3 (ipykernel)", "language": "python", - "display_name": "Python 3 (ipykernel)" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -150,5 +150,4 @@ }, "nbformat": 4, "nbformat_minor": 2 - } diff --git a/examples/dictionary_based_classification.ipynb b/examples/dictionary_based_classification.ipynb index f65398b23..bb756d52b 100644 --- a/examples/dictionary_based_classification.ipynb +++ b/examples/dictionary_based_classification.ipynb @@ -346,7 +346,7 @@ "source": [ "# Recommended non-contract TDE parameters\n", "tde_u = TemporalDictionaryEnsemble(\n", - " n_parameter_samples=250,\n", + " n_parameter_samples=50,\n", " max_ensemble_size=50,\n", " randomly_selected_params=50,\n", " random_state=47,\n", @@ -395,7 +395,7 @@ "source": [ "# Recommended non-contract TDE parameters\n", "tde_mv = TemporalDictionaryEnsemble(\n", - " n_parameter_samples=250,\n", + " n_parameter_samples=50,\n", " max_ensemble_size=50,\n", " randomly_selected_params=50,\n", " random_state=47,\n", diff --git a/sktime/forecasting/model_selection/_tune.py b/sktime/forecasting/model_selection/_tune.py index 704121477..e7de352f8 100644 --- a/sktime/forecasting/model_selection/_tune.py +++ b/sktime/forecasting/model_selection/_tune.py @@ -2,7 +2,7 @@ # copyright: sktime developers, BSD-3-Clause License (see LICENSE file) """Implements grid search functionality to tune forecasters.""" -__author__ = ["mloning"] +__author__ = ["mloning", "fkiraly", "aiwalter"] __all__ = [ "ForecastingGridSearchCV", "ForecastingRandomizedSearchCV", @@ -11,6 +11,7 @@ __all__ = [ from collections.abc import Sequence from typing import Dict, List, Optional, Union +from warnings import warn import numpy as np import pandas as pd @@ -36,6 +37,8 @@ class BaseGridSearch(_DelegatedForecaster): "capability:pred_int:insample": True, } + # todo 0.24.0: replace all tune_by_variable defaults in this file with False + # remove deprecation message in BaseGridSearch.__init__ def __init__( self, forecaster, @@ -50,6 +53,8 @@ class BaseGridSearch(_DelegatedForecaster): return_n_best_forecasters=1, update_behaviour="full_refit", error_score=np.nan, + tune_by_instance=False, + tune_by_variable=None, ): self.forecaster = forecaster self.cv = cv @@ -63,13 +68,30 @@ class BaseGridSearch(_DelegatedForecaster): self.return_n_best_forecasters = return_n_best_forecasters self.update_behaviour = update_behaviour self.error_score = error_score + self.tune_by_instance = tune_by_instance + self.tune_by_variable = tune_by_variable + super().__init__() + + # todo 0.24.0: remove this + if tune_by_variable is None: + warn( + f"in {self.__class__.__name__}, the default for tune_by_variable " + "will change from True to False in 0.24.0. " + "This will tune one parameter setting for all variables, while " + "currently it tunes one parameter per variable. " + "In order to maintain the current behaviour, ensure to set " + "the parameter tune_by_variable to True explicitly before upgrading " + "to version 0.24.0.", + DeprecationWarning, + ) + tune_by_variable = True + tags_to_clone = [ "requires-fh-in-fit", "capability:pred_int", "capability:pred_int:insample", "capability:insample", - "scitype:y", "ignores-exogeneous-X", "handles-missing-data", "y_inner_mtype", @@ -81,6 +103,11 @@ class BaseGridSearch(_DelegatedForecaster): self._extend_to_all_scitypes("y_inner_mtype") self._extend_to_all_scitypes("X_inner_mtype") + # this ensures univariate broadcasting over variables + # if tune_by_variable is True + if tune_by_variable: + self.set_tags({"scitype:y": "univariate"}) + # attribute for _DelegatedForecaster, which then delegates # all non-overridden methods are same as of getattr(self, _delegate_name) # see further details in _DelegatedForecaster docstring @@ -91,6 +118,11 @@ class BaseGridSearch(_DelegatedForecaster): Mutates self tag with name `tagname`. If no mtypes are present of a time series scitype, adds a pandas based one. + If only univariate pandas scitype is present for Series ("pd.Series"), + also adds the multivariate one ("pd.DataFrame"). + + If tune_by_instance is True, only Series mtypes are added, + and potentially present Panel or Hierarchical mtypes are removed. Parameters ---------- @@ -104,12 +136,22 @@ class BaseGridSearch(_DelegatedForecaster): if not isinstance(tagval, list): tagval = [tagval] scitypes = mtype_to_scitype(tagval, return_unique=True) + # if no Series mtypes are present, add pd.DataFrame if "Series" not in scitypes: tagval = tagval + ["pd.DataFrame"] + # ensure we have a Series mtype capable of multivariate + elif "pd.Series" in tagval and "pd.DataFrame" not in tagval: + tagval = ["pd.DataFrame"] + tagval + # if no Panel mtypes are present, add pd.DataFrame based one if "Panel" not in scitypes: tagval = tagval + ["pd-multiindex"] + # if no Hierarchical mtypes are present, add pd.DataFrame based one if "Hierarchical" not in scitypes: tagval = tagval + ["pd_multiindex_hier"] + + if self.tune_by_instance: + tagval = [x for x in tagval if mtype_to_scitype(x) == "Series"] + self.set_tags({tagname: tagval}) def _get_fitted_params(self): @@ -418,6 +460,22 @@ class ForecastingGridSearchCV(BaseGridSearch): Value to assign to the score if an exception occurs in estimator fitting. If set to "raise", the exception is raised. If a numeric value is given, FitFailedWarning is raised. + tune_by_instance : bool, optional (default=False) + Whether to tune parameter by each time series instance separately, + in case of Panel or Hierarchical data passed to the tuning estimator. + Only applies if time series passed are Panel or Hierarchical. + If True, clones of the forecaster will be fit to each instance separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ForecastByLevel wrapper to self. + If False, the same best parameter is selected for all instances. + tune_by_variable : bool, optional (default=True) + Whether to tune parameter by each time series variable separately, + in case of multivariate data passed to the tuning estimator. + Only applies if time series passed are strictly multivariate. + If True, clones of the forecaster will be fit to each variable separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ColumnEnsembleForecaster wrapper to self. + If False, the same best parameter is selected for all variables. Attributes ---------- @@ -441,6 +499,12 @@ class ForecastingGridSearchCV(BaseGridSearch): n_best_scores_: list of float The scores of n_best_forecasters_ sorted from best to worst score of forecasters + forecasters_ : pd.DataFramee + DataFrame with all fitted forecasters and their parameters. + Only present if tune_by_instance=True or tune_by_variable=True, + and at least one of the two is applicable. + In this case, the other attributes are not present in self, + only in the fields of forecasters_. Examples -------- @@ -520,6 +584,8 @@ class ForecastingGridSearchCV(BaseGridSearch): backend="loky", update_behaviour="full_refit", error_score=np.nan, + tune_by_instance=False, + tune_by_variable=None, ): super().__init__( forecaster=forecaster, @@ -534,6 +600,8 @@ class ForecastingGridSearchCV(BaseGridSearch): backend=backend, update_behaviour=update_behaviour, error_score=error_score, + tune_by_instance=tune_by_instance, + tune_by_variable=tune_by_variable, ) self.param_grid = param_grid @@ -701,6 +769,22 @@ class ForecastingRandomizedSearchCV(BaseGridSearch): Value to assign to the score if an exception occurs in estimator fitting. If set to "raise", the exception is raised. If a numeric value is given, FitFailedWarning is raised. + tune_by_instance : bool, optional (default=False) + Whether to tune parameter by each time series instance separately, + in case of Panel or Hierarchical data passed to the tuning estimator. + Only applies if time series passed are Panel or Hierarchical. + If True, clones of the forecaster will be fit to each instance separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ForecastByLevel wrapper to self. + If False, the same best parameter is selected for all instances. + tune_by_variable : bool, optional (default=True) + Whether to tune parameter by each time series variable separately, + in case of multivariate data passed to the tuning estimator. + Only applies if time series passed are strictly multivariate. + If True, clones of the forecaster will be fit to each variable separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ColumnEnsembleForecaster wrapper to self. + If False, the same best parameter is selected for all variables. Attributes ---------- @@ -718,6 +802,12 @@ class ForecastingRandomizedSearchCV(BaseGridSearch): n_best_scores_: list of float The scores of n_best_forecasters_ sorted from best to worst score of forecasters + forecasters_ : pd.DataFramee + DataFrame with all fitted forecasters and their parameters. + Only present if tune_by_instance=True or tune_by_variable=True, + and at least one of the two is applicable. + In this case, the other attributes are not present in self, + only in the fields of forecasters_. """ def __init__( @@ -737,6 +827,8 @@ class ForecastingRandomizedSearchCV(BaseGridSearch): backend="loky", update_behaviour="full_refit", error_score=np.nan, + tune_by_instance=False, + tune_by_variable=None, ): super().__init__( forecaster=forecaster, @@ -751,6 +843,8 @@ class ForecastingRandomizedSearchCV(BaseGridSearch): backend=backend, update_behaviour=update_behaviour, error_score=error_score, + tune_by_instance=tune_by_instance, + tune_by_variable=tune_by_variable, ) self.param_distributions = param_distributions self.n_iter = n_iter @@ -906,6 +1000,22 @@ class ForecastingSkoptSearchCV(BaseGridSearch): backend : str, optional (default="loky") Specify the parallelisation backend implementation in joblib, where "loky" is used by default. + tune_by_instance : bool, optional (default=False) + Whether to tune parameter by each time series instance separately, + in case of Panel or Hierarchical data passed to the tuning estimator. + Only applies if time series passed are Panel or Hierarchical. + If True, clones of the forecaster will be fit to each instance separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ForecastByLevel wrapper to self. + If False, the same best parameter is selected for all instances. + tune_by_variable : bool, optional (default=True) + Whether to tune parameter by each time series variable separately, + in case of multivariate data passed to the tuning estimator. + Only applies if time series passed are strictly multivariate. + If True, clones of the forecaster will be fit to each variable separately, + and are available in fields of the forecasters_ attribute. + Has the same effect as applying ColumnEnsembleForecaster wrapper to self. + If False, the same best parameter is selected for all variables. Attributes ---------- @@ -923,6 +1033,12 @@ class ForecastingSkoptSearchCV(BaseGridSearch): n_best_scores_: list of float The scores of n_best_forecasters_ sorted from best to worst score of forecasters + forecasters_ : pd.DataFramee + DataFrame with all fitted forecasters and their parameters. + Only present if tune_by_instance=True or tune_by_variable=True, + and at least one of the two is applicable. + In this case, the other attributes are not present in self, + only in the fields of forecasters_. Examples -------- @@ -982,6 +1098,8 @@ class ForecastingSkoptSearchCV(BaseGridSearch): backend: str = "loky", update_behaviour: str = "full_refit", error_score=np.nan, + tune_by_instance=False, + tune_by_variable=None, ): self.param_distributions = param_distributions self.n_iter = n_iter @@ -1001,6 +1119,8 @@ class ForecastingSkoptSearchCV(BaseGridSearch): backend=backend, update_behaviour=update_behaviour, error_score=error_score, + tune_by_instance=tune_by_instance, + tune_by_variable=tune_by_variable, ) def _fit(self, y, X=None, fh=None):	sktime/sktime	809ce86ee613d6a602585a6bcd3502cbbdc7c942	diff --git a/sktime/forecasting/model_selection/tests/test_tune.py b/sktime/forecasting/model_selection/tests/test_tune.py index 12afc70a7..f374e51a6 100644 --- a/sktime/forecasting/model_selection/tests/test_tune.py +++ b/sktime/forecasting/model_selection/tests/test_tune.py @@ -1,9 +1,8 @@ #!/usr/bin/env python3 -u # copyright: sktime developers, BSD-3-Clause License (see LICENSE file) -"""Test grid search CV.""" +"""Test forecasting tuners.""" __author__ = ["mloning", "fkiraly"] -__all__ = ["test_gscv", "test_rscv"] import numpy as np import pytest @@ -81,12 +80,13 @@ def _check_cv(forecaster, tuner, cv, param_grid, y, X, scoring): assert param_grid[best_idx].items() <= fitted_params.items() -def _create_hierarchical_data(): +def _create_hierarchical_data(n_columns=1): y = _make_hierarchical( random_state=TEST_RANDOM_SEEDS[0], hierarchy_levels=(2, 2), min_timepoints=15, max_timepoints=15, + n_columns=n_columns, ) X = _make_hierarchical( random_state=TEST_RANDOM_SEEDS[1], @@ -97,7 +97,10 @@ def _create_hierarchical_data(): return y, X -NAIVE = NaiveForecaster(strategy="mean") +# estimator fixtures used for tuning +# set_tags in NaiveForecaster ensures that it is univariate and broadcasts +# this is currently the case, but a future improved NaiveForecaster may reduce coverage +NAIVE = NaiveForecaster(strategy="mean").set_tags(**{"scitype:y": "univariate"}) NAIVE_GRID = {"window_length": TEST_WINDOW_LENGTHS_INT} PIPE = TransformedTargetForecaster( [ @@ -126,15 +129,24 @@ ERROR_SCORES = [np.nan, "raise", 1000] @pytest.mark.parametrize("scoring", TEST_METRICS) @pytest.mark.parametrize("cv", CVs) @pytest.mark.parametrize("error_score", ERROR_SCORES) -def test_gscv(forecaster, param_grid, cv, scoring, error_score): [email protected]("multivariate", [True, False]) +def test_gscv(forecaster, param_grid, cv, scoring, error_score, multivariate): """Test ForecastingGridSearchCV.""" - y, X = load_longley() + if multivariate: + X, y = load_longley() + else: + y, X = load_longley() + gscv = ForecastingGridSearchCV( forecaster, param_grid=param_grid, cv=cv, scoring=scoring, error_score=error_score, + # todo 0.24.0: remove this + # and/or add a test for tune_by_variable=True + # in this case, the forecaster is expeceted to vectorize over columns + tune_by_variable=False, ) gscv.fit(y, X) @@ -177,6 +189,7 @@ def test_rscv(forecaster, param_grid, cv, scoring, error_score, n_iter, random_s ParameterSampler(param_grid, n_iter, random_state=random_state) ) _check_cv(forecaster, rscv, cv, param_distributions, y, X, scoring) + _check_fitted_params_keys(rscv.get_fitted_params()) @pytest.mark.skipif( @@ -189,20 +202,26 @@ def test_rscv(forecaster, param_grid, cv, scoring, error_score, n_iter, random_s @pytest.mark.parametrize("scoring", TEST_METRICS) @pytest.mark.parametrize("cv", CVs) @pytest.mark.parametrize("error_score", ERROR_SCORES) -def test_gscv_hierarchical(forecaster, param_grid, cv, scoring, error_score): [email protected]("n_cols", [1, 2]) +def test_gscv_hierarchical(forecaster, param_grid, cv, scoring, error_score, n_cols): """Test ForecastingGridSearchCV.""" - y, X = _create_hierarchical_data() + y, X = _create_hierarchical_data(n_columns=n_cols) gscv = ForecastingGridSearchCV( forecaster, param_grid=param_grid, cv=cv, scoring=scoring, error_score=error_score, + # todo 0.24.0: remove this + # and/or add a test for tune_by_variable=True + # in this case, the forecaster is expeceted to vectorize over columns + tune_by_variable=False, ) gscv.fit(y, X) param_grid = ParameterGrid(param_grid) _check_cv(forecaster, gscv, cv, param_grid, y, X, scoring) + _check_fitted_params_keys(gscv.get_fitted_params()) @pytest.mark.skipif( diff --git a/sktime/proba/tests/test_all_distrs.py b/sktime/proba/tests/test_all_distrs.py index 5e8594495..5808d9d2c 100644 --- a/sktime/proba/tests/test_all_distrs.py +++ b/sktime/proba/tests/test_all_distrs.py @@ -72,7 +72,7 @@ class TestAllDistributions(DistributionFixtureGenerator, QuickTester): assert (res_panel.index == dummy_panel.index).all() assert (res_panel.columns == dummy_panel.columns).all() - @pytest.mark.parametrize("method", METHODS_SCALAR) + @pytest.mark.parametrize("method", METHODS_SCALAR, ids=METHODS_SCALAR) def test_methods_scalar(self, estimator_instance, method): """Test expected return of scalar methods.""" if not _has_capability(estimator_instance, method): @@ -83,7 +83,7 @@ class TestAllDistributions(DistributionFixtureGenerator, QuickTester): _check_output_format(res, d, method) - @pytest.mark.parametrize("method", METHODS_X) + @pytest.mark.parametrize("method", METHODS_X, ids=METHODS_X) def test_methods_x(self, estimator_instance, method): """Test expected return of methods that take sample-like argument.""" if not _has_capability(estimator_instance, method): @@ -95,7 +95,7 @@ class TestAllDistributions(DistributionFixtureGenerator, QuickTester): _check_output_format(res, d, method) - @pytest.mark.parametrize("method", METHODS_P) + @pytest.mark.parametrize("method", METHODS_P, ids=METHODS_P) def test_methods_p(self, estimator_instance, method): """Test expected return of methods that take percentage-like argument.""" if not _has_capability(estimator_instance, method): diff --git a/sktime/registry/tests/test_tags.py b/sktime/registry/tests/test_tags.py new file mode 100644 index 000000000..e3e738163 --- /dev/null +++ b/sktime/registry/tests/test_tags.py @@ -0,0 +1,24 @@ +"""Tests for tag register an tag functionality.""" + +from sktime.registry._tags import ESTIMATOR_TAG_REGISTER + + +def test_tag_register_type(): + """Test the specification of the tag register. See _tags for specs.""" + assert isinstance(ESTIMATOR_TAG_REGISTER, list) + assert all(isinstance(tag, tuple) for tag in ESTIMATOR_TAG_REGISTER) + + for tag in ESTIMATOR_TAG_REGISTER: + assert len(tag) == 4 + assert isinstance(tag[0], str) + assert isinstance(tag[1], (str, list)) + if isinstance(tag[1], list): + assert all(isinstance(x, str) for x in tag[1]) + assert isinstance(tag[2], (str, tuple)) + if isinstance(tag[2], tuple): + assert len(tag[2]) == 2 + assert isinstance(tag[2][0], str) + assert isinstance(tag[2][1], (list, str)) + if isinstance(tag[2][1], list): + assert all(isinstance(x, str) for x in tag[2][1]) + assert isinstance(tag[3], str)	[ENH] speed up notebooks and notebook tests It seems the notebooks in `examples` take 50min to run, all taken together. I remember times where this was closer to 20min - we should investigate where runtime is spent in the notebooks, and optimally replace by faster examples that illustrate the same point(s). Good first issue - simply go through the notebooks, run them and check which cells take longest. There are also a number of more "obscure" notebooks, we may consider removing them, or shortening them, or making the data sets smaller.	809ce86ee613d6a602585a6bcd3502cbbdc7c942	[ "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv0-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv0-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-raise-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-nan-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv2-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[False-1000-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv1-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv2-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv1-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv1-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-raise-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-1000-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[1-nan-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv0-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-1000-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv1-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-nan-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv[True-raise-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-nan-cv2-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv2-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-1000-cv0-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_gscv_hierarchical[2-raise-cv1-scoring0-forecaster1-param_grid1]" ]	[ "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-1-cdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-0-mean]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-0-energy]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_p[Normal-0-ppf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-1-var]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-1-energy]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_quantile[Normal-0-0.7]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-0-cdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-0-pdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-0-energy]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_quantile[Normal-1-q1]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-1-mean]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_p[Normal-1-ppf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-0-var]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_scalar[Normal-1-energy]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_sample[Normal-0]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_sample[Normal-1]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-0-log_pdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-1-log_pdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_quantile[Normal-1-0.7]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_methods_x[Normal-1-pdf]", "sktime/proba/tests/test_all_distrs.py::TestAllDistributions::test_quantile[Normal-0-q1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-nan-scoring1-forecaster1-param_grid1]", "sktime/registry/tests/test_tags.py::test_tag_register_type", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv0-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv0-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-nan-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-nan-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-raise-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv1-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-raise-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-1000-scoring0-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-1000-scoring1-forecaster0-param_grid0]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv1-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-1-cv2-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv0-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv0-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-raise-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv1-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv1-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-1-cv2-1000-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[1-4-cv2-nan-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-1000-scoring1-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-nan-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-raise-scoring0-forecaster1-param_grid1]", "sktime/forecasting/model_selection/tests/test_tune.py::test_rscv[42-4-cv2-1000-scoring0-forecaster1-param_grid1]" ]	{ "failed_lite_validators": [ "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-08-27 17:17:04+00:00	bsd-3-clause	5,531
sktime__sktime-5208	diff --git a/.all-contributorsrc b/.all-contributorsrc index 3441d6560..ed91edebc 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -1740,6 +1740,7 @@ "name": "Benedikt Heidrich", "profile": "https://github.com/benheid", "contributions": [ + "bug", "code" ] }, diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index ad94a9858..238a9a1e6 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -50,7 +50,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d <tr> <td align="center" valign="top" width="11.11%"><a href="https://github.com/BandaSaiTejaReddy"><img src="https://avatars0.githubusercontent.com/u/31387911?v=4?s=100" width="100px;" alt="BANDASAITEJAREDDY"/><br /><sub><b>BANDASAITEJAREDDY</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=BandaSaiTejaReddy" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=BandaSaiTejaReddy" title="Documentation">📖</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/badrmarani"><img src="https://avatars.githubusercontent.com/badrmarani?s=100" width="100px;" alt="Badr-Eddine Marani"/><br /><sub><b>Badr-Eddine Marani</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=badrmarani" title="Code">💻</a></td> - <td align="center" valign="top" width="11.11%"><a href="https://github.com/benheid"><img src="?s=100" width="100px;" alt="Benedikt Heidrich"/><br /><sub><b>Benedikt Heidrich</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=benheid" title="Code">💻</a></td> + <td align="center" valign="top" width="11.11%"><a href="https://github.com/benheid"><img src="?s=100" width="100px;" alt="Benedikt Heidrich"/><br /><sub><b>Benedikt Heidrich</b></sub></a><br /><a href="https://github.com/sktime/sktime/issues?q=author%3Abenheid" title="Bug reports">🐛</a> <a href="https://github.com/sktime/sktime/commits?author=benheid" title="Code">💻</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/benjaminbluhm"><img src="?s=100" width="100px;" alt="Benjamin Bluhm"/><br /><sub><b>Benjamin Bluhm</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=benjaminbluhm" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=benjaminbluhm" title="Documentation">📖</a> <a href="#example-benjaminbluhm" title="Examples">💡</a></td> <td align="center" valign="top" width="11.11%"><a href="https://haskarb.github.io/"><img src="https://avatars.githubusercontent.com/u/20501023?v=4?s=100" width="100px;" alt="Bhaskar Dhariyal"/><br /><sub><b>Bhaskar Dhariyal</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=haskarb" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=haskarb" title="Tests">⚠️</a></td> <td align="center" valign="top" width="11.11%"><a href="https://github.com/BINAYKUMAR943"><img src="https://avatars.githubusercontent.com/u/38756834?v=4?s=100" width="100px;" alt="Binay Kumar"/><br /><sub><b>Binay Kumar</b></sub></a><br /><a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Code">💻</a> <a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Documentation">📖</a> <a href="https://github.com/sktime/sktime/commits?author=BINAYKUMAR943" title="Tests">⚠️</a></td> diff --git a/sktime/transformations/series/subset.py b/sktime/transformations/series/subset.py index a578e966d..d82b6a0ee 100644 --- a/sktime/transformations/series/subset.py +++ b/sktime/transformations/series/subset.py @@ -160,6 +160,7 @@ class ColumnSelect(BaseTransformer): "fit_is_empty": True, "univariate-only": False, "capability:inverse_transform": False, + "skip-inverse-transform": True, } def __init__(self, columns=None, integer_treatment="col", index_treatment="remove"):	sktime/sktime	ff6f059c5d78af345c061209147fd42c1c7d6cdf	diff --git a/sktime/transformations/series/tests/test_subset.py b/sktime/transformations/series/tests/test_subset.py index 2137b95e5..f400a5794 100644 --- a/sktime/transformations/series/tests/test_subset.py +++ b/sktime/transformations/series/tests/test_subset.py @@ -7,6 +7,7 @@ import pandas as pd import pytest from sktime.datasets import load_airline, load_longley +from sktime.forecasting.naive import NaiveForecaster from sktime.transformations.series.subset import ColumnSelect, IndexSubset @@ -49,3 +50,10 @@ def test_columnselect_int(): X_subset = transformer.fit_transform(X=X) assert X_subset.columns.equals(X.columns[[0, 2, 4]]) + + +def test_columnselect_as_first_step_in_transformedtargetforecaster(): + y = load_longley()[1][["GNP", "UNEMP"]] + fc = ColumnSelect(["GNP"]) * NaiveForecaster() + fc.fit(y) + fc.predict(fh=[1])	[BUG] ColumnSelect missing tag`"skip-inverse-transform"` Describe the bug <!-- A clear and concise description of what the bug is. --> The ColumnSelect is missing the tag `"skip-inverse-transform"`. Thus, a TransformedTargetForecaster subsetting the `y` input will fail when calling predict. To Reproduce <!-- Add a Minimal, Complete, and Verifiable example (for more details, see e.g. https://stackoverflow.com/help/mcve If the code is too long, feel free to put it in a public gist and link it in the issue: https://gist.github.com --> ```python from sktime.forecasting.naive import NaiveForecaster from sktime.transformations.series.subset import ColumnSelect from sktime.datasets import load_longley y = load_longley()[1][["GNP", "UNEMP"]] fc = ColumnSelect(["GNP"]) * NaiveForecaster() fc.fit(y) fc.predict(fh=[1]) ``` Expected behavior <!-- A clear and concise description of what you expected to happen. --> I would expect that the forecast is performed only on the selected time series without raising an error. Additional context <!-- Add any other context about the problem here. --> This would be fixed by just adding the tag `skip-inverse-transform` to ColumnSelect.	ff6f059c5d78af345c061209147fd42c1c7d6cdf	[ "sktime/transformations/series/tests/test_subset.py::test_columnselect_as_first_step_in_transformedtargetforecaster" ]	[ "sktime/transformations/series/tests/test_subset.py::test_columnselect_indextreatment[keep]", "sktime/transformations/series/tests/test_subset.py::test_columnselect_int", "sktime/transformations/series/tests/test_subset.py::test_columnselect_indextreatment[remove]", "sktime/transformations/series/tests/test_subset.py::test_indexsubset_indextreatment[remove]", "sktime/transformations/series/tests/test_subset.py::test_indexsubset_indextreatment[keep]" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files" ], "has_test_patch": true, "is_lite": false }	2023-09-10 09:26:29+00:00	bsd-3-clause	5,532
sktime__sktime-5615	diff --git a/.all-contributorsrc b/.all-contributorsrc index 2663647c5..68675014c 100644 --- a/.all-contributorsrc +++ b/.all-contributorsrc @@ -2462,6 +2462,15 @@ "code" ] }, + { + "login": "rahulporuri", + "name": "Poruri Sai Rahul", + "avatar_url": "https://avatars.githubusercontent.com/u/1926457?v=4", + "profile": "https://github.com/rahulporuri", + "contributions": [ + "doc" + ] + }, { "login": "fspinna", "name": "Francesco Spinnato", diff --git a/sktime/classification/kernel_based/_rocket_classifier.py b/sktime/classification/kernel_based/_rocket_classifier.py index fb5a265de..c62173a41 100644 --- a/sktime/classification/kernel_based/_rocket_classifier.py +++ b/sktime/classification/kernel_based/_rocket_classifier.py @@ -30,15 +30,17 @@ class RocketClassifier(_DelegatedClassifier): Shorthand for the pipeline `rocket * StandardScaler(with_mean=False) * RidgeClassifierCV(alphas)` where `alphas = np.logspace(-3, 3, 10)`, and - where `rocket` depends on params `rocket_transform`, `use_multivariate` as follows: - - \| rocket_transform \| `use_multivariate` \| rocket (class) \| - \|------------------\|--------------------\|-------------------------\| - \| "rocket" \| any \| Rocket \| - \| "minirocket" \| "yes \| MiniRocketMultivariate \| - \| "minirocket" \| "no" \| MiniRocket \| - \| "multirocket" \| "yes" \| MultiRocketMultivariate \| - \| "multirocket" \| "no" \| MultiRocket \| + where `rocket` depends on params `rocket_transform`, `use_multivariate` as follows + + ================ ================== ======================= + rocket_transform `use_multivariate` rocket (class) + ================ ================== ======================= + "rocket" any Rocket + "minirocket" "yes" MiniRocketMultivariate + "minirocket" "no" MiniRocket + "multirocket" "yes" MultiRocketMultivariate + "multirocket" "no" MultiRocket + ================ ================== ======================= classes are sktime classes, other parameters are passed on to the rocket class. diff --git a/sktime/forecasting/arch/_uarch.py b/sktime/forecasting/arch/_uarch.py index c63790215..62098f253 100644 --- a/sktime/forecasting/arch/_uarch.py +++ b/sktime/forecasting/arch/_uarch.py @@ -251,6 +251,7 @@ class ARCH(BaseForecaster): if fh: self._horizon = fh + y_name = y.name self._forecaster = _ARCH( y=y, x=X, @@ -277,6 +278,7 @@ class ARCH(BaseForecaster): options=self.options, backcast=self.backcast, ) + y.name = y_name return self def _get_arch_result_object(self, fh=None, X=None): @@ -344,7 +346,7 @@ class ARCH(BaseForecaster): y_pred = pd.Series( ArchResultObject.mean.values[-1], index=full_range, - name=str(self._y.name), + name=self._y.name, ) y_pred = y_pred.loc[abs_idx.to_pandas()] y_pred.index = self._horizon.to_absolute_index(self.cutoff) @@ -398,11 +400,15 @@ class ARCH(BaseForecaster): upper_int = mean_forecast + (z_critical * std_err) lower_df = pd.DataFrame( lower_int, - columns=[y_col_name + " " + str(alpha) + " " + "lower"], + columns=[ + y_col_name if y_col_name else "0" + " " + str(alpha) + " " + "lower" + ], ) upper_df = pd.DataFrame( upper_int, - columns=[y_col_name + " " + str(alpha) + " " + "upper"], + columns=[ + y_col_name if y_col_name else "0" + " " + str(alpha) + " " + "upper" + ], ) df_list.append(pd.concat((lower_df, upper_df), axis=1)) concat_df = pd.concat(df_list, axis=1) @@ -410,7 +416,7 @@ class ARCH(BaseForecaster): OrderedDict.fromkeys( [ col_df - for col in y_col_name + for col in (y_col_name if y_col_name else "0") for col_df in concat_df.columns if col in col_df ] @@ -425,7 +431,7 @@ class ARCH(BaseForecaster): final_columns = list( itertools.product( [ - [y_col_name], + [y_col_name if y_col_name else 0], coverage, df.columns.get_level_values(2).unique(), ] diff --git a/sktime/forecasting/base/adapters/_fbprophet.py b/sktime/forecasting/base/adapters/_fbprophet.py index 79ac65bf0..acc32d7f6 100644 --- a/sktime/forecasting/base/adapters/_fbprophet.py +++ b/sktime/forecasting/base/adapters/_fbprophet.py @@ -116,7 +116,10 @@ class _ProphetAdapter(BaseForecaster): df["cap"] = self.growth_cap df["floor"] = self.growth_floor - fit_kwargs = self.fit_kwargs or {} + if hasattr(self, "fit_kwargs") and isinstance(self.fit_kwargs, dict): + fit_kwargs = self.fit_kwargs + else: + fit_kwargs = {} if self.verbose: self._forecaster.fit(df=df, *fit_kwargs) else: diff --git a/sktime/forecasting/compose/_hierarchy_ensemble.py b/sktime/forecasting/compose/_hierarchy_ensemble.py index 1eca3af03..12cb104ca 100644 --- a/sktime/forecasting/compose/_hierarchy_ensemble.py +++ b/sktime/forecasting/compose/_hierarchy_ensemble.py @@ -285,7 +285,8 @@ class HierarchyEnsembleForecaster(_HeterogenousEnsembleForecaster): if counter == 0: nodes = mi else: - nodes.append(mi) + # For nlevels = 2, 'nodes' is pd.Index object (L286) + nodes = nodes.append(mi) else: node_l = [] for i in range(len(node)): @@ -495,6 +496,7 @@ class HierarchyEnsembleForecaster(_HeterogenousEnsembleForecaster): raise ValueError("Nodes cannot be empty.") if z.index.nlevels == 2: nodes_ix = pd.Index(nodes) + nodes_t += nodes else: nodes_l = [] for i in range(len(nodes)):	sktime/sktime	74c55ced89bdc62738dce717cf1e634e28da0e45	diff --git a/sktime/forecasting/compose/tests/test_hierarchy_ensemble.py b/sktime/forecasting/compose/tests/test_hierarchy_ensemble.py index b3a655fb4..e56194314 100644 --- a/sktime/forecasting/compose/tests/test_hierarchy_ensemble.py +++ b/sktime/forecasting/compose/tests/test_hierarchy_ensemble.py @@ -7,10 +7,11 @@ __author__ = ["VyomkeshVyas"] import numpy as np import pytest +from sktime.base._meta import flatten from sktime.datatypes._utilities import get_window from sktime.forecasting.compose import HierarchyEnsembleForecaster from sktime.forecasting.naive import NaiveForecaster -from sktime.forecasting.trend import PolynomialTrendForecaster +from sktime.forecasting.trend import PolynomialTrendForecaster, TrendForecaster from sktime.transformations.hierarchical.aggregate import Aggregator from sktime.utils._testing.hierarchical import _bottom_hier_datagen, _make_hierarchical from sktime.utils.validation._dependencies import _check_soft_dependencies @@ -145,3 +146,57 @@ def test_hierarchy_ensemble_exog(forecasters): estimator_instance.fit(y=y_train, X=X_train, fh=[1, 2, 3]) estimator_instance.predict(X=X_test) estimator_instance.update(y=y_test, X=X_test) + + [email protected]( + "forecasters", + [ + [ + ("trend", TrendForecaster(), ["l1_node01"]), + ("polytrend", PolynomialTrendForecaster(), ["l1_node02", "l1_node03"]), + ("naive", NaiveForecaster(), ["__total"]), + ], + [ + ( + "trend", + TrendForecaster(), + [("__total"), ("l1_node01"), ("l1_node02"), ("l1_node03")], + ), + ], + ], +) [email protected]("default", [NaiveForecaster(), None]) +def test_level_one_data(forecasters, default): + "Check for data with one level of hierarchy (excluding timepoints level)." + agg = Aggregator() + + y = _bottom_hier_datagen( + no_bottom_nodes=3, + no_levels=1, + random_seed=123, + ) + + forecaster = HierarchyEnsembleForecaster(forecasters, by="node", default=default) + + forecaster.fit(y, fh=[1, 2, 3]) + actual_pred = forecaster.predict() + + y = agg.fit_transform(y) + + for i in range(len(forecasters)): + test_frcstr = forecasters[i][1].clone() + df = y[y.index.droplevel(-1).isin(forecaster.fitted_list[i][1])] + test_frcstr.fit(df, fh=[1, 2, 3]) + test_pred = test_frcstr.predict() + msg = "Node predictions do not match" + assert np.all(actual_pred.loc[test_pred.index] == test_pred), msg + + _, _, nodes = zip(*forecasters) + nodes = set(flatten(nodes)) + if default is not None and len(nodes) != len(y.index.droplevel(-1).unique()): + def_frcstr = default + df = y[y.index.droplevel(-1).isin(forecaster.fitted_list[-1][1])] + def_frcstr.fit(df, fh=[1, 2, 3]) + def_pred = def_frcstr.predict() + msg = "Node default predictions do not match" + assert np.all(actual_pred.loc[def_pred.index] == def_pred), msg diff --git a/sktime/forecasting/tests/test_all_forecasters.py b/sktime/forecasting/tests/test_all_forecasters.py index 3bff7ad35..07929a18e 100644 --- a/sktime/forecasting/tests/test_all_forecasters.py +++ b/sktime/forecasting/tests/test_all_forecasters.py @@ -383,7 +383,7 @@ class TestAllForecasters(ForecasterFixtureGenerator, QuickTester): found = pred_ints.columns.to_flat_index() msg = ( - "columns of returned prediction interval DataFrame do not" + "columns of returned prediction interval DataFrame do not " f"match up with expected columns. Expected: {expected}," f"found: {found}" )	[BUG] `HierarchyEnsembleForecaster` returns unexpected predictions if data has only one hierarchy level and forecasters specified by node Describe the bug The `HierarchyEnsembleForecaster` returns unexpected predictions if the hierarchy has only one level and different forecasters are specified per node (`by=node`). To Reproduce The code snippet below is similar to the examples in the [documentation](https://www.sktime.net/en/latest/api_reference/auto_generated/sktime.forecasting.compose.HierarchyEnsembleForecaster.html) but with only one level instead of two and only 3 bottom nodes instead of 7. ```python from sktime.forecasting.compose import HierarchyEnsembleForecaster from sktime.forecasting.naive import NaiveForecaster from sktime.forecasting.trend import PolynomialTrendForecaster, TrendForecaster from sktime.utils._testing.hierarchical import _bottom_hier_datagen y = _bottom_hier_datagen( no_bottom_nodes=3, no_levels=1, random_seed=123 ) y.groupby(["l1_agg"]).sum().index # Example of by = 'node' forecasters = [ ('trend', TrendForecaster(), [("__total")]), ('poly', PolynomialTrendForecaster(degree=2), [('l1_node01')]), ] forecaster = HierarchyEnsembleForecaster( forecasters=forecasters, by='node', default=NaiveForecaster() ) forecaster.fit(y, fh=[1, 2, 3]) y_pred = forecaster.predict() y_pred ``` Output: <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th></th> <th>passengers</th> </tr> <tr> <th>l1_agg</th> <th>timepoints</th> <th></th> </tr> </thead> <tbody> <tr> <th rowspan="3" valign="top">__total</th> <th>1961-01</th> <td>9024.895980</td> </tr> <tr> <th>1961-02</th> <td>9075.494395</td> </tr> <tr> <th>1961-03</th> <td>9126.092810</td> </tr> <tr> <th rowspan="6" valign="top">l1_node01</th> <th>1961-01</th> <td>497.671704</td> </tr> <tr> <th>1961-01</th> <td>432.000000</td> </tr> <tr> <th>1961-02</th> <td>501.352085</td> </tr> <tr> <th>1961-02</th> <td>432.000000</td> </tr> <tr> <th>1961-03</th> <td>505.046482</td> </tr> <tr> <th>1961-03</th> <td>432.000000</td> </tr> <tr> <th rowspan="3" valign="top">l1_node02</th> <th>1961-01</th> <td>5893.819230</td> </tr> <tr> <th>1961-02</th> <td>5893.819230</td> </tr> <tr> <th>1961-03</th> <td>5893.819230</td> </tr> <tr> <th rowspan="3" valign="top">l1_node03</th> <th>1961-01</th> <td>1919.395692</td> </tr> <tr> <th>1961-02</th> <td>1919.395692</td> </tr> <tr> <th>1961-03</th> <td>1919.395692</td> </tr> </tbody> </table> </div> Expected behavior Output: <div> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th></th> <th>passengers</th> </tr> <tr> <th>l1_agg</th> <th>timepoints</th> <th></th> </tr> </thead> <tbody> <tr> <th rowspan="3" valign="top">__total</th> <th>1961-01</th> <td>9024.895980</td> </tr> <tr> <th>1961-02</th> <td>9075.494395</td> </tr> <tr> <th>1961-03</th> <td>9126.092810</td> </tr> <tr> <th rowspan="3" valign="top">l1_node01</th> <th>1961-01</th> <td>497.671704</td> </tr> <tr> <th>1961-02</th> <td>501.352085</td> </tr> <tr> <th>1961-03</th> <td>505.046482</td> </tr> <tr> <th rowspan="3" valign="top">l1_node02</th> <th>1961-01</th> <td>5893.819230</td> </tr> <tr> <th>1961-02</th> <td>5893.819230</td> </tr> <tr> <th>1961-03</th> <td>5893.819230</td> </tr> <tr> <th rowspan="3" valign="top">l1_node03</th> <th>1961-01</th> <td>1919.395692</td> </tr> <tr> <th>1961-02</th> <td>1919.395692</td> </tr> <tr> <th>1961-03</th> <td>1919.395692</td> </tr> </tbody> </table> </div> Additional context The predictions for the node `l1_node01` are duplicated. The first occurrences are the predictions from `PolynomialTrendForecaster`. The second occurrences are predictions of the `NaiveForecaster` which is configured as default. If using two hierarchy levels as in the documentation the predictions are as expected (i.e., no duplicates from the default predictor). I tried to stay close to the example in the doc. However, maybe I am just using the `HierarchyEnsembleForecaster` class wrong. Versions System: python: 3.11.5 \| packaged by conda-forge \| (main, Aug 27 2023, 03:35:23) [Clang 15.0.7 ] executable: ../anaconda3/envs/sktime311/bin/python machine: macOS-14.0-x86_64-i386-64bit Python dependencies: pip: 23.2.1 sktime: 0.24.0 sklearn: 1.3.0 skbase: 0.5.1 numpy: 1.25.2 scipy: 1.11.2 pandas: 2.0.3 matplotlib: 3.7.2 joblib: 1.3.2 numba: None statsmodels: 0.14.0 pmdarima: 2.0.3 statsforecast: None tsfresh: None tslearn: None torch: None tensorflow: None tensorflow_probability: None	74c55ced89bdc62738dce717cf1e634e28da0e45	[ "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_level_one_data[None-forecasters1]", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_level_one_data[None-forecasters0]", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_level_one_data[default0-forecasters0]" ]	[ "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ThetaModularForecaster-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[PluginParamsForecaster-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ColumnEnsembleForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[RecursiveTimeSeriesRegressionForecaster-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[HierarchyEnsembleForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[CurveFitForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-2-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ColumnEnsembleForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[UpdateRefitsEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTabularRegressionForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ThetaModularForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTabularRegressionForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ForecastX-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[HierarchyEnsembleForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[Croston-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[SquaringResiduals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[UpdateRefitsEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ThetaModularForecaster-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ForecastingPipeline-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ConformalIntervals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ConformalIntervals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[Croston-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[SquaringResiduals-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-2-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateRefitsEvery-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[RecursiveTabularRegressionForecaster-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-2-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[HierarchyEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ConformalIntervals-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ForecastX-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-2-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateEvery-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-2-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[SquaringResiduals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[MultiplexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[MultiplexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[HierarchyEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[FhPlexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-2-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[HierarchyEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ThetaModularForecaster-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[Croston-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ConformalIntervals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[FhPlexForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[FhPlexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastX-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-2-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ThetaModularForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[TransformedTargetForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-2-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ConformalIntervals-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-2-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateEvery-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[TransformedTargetForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-2-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[CurveFitForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[PluginParamsForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ForecastingPipeline-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[RecursiveTabularRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateEvery-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[TransformedTargetForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[PluginParamsForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[TransformedTargetForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastX-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-2-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-2-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ColumnEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ForecastX-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ForecastingPipeline-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-2-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[UpdateEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-2-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTabularRegressionForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-2-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[SquaringResiduals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ColumnEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-2-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-2-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-2-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=[-2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[SquaringResiduals-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[MultiplexForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ConformalIntervals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ColumnEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[UpdateEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ThetaModularForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateEvery-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=[-3", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[Croston-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[MultiplexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ColumnEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ConformalIntervals-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-2-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[FhPlexForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[SquaringResiduals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[PluginParamsForecaster-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-2-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[MultiplexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[PluginParamsForecaster-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[Croston-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-2-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-2-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[FhPlexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[HierarchyEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ForecastX-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ForecastX-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[HierarchyEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ThetaModularForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-2-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateEvery-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[PluginParamsForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[TransformedTargetForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[TransformedTargetForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateEvery-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateRefitsEvery-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[CurveFitForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-2-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[UpdateEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[SquaringResiduals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[FhPlexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-2-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-2-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateRefitsEvery-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[TransformedTargetForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-2-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[UpdateEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[Croston-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[RecursiveTabularRegressionForecaster-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[PluginParamsForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[CurveFitForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[FhPlexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[TransformedTargetForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[UpdateRefitsEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[CurveFitForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[HierarchyEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[HierarchyEnsembleForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ThetaModularForecaster-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ConformalIntervals-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ColumnEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-2-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTabularRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[PluginParamsForecaster-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[UpdateEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[RecursiveTimeSeriesRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-2-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-2-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ForecastingPipeline-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[RecursiveTabularRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[UpdateRefitsEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[MultiplexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[MultiplexForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ConformalIntervals-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ThetaModularForecaster-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[PluginParamsForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-2-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[PluginParamsForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[Croston-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[Croston-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ColumnEnsembleForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[UpdateRefitsEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ColumnEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-1-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ConformalIntervals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[FhPlexForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ThetaModularForecaster-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-2-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[RecursiveTimeSeriesRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastX-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-2-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ColumnEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ThetaModularForecaster-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[PluginParamsForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[CurveFitForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[CurveFitForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[Croston-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[TransformedTargetForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ConformalIntervals-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[PluginParamsForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[UpdateEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ThetaModularForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-2-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[MultiplexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-2-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[FhPlexForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[RecursiveTabularRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[FhPlexForecaster-2-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[CurveFitForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ColumnEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ForecastingPipeline-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[TransformedTargetForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ForecastingPipeline-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ConformalIntervals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-2-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-2-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[SquaringResiduals-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[TransformedTargetForecaster-2-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-2-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[PluginParamsForecaster-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[Croston-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[CurveFitForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[RecursiveTabularRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ConformalIntervals-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ThetaModularForecaster-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ConformalIntervals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ForecastingPipeline-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[Croston-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[FhPlexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTabularRegressionForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[HierarchyEnsembleForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[RecursiveTabularRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ColumnEnsembleForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[SquaringResiduals-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-2-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[Croston-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ForecastingPipeline-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ThetaModularForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[Croston-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ThetaModularForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-2-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[MultiplexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateRefitsEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ColumnEnsembleForecaster-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[HierarchyEnsembleForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ColumnEnsembleForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[SquaringResiduals-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[MultiplexForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ConformalIntervals-1-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ForecastingPipeline-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[TransformedTargetForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[PluginParamsForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateRefitsEvery-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ForecastX-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateEvery-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[FhPlexForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[TransformedTargetForecaster-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[CurveFitForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[RecursiveTimeSeriesRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-2-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[HierarchyEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ThetaModularForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ThetaModularForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[SquaringResiduals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-0-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[UpdateEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-2-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[CurveFitForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastX-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-1-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ThetaModularForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateRefitsEvery-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ThetaModularForecaster-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[HierarchyEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[Croston-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[ForecastX-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastX-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[MultiplexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[FhPlexForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ThetaModularForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastX-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[HierarchyEnsembleForecaster-2-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[HierarchyEnsembleForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTimeSeriesRegressionForecaster-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[PluginParamsForecaster-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ColumnEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[SquaringResiduals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[RecursiveTimeSeriesRegressionForecaster-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[CurveFitForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ForecastingPipeline-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[ForecastingPipeline-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[RecursiveTabularRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ConformalIntervals-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[CurveFitForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-0-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[CurveFitForecaster-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-2-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[FhPlexForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[FhPlexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastingPipeline-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[MultiplexForecaster-0-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[CurveFitForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-1-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[TransformedTargetForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTabularRegressionForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[CurveFitForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-1-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTabularRegressionForecaster-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[CurveFitForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[HierarchyEnsembleForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[UpdateEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[PluginParamsForecaster-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ThetaModularForecaster-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[MultiplexForecaster-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ConformalIntervals-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[HierarchyEnsembleForecaster-2-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[ForecastingPipeline-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-2-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[UpdateEvery-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[FhPlexForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[CurveFitForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastX-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastX-1-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-2-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ForecastingPipeline-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[MultiplexForecaster-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-0-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ColumnEnsembleForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[PluginParamsForecaster-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[CurveFitForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[PluginParamsForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[RecursiveTabularRegressionForecaster-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateRefitsEvery-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[HierarchyEnsembleForecaster-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[RecursiveTimeSeriesRegressionForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateRefitsEvery-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[CurveFitForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[FhPlexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[SquaringResiduals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-1-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ForecastingPipeline-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ThetaModularForecaster-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[TransformedTargetForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-1-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[MultiplexForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-2-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ThetaModularForecaster-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[PluginParamsForecaster-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[CurveFitForecaster-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-2-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastX-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[Croston-2-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[PluginParamsForecaster-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateRefitsEvery-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[PluginParamsForecaster-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ForecastX-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[Croston-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTabularRegressionForecaster-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-1-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[UpdateRefitsEvery-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[RecursiveTimeSeriesRegressionForecaster]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ColumnEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-1-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[MultiplexForecaster-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-1-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[TransformedTargetForecaster-1-y0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastX-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-2-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[RecursiveTimeSeriesRegressionForecaster-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[PluginParamsForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastX-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTabularRegressionForecaster-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ColumnEnsembleForecaster-0-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[FhPlexForecaster-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[TransformedTargetForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_raises_not_fitted_error[UpdateRefitsEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[HierarchyEnsembleForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-1-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-2-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ColumnEnsembleForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[TransformedTargetForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[HierarchyEnsembleForecaster-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[MultiplexForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[UpdateEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[UpdateEvery-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[FhPlexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-2-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[ForecastingPipeline-2-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[FhPlexForecaster-0-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-1-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[FhPlexForecaster-2-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[CurveFitForecaster-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ColumnEnsembleForecaster-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[ForecastingPipeline-2]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:2cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[UpdateRefitsEvery-0-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-2-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ForecastX-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-2-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-2-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-0-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastX-0-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastingPipeline-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_and_cutoff[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastX-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateRefitsEvery-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[SquaringResiduals-0-y:1cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-0-y:1cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:1cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateRefitsEvery-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-1-y:1cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[HierarchyEnsembleForecaster-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[RecursiveTimeSeriesRegressionForecaster-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[UpdateEvery-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[RecursiveTimeSeriesRegressionForecaster-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[TransformedTargetForecaster-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ForecastingPipeline-1-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[MultiplexForecaster-1-y:1cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[ForecastingPipeline-2-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[MultiplexForecaster-0-ForecasterFitPredictPanelSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_multivariate_raises_error[UpdateRefitsEvery-0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[FhPlexForecaster-0-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[RecursiveTimeSeriesRegressionForecaster-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ColumnEnsembleForecaster-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ForecastingPipeline-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[Croston-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:2cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ThetaModularForecaster-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[CurveFitForecaster-0-y:1cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[UpdateRefitsEvery-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[MultiplexForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[Croston-2-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[SquaringResiduals-1-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:1cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-0-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[HierarchyEnsembleForecaster-2-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[MultiplexForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[TransformedTargetForecaster-1-y:2cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[TransformedTargetForecaster-2-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-0-y:1cols-fh=-3-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=5-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[CurveFitForecaster-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[TransformedTargetForecaster-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[MultiplexForecaster-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-0-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[RecursiveTabularRegressionForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-0-y:1cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:1cols-fh=-3-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[CurveFitForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[UpdateEvery-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-2-y:2cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[RecursiveTabularRegressionForecaster-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[ConformalIntervals-1-y:2cols-X0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_not_passed_error_handling[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:2cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-1-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[HierarchyEnsembleForecaster-2-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ConformalIntervals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_X_invalid_type_raises_error[CurveFitForecaster-0-y:2cols-X1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTabularRegressionForecaster-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-1-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ColumnEnsembleForecaster-1-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[PluginParamsForecaster-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:1cols-fh=0-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[TransformedTargetForecaster-0-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ColumnEnsembleForecaster-0-y:1cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastX-1-y:2cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-2-y:1cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[Croston-1-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[UpdateEvery-1-y:1cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateRefitsEvery-0-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[MultiplexForecaster-0-y:2cols-fh=-3-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[PluginParamsForecaster-y:2cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[RecursiveTimeSeriesRegressionForecaster-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[TransformedTargetForecaster-0-y:1cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[SquaringResiduals-0-ForecasterFitPredictUnivariateWithX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-1-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ForecastX-1-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:1cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-0-y:2cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_level_one_data[default0-forecasters1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateRefitsEvery-0-y:2cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[TransformedTargetForecaster-2-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ForecastingPipeline-1-y:1cols-fh=1-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_different_fh_in_fit_and_predict_error_handling[SquaringResiduals-0-y:1cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=1-alpha=0.05-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:1cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-0-y:2cols-fh=1-alpha=0.1-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-0-y:1cols-fh=1-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-0-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[FhPlexForecaster-1-y:1cols-update_params=True-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-1-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[Croston-2-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_series_name_preserved[SquaringResiduals-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-0-y:1cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[PluginParamsForecaster-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:2cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[HierarchyEnsembleForecaster-0-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-2-y:2cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[ConformalIntervals-0-y:1cols-fh=1-alpha=0.05-range]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastX-0-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ConformalIntervals-1-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-2-y:1cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-1-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[ConformalIntervals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[CurveFitForecaster-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=5-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[SquaringResiduals-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ConformalIntervals-1-y:2cols-update_params=False-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[UpdateEvery-0-y:1cols-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[Croston-0-y:1cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastingPipeline-2-y:1cols-update_params=False-step=5-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[CurveFitForecaster-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_hierarchical_with_exogeneous[ConformalIntervals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-datetime-timedelta-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:1cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[PluginParamsForecaster-y:1cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-0-y:2cols-fh=0-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-2-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_hierarchy_ensemble_exog[forecasters1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[FhPlexForecaster-1-ForecasterFitPredictHierarchicalSimple]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ThetaModularForecaster-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ThetaModularForecaster-y:2cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[ConformalIntervals-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:1cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateEvery-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-2-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[Croston-1-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=0-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-1-y:1cols-update_params=False-step=5-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-1-y:2cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[RecursiveTabularRegressionForecaster-y:1cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-1-y:1cols-fh=0-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[UpdateRefitsEvery-0-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_hierarchy_ensemble_node_predict[forecasters0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ConformalIntervals-0-y:2cols-fh=-3-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-0-y:2cols-update_params=False-step=1-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-0-y:2cols-fh=-3-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=1-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[TransformedTargetForecaster-2-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateEvery-1-y:2cols-fh=1-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-2-y:1cols-fh=1-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[ConformalIntervals-1-y:1cols-fh=1-alpha=0.1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[ForecastingPipeline-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-1-y:1cols-fh=-3-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:1cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[ForecastX-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[Croston-1-y:2cols-update_params=True-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ForecastingPipeline-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-1-y:2cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[UpdateRefitsEvery-0-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:1cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[SquaringResiduals-1-y:2cols-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ForecastX-1-y:2cols-update_params=True-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_fh_attribute[UpdateRefitsEvery-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateEvery-0-y:2cols-fh=0-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[HierarchyEnsembleForecaster-0-y:1cols-update_params=False-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[CurveFitForecaster-0-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ColumnEnsembleForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[SquaringResiduals-0-y:2cols-update_params=True-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-1-y:2cols-update_params=False-step=1-5-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[SquaringResiduals-0-y:2cols-update_params=False-fh=[2", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_hierarchy_ensemble_exog[forecasters0]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-period-period-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:1cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[SquaringResiduals-1-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[SquaringResiduals-0-y:1cols-period-int-True]", "sktime/forecasting/compose/tests/test_hierarchy_ensemble.py::test_hierarchy_ensemble_node_predict[forecasters1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_get_fitted_params[Croston-0-ForecasterFitPredictMultivariateNoX]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[FhPlexForecaster-0-y:1cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[SquaringResiduals-0-y:2cols-fh=1-alpha=[0.25,", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[Croston-2-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_score[TransformedTargetForecaster-0-y:2cols-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[Croston-1-y:2cols-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:2cols-fh=1-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[FhPlexForecaster-1-y:1cols-update_params=False-step=1-1-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[ConformalIntervals-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:1cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[UpdateRefitsEvery-1-y:2cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test__y_when_refitting[SquaringResiduals-0-y:2cols]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[MultiplexForecaster-0-y:2cols-update_params=False-step=1-1-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_quantiles[UpdateEvery-1-y:1cols-fh=1-alpha=0.05]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_predicted_index[ConformalIntervals-0-y:1cols-update_params=True-5-fh=1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ColumnEnsembleForecaster-0-y:1cols-fh=-3-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_interval[MultiplexForecaster-1-y:2cols-fh=1-alpha=0.1-None]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-2-y:1cols-fh=-3-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[ForecastingPipeline-1-y:2cols-fh=0-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[ThetaModularForecaster-y:1cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_with_X[MultiplexForecaster-0-y:2cols-fh=1-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-0-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_pred_int_tag[Croston-1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-datetime-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[HierarchyEnsembleForecaster-1-y:2cols-fh=1-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_y_invalid_type_raises_error[SquaringResiduals-1-y1]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-int-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[MultiplexForecaster-1-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[FhPlexForecaster-1-y:2cols-fh=1-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-int-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-1-y:2cols-range-int-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_update_predict_single[UpdateEvery-0-y:1cols-update_params=True-fh=[2", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-0-y:2cols-datetime-datetime-False]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index[TransformedTargetForecaster-0-y:1cols-fh=0-range-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_time_index_in_sample_full[FhPlexForecaster-2-y:2cols-period-int-True]", "sktime/forecasting/tests/test_all_forecasters.py::TestAllForecasters::test_predict_proba[ConformalIntervals-1-y:1cols-fh=1]" ]	{ "failed_lite_validators": [ "has_hyperlinks", "has_many_modified_files", "has_many_hunks" ], "has_test_patch": true, "is_lite": false }	2023-12-12 13:05:07+00:00	bsd-3-clause	5,533
slarse__labelbot-21	diff --git a/labelbot/auth.py b/labelbot/auth.py new file mode 100644 index 0000000..8ad32b3 --- /dev/null +++ b/labelbot/auth.py @@ -0,0 +1,52 @@ +"""Handles authentication tokens with the GitHub API. + +.. module:: auth + :synopsis: Functions for generating tokens used for authentication with GitHub. +.. moduleauthor:: Lars Hummelgren <[email protected]> & Joakim Croona <[email protected]> + +""" + +import datetime +import http.client +import json +import jwcrypto +import python_jwt +import requests + +USER_AGENT = "label-bot" + + +def generate_jwt_token(private_pem: str, app_id: int) -> str: + """Generates a JWT token valid for 10 minutes using the private key. + + Args: + private_pem: the private key that is used to generate a JWT + app_id the Application id + Returns: + The JWT that was generated using the private key and the app id + """ + private_key = jwcrypto.jwk.JWK.from_pem(private_pem.encode(encoding="utf8")) + payload = {"iss": app_id} + duration = datetime.timedelta(minutes=10) + return python_jwt.generate_jwt(payload, private_key, "RS256", duration) + + +def generate_installation_access_token(jwt_token: str, installation_id): + """Generates an installation access token using a JWT token and an installation id. + + An installation access token is valid for 1 hour. + + Args: + jwt_token: a valid JWT token + installation_id: the installation id of the app. + Returns: + An installation access token from the GitHub API + """ + headers = { + "Authorization": f"Bearer {jwt_token}", + "Accept": "application/vnd.github.machine-man-preview+json", + "User-Agent": USER_AGENT, + } + url = f"https://api.github.com/app/installations/{installation_id}/access_tokens" + r = requests.post(url, headers=headers) + return r.json()["token"]	slarse/labelbot	98a4801c2fd4da4370762c83a9e63b1f21292c20	diff --git a/tests/test_auth.py b/tests/test_auth.py new file mode 100644 index 0000000..528d56d --- /dev/null +++ b/tests/test_auth.py @@ -0,0 +1,35 @@ +from labelbot import auth + +rsa_key = """-----BEGIN RSA PRIVATE KEY----- +MIIEpQIBAAKCAQEAxgHlyqhl8bMNT8opV631hJy1aJ7guF7iDfBMa+V3kKzo5OUu +h5VGQ5xWQPZDf27brxgL0ywvfYzw+YaP6TaMcmUR8nzE+gr9B+GOc92GtVrZd4dd +o2CL/wLpANUwMZ2sCWWHg3sf5S5KRbg0WUPLk8dqnwINJKUnd1uZW4M76FMJxg92 +iQIMgdngEoos+bGE0X8mkClics0hMxZcUUsATV9YnrOztnx356/4yaZaRySp7gqd +bzuDHgi4kJi228eqWH12O6Q2tooOb1WZHUdOjlcYyjulipNiA9G0SnanN9YxmNGc ++0iLRQvlvuHPxA490d/WR+iMXAGHmUN40PYucwIDAQABAoIBAQC6ze2CPU84MOld +HmfUnXzk6IdJNaLirjlsVwlyPaGIr2hlEkbMiSsp/CNv1CWn4umFDhWR27zOIRry +/l1k8x6bifjdoZKgJ5/CQK0JaLR/Aj/qQZ441YweQRubuoVmOc+ladDoXU+hAwP1 +NKzGjmxQdjGD5AaMTPen5pYPPQdWzN5AvTH/Q3FIFsGAJ/JZIj3CjxJ5zyDdlYvJ +PKW/3E5DYSCVyjopjZhiNDHIa8Ur8e/b0S7EmxtRZc3IdV1nLAgRCkOkOZo9i0D8 +RN+Ro5Aiw/DUcYl4VzVxdikAASu9+Fey9NFDceeClKnIe/L5FXHjXR8VXuaw60AY +htI6g7LpAoGBAPSsiu1Fqtp+s07nHeeChTqPgpSSx7ihhEgZ/TqCElEl4xG4mkMg +vaSX9nS5Mm/cUF3mD40KwS+eaBxIVtk7uyQ80lBEc/lC/7txGKVCFWB+x7ChxPxI +HLA0pBg/O5g9HLtFXGDJn4WwbFU/j1luPuwNOFD/yqTNpQUiubuq9is9AoGBAM8s +V637me/rkyPDP0/up93Ox3szguIv03CaKqvL03ZJU/DZIMwtQgpvIKrBFhlQMG1Q +KkmgeCgpmLjgCIElXqLldur2TSag6Mtw2suomjELLNUpgnDs1hdq1xBcZCDyyGCj +F+AUjEun2+9TVLeGxvjtY1rB2a2Kc/k3XQXi8htvAoGBALYWdqnQUC+dXUpaO+og +O5ByXwa9Gb+xDGYwWUGirYkQviVhEgTlJ92HblY9wWh4OKM45NfdahpLNEXgHCo9 +BrAYR5iO6RRXJUTVDTdnr8sJbwlnytbJv/fupTSaUnqg+HHyU6aARqTSwDzNOZyf +rFo2GHRHeQMfPDFPP5SHzf4tAoGBAKsizRcKhMH8zqI3MkCcO4ztuDkcdxzTNw2I +PIGHsRnAPxfwtLgVFr25yLllIRUt+aMDGruRVFCQ8/icEEpmjUNw3AgCB/9F4qfT +hNnBYAXtXk6DqJ4R9lSHzDpWp9vT0hSKBTn0n2QLuJF9O7kTG6AbsPwSr/c8LMsM +ocowC6D/AoGAOEy3olvgdY9lWr6zHdK745qnFK2hHuAT4LEw+37/1WucNIXxItM8 +RdDCSLSlSxkpOjWFJPhdW19i/9O4QNNwAF5wCtlIFeN+HF24LwDF7I/Xj26pIKBj +8lEnfws5Dn7I9sG0wBn+5px52jgOqiKzjy3jcIENBRO6i1OZ8c07NmM= +-----END RSA PRIVATE KEY-----""" + + +def test_auth_jwt_token(): + """Tests that jwt_token is truthy""" + result = auth.generate_jwt_token(rsa_key, 12334) + assert result	Access token for privileged operations with the GitHub API As we want to set labels on issues (a privileged operation) via the API, we need to generate an access token. [The process is described here](https://developer.github.com/apps/building-github-apps/authenticating-with-github-apps/#generating-a-private-key). There's a Python package [python_jwt](https://pypi.org/project/python_jwt/) that can do the hard parts for us. I've got an example of how to do this in an old project (although I wasn't the one who implemented it, so I'm not privvy to the details). Once an access token has been generated, it's valid for 1 hour. If we want to optimize for performance, we could store the token for 1 hour in DynamoDB using the [TTL functionality](https://aws.amazon.com/about-aws/whats-new/2017/02/amazon-dynamodb-now-supports-automatic-item-expiration-with-time-to-live-ttl/). Won't be necessary for a prototype, but could be cool if we've got time left to do it.	98a4801c2fd4da4370762c83a9e63b1f21292c20	[ "tests/test_auth.py::test_auth_jwt_token" ]	[]	{ "failed_lite_validators": [ "has_hyperlinks", "has_added_files" ], "has_test_patch": true, "is_lite": false }	2019-04-11 12:02:27+00:00	mit	5,534

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.