kumoai 2.11.0.dev202510181831__cp311-cp311-macosx_11_0_arm64.whl → 2.12.0.dev202511111731__cp311-cp311-macosx_11_0_arm64.whl

{kumoai-2.11.0.dev202510181831.dist-info → kumoai-2.12.0.dev202511111731.dist-info}/RECORD

@@ -1,7 +1,7 @@
 kumoai/_logging.py,sha256=U2_5ROdyk92P4xO4H2WJV8EC7dr6YxmmnM-b7QX9M7I,886
 kumoai/mixin.py,sha256=MP413xzuCqWhxAPUHmloLA3j4ZyF1tEtfi516b_hOXQ,812
-kumoai/_version.py,sha256=HKmzLWQzbgO1FpYD6EzQK0ge2WmooFnp40R0dVjHuwA,39
-kumoai/__init__.py,sha256=x3DjDsWBgWSNwo7mDwb3XAoRm2NuSO09yvhQTL9tBT8,10673
+kumoai/_version.py,sha256=EmBJ4U0JvENPiq7lq8M80mpSdMDFEwNkBsjWDdzaLT4,39
+kumoai/__init__.py,sha256=LU1zmKYc0KV5hy2VGKUuXgSvbJwj2rSRQ_R_bpHyl1o,10708
 kumoai/formatting.py,sha256=jA_rLDCGKZI8WWCha-vtuLenVKTZvli99Tqpurz1H84,953
 kumoai/futures.py,sha256=oJFIfdCM_3nWIqQteBKYMY4fPhoYlYWE_JA2o6tx-ng,3737
 kumoai/kumolib.cpython-311-darwin.so,sha256=AmB_Fysmud1y7Gm5CuBQ5lWDuSzpxVDV_iTA2cjH1s8,232544
@@ -13,17 +13,15 @@ kumoai/_singleton.py,sha256=UTwrbDkoZSGB8ZelorvprPDDv9uZkUi1q_SrmsyngpQ,836
 kumoai/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kumoai/experimental/rfm/local_graph_sampler.py,sha256=o60_sdMa_fr60DrdmCIaE6lKQAD2msp1t-GGubFNt-o,6738
 kumoai/experimental/rfm/local_graph.py,sha256=2iJDlsGVzqCe1bD_puXWlhwGkn7YnQyJ4p4C-fwCZNE,30076
-kumoai/experimental/rfm/local_pquery_driver.py,sha256=xqAQ9fJfkqM1axknFpg0NLQbIYmExh-s7vGdUyDEkwA,18600
-kumoai/experimental/rfm/__init__.py,sha256=F1aUOCLDN2yrIRDAiOlogDfXKUkUQgp8Mt0pVX9rLX8,1641
+kumoai/experimental/rfm/local_pquery_driver.py,sha256=aO7Jfwx9gxGKYvpqxZx1LLWdI1MhuZQOPtAITxoOQO0,26162
+kumoai/experimental/rfm/__init__.py,sha256=ornmi2x947jkQLptMn7ZLvTf2Sw-RMcVW73AnjVsWAo,1709
 kumoai/experimental/rfm/utils.py,sha256=3IiBvT_aLBkkcJh3H11_50yt_XlEzHR0cm9Kprrtl8k,11123
 kumoai/experimental/rfm/local_table.py,sha256=r8xZ33Mjs6JD8ud6h23tZ99Dag2DvZ4h6tWjmGrKQg4,19605
-kumoai/experimental/rfm/rfm.py,sha256=K5c8pmWe3lCO1J4EMZBZPgJQPcdsvBAyvmvrLsa1tVU,45519
+kumoai/experimental/rfm/rfm.py,sha256=V2NxxhrYi_MqLi_xcZsOYsdciT7V44iS5Fc9Ewq9eiM,48101
 kumoai/experimental/rfm/local_graph_store.py,sha256=8BqonuaMftAAsjgZpB369i5AeNd1PkisMbbEqc0cKBo,13847
 kumoai/experimental/rfm/authenticate.py,sha256=FiuHMvP7V3zBZUlHMDMbNLhc-UgDZgz4hjVSTuQ7DRw,18888
-kumoai/experimental/rfm/pquery/backend.py,sha256=6wtB0yFpxQUraBSA2TbKMVSIMD0dcLwYV5P4SQx2g_k,3287
-kumoai/experimental/rfm/pquery/__init__.py,sha256=9uLXixjp78y0IzO2F__lFqKNm37OGhN3iDh56akWLNU,283
-kumoai/experimental/rfm/pquery/pandas_backend.py,sha256=pgHCErSo6U-KJMhgIYijYt96uubtFB2WtsrTdLU7NYc,15396
-kumoai/experimental/rfm/pquery/pandas_executor.py,sha256=BgF3saosisgLHx1RyLj-HSEbMp4xLatNuARdKWwiiLY,17326
+kumoai/experimental/rfm/pquery/__init__.py,sha256=X0O3EIq5SMfBEE-ii5Cq6iDhR3s3XMXB52Cx5htoePw,152
+kumoai/experimental/rfm/pquery/pandas_executor.py,sha256=kiBJq7uVGbasG7TiqsubEl6ey3UYzZiM4bwxILqp_54,18487
 kumoai/experimental/rfm/pquery/executor.py,sha256=f7-pJhL0BgFU9E4o4gQpQyArOvyrZtwxFmks34-QOAE,2741
 kumoai/experimental/rfm/infer/multicategorical.py,sha256=0-cLpDnGryhr76QhZNO-klKokJ6MUSfxXcGdQ61oykY,1102
 kumoai/experimental/rfm/infer/categorical.py,sha256=VwNaKwKbRYkTxEJ1R6gziffC8dGsEThcDEfbi-KqW5c,853
@@ -40,7 +38,7 @@ kumoai/artifact_export/job.py,sha256=GEisSwvcjK_35RgOfsLXGgxMTXIWm765B_BW_Kgs-V0
 kumoai/artifact_export/__init__.py,sha256=BsfDrc3mCHpO9-BqvqKm8qrXDIwfdaoH5UIoG4eQkc4,238
 kumoai/utils/datasets.py,sha256=ptKIUoBONVD55pTVNdRCkQT3NWdN_r9UAUu4xewPa3U,2928
 kumoai/utils/__init__.py,sha256=wGDC_31XJ-7ipm6eawjLAJaP4EfmtNOH8BHzaetQ9Ko,268
-kumoai/utils/progress_logger.py,sha256=jHAS_iDD008VSa_P_XzJsRS6TVIXviK017KE5ict-4M,4875
+kumoai/utils/progress_logger.py,sha256=pngEGzMHkiOUKOa6fbzxCEc2xlA4SJKV4TDTVVoqObM,5062
 kumoai/utils/forecasting.py,sha256=-nDS6ucKNfQhTQOfebjefj0wwWH3-KYNslIomxwwMBM,7415
 kumoai/codegen/generate.py,sha256=SvfWWa71xSAOjH9645yQvgoEM-o4BYjupM_EpUxqB_E,7331
 kumoai/codegen/naming.py,sha256=_XVQGxHfuub4bhvyuBKjltD5Lm_oPpibvP_LZteCGk0,3021
@@ -84,17 +82,17 @@ kumoai/client/jobs.py,sha256=iu_Wrta6BQMlV6ZtzSnmhjwNPKDMQDXOsqVVIyWodqw,17074
 kumoai/client/utils.py,sha256=lz1NubwMDHCwzQRowRXm7mjAoYRd5UjRQIwXdtWAl90,3849
 kumoai/client/connector.py,sha256=x3i2aBTJTEMZvYRcWkY-UfWVOANZjqAso4GBbcshFjw,3920
 kumoai/client/table.py,sha256=cQG-RPm-e91idEgse1IPJDvBmzddIDGDkuyrR1rq4wU,3235
-kumoai/client/rfm.py,sha256=15Wt_45mf7WJyCKylxF6_biHis9R_qmplPk9cwR9JeU,2918
-kumoai/client/endpoints.py,sha256=0VPeWgy2AEA1BD4zFB6DQaP4N2Ln2lPEnBIs_9fM1y4,5315
+kumoai/client/rfm.py,sha256=NxKk8mH2A-B58rSXhDWaph4KeiSyJYDq-RO-vAHh7es,3726
+kumoai/client/endpoints.py,sha256=iF2ZD25AJCIVbmBJ8tTZ8y1Ch0m6nTp18ydN7h4WiTk,5382
 kumoai/trainer/config.py,sha256=-2RfK10AsVVThSyfWtlyfH4Fc4EwTdu0V3yrDRtIOjk,98
 kumoai/trainer/util.py,sha256=bDPGkMF9KOy4HgtA-OwhXP17z9cbrfMnZGtyGuUq_Eo,4062
 kumoai/trainer/job.py,sha256=Wk69nzFhbvuA3nEvtCstI04z5CxkgvQ6tHnGchE0Lkg,44938
 kumoai/trainer/baseline_trainer.py,sha256=LlfViNOmswNv4c6zJJLsyv0pC2mM2WKMGYx06ogtEVc,4024
 kumoai/trainer/__init__.py,sha256=zUdFl-f-sBWmm2x8R-rdVzPBeU2FaMzUY5mkcgoTa1k,939
 kumoai/trainer/online_serving.py,sha256=9cddb5paeZaCgbUeceQdAOxysCtV5XP-KcsgFz_XR5w,9566
-kumoai/trainer/trainer.py,sha256=nPeZMMp17TtRFd4lKbF-TlMPnhYR4_VyPDPI0T9W9PU,20094
-kumoai-2.11.0.dev202510181831.dist-info/RECORD,,
-kumoai-2.11.0.dev202510181831.dist-info/WHEEL,sha256=sunMa2yiYbrNLGeMVDqEA0ayyJbHlex7SCn1TZrEq60,136
-kumoai-2.11.0.dev202510181831.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
-kumoai-2.11.0.dev202510181831.dist-info/METADATA,sha256=gSsdQnJBns8JH7zVpN55mX2iGPxpecpLkWCnyenAXC8,2052
-kumoai-2.11.0.dev202510181831.dist-info/licenses/LICENSE,sha256=TbWlyqRmhq9PEzCaTI0H0nWLQCCOywQM8wYH8MbjfLo,1102
+kumoai/trainer/trainer.py,sha256=hBXO7gwpo3t59zKFTeIkK65B8QRmWCwO33sbDuEAPlY,20133
+kumoai-2.12.0.dev202511111731.dist-info/RECORD,,
+kumoai-2.12.0.dev202511111731.dist-info/WHEEL,sha256=sunMa2yiYbrNLGeMVDqEA0ayyJbHlex7SCn1TZrEq60,136
+kumoai-2.12.0.dev202511111731.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
+kumoai-2.12.0.dev202511111731.dist-info/METADATA,sha256=sNoIEIZxJx58O-0mQyfBmpsnrkAzg3ZVQhucsvlDX64,2052
+kumoai-2.12.0.dev202511111731.dist-info/licenses/LICENSE,sha256=TbWlyqRmhq9PEzCaTI0H0nWLQCCOywQM8wYH8MbjfLo,1102

kumoai/experimental/rfm/pquery/backend.py

@@ -1,136 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, Generic, Optional, Tuple, TypeVar, Union
-
-from kumoapi.rfm import PQueryDefinition
-from kumoapi.rfm.pquery import (
-    Aggregation,
-    AggregationType,
-    BoolOp,
-    Column,
-    Condition,
-    Filter,
-    Float,
-    FloatList,
-    Int,
-    IntList,
-    LogicalOperation,
-    MemberOp,
-    RelOp,
-    Str,
-    StrList,
-)
-
-TableData = TypeVar('TableData')
-ColumnData = TypeVar('ColumnData')
-IndexData = TypeVar('IndexData')
-
-
-class PQueryBackend(Generic[TableData, ColumnData, IndexData], ABC):
-    @abstractmethod
-    def eval_aggregation_type(
-        self,
-        op: AggregationType,
-        feat: Optional[ColumnData],
-        batch: IndexData,
-        batch_size: int,
-        filter_na: bool = True,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass
-
-    @abstractmethod
-    def eval_rel_op(
-        self,
-        left: ColumnData,
-        op: RelOp,
-        right: Union[Int, Float, Str, None],
-    ) -> ColumnData:
-        pass
-
-    @abstractmethod
-    def eval_member_op(
-        self,
-        left: ColumnData,
-        op: MemberOp,
-        right: Union[IntList, FloatList, StrList],
-    ) -> ColumnData:
-        pass
-
-    @abstractmethod
-    def eval_bool_op(
-        self,
-        left: ColumnData,
-        op: BoolOp,
-        right: Optional[ColumnData],
-    ) -> ColumnData:
-        pass
-
-    @abstractmethod
-    def eval_column(
-        self,
-        column: Column,
-        feat_dict: Dict[str, TableData],
-        filter_na: bool = True,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass
-
-    @abstractmethod
-    def eval_aggregation(
-        self,
-        aggr: Aggregation,
-        feat_dict: Dict[str, TableData],
-        time_dict: Dict[str, ColumnData],
-        batch_dict: Dict[str, IndexData],
-        anchor_time: ColumnData,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass
-
-    @abstractmethod
-    def eval_condition(
-        self,
-        condition: Condition,
-        feat_dict: Dict[str, TableData],
-        time_dict: Dict[str, ColumnData],
-        batch_dict: Dict[str, IndexData],
-        anchor_time: ColumnData,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass
-
-    @abstractmethod
-    def eval_logical_operation(
-        self,
-        logical_operation: LogicalOperation,
-        feat_dict: Dict[str, TableData],
-        time_dict: Dict[str, ColumnData],
-        batch_dict: Dict[str, IndexData],
-        anchor_time: ColumnData,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass
-
-    @abstractmethod
-    def eval_filter(
-        self,
-        filter: Filter,
-        feat_dict: Dict[str, TableData],
-        time_dict: Dict[str, ColumnData],
-        batch_dict: Dict[str, IndexData],
-        anchor_time: ColumnData,
-    ) -> IndexData:
-        pass
-
-    @abstractmethod
-    def eval_pquery(
-        self,
-        query: PQueryDefinition,
-        feat_dict: Dict[str, TableData],
-        time_dict: Dict[str, ColumnData],
-        batch_dict: Dict[str, IndexData],
-        anchor_time: ColumnData,
-        num_forecasts: int = 1,
-    ) -> Tuple[ColumnData, IndexData]:
-        pass

kumoai/experimental/rfm/pquery/pandas_backend.py

@@ -1,478 +0,0 @@
-from typing import Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import pandas as pd
-from kumoapi.rfm import PQueryDefinition
-from kumoapi.rfm.pquery import (
-    Aggregation,
-    AggregationType,
-    BoolOp,
-    Column,
-    Condition,
-    Filter,
-    Float,
-    FloatList,
-    Int,
-    IntList,
-    LogicalOperation,
-    MemberOp,
-    RelOp,
-    Str,
-    StrList,
-)
-
-from kumoai.experimental.rfm.pquery import PQueryBackend
-
-
-class PQueryPandasBackend(PQueryBackend[pd.DataFrame, pd.Series, np.ndarray]):
-    def eval_aggregation_type(
-        self,
-        op: AggregationType,
-        feat: Optional[pd.Series],
-        batch: np.ndarray,
-        batch_size: int,
-        filter_na: bool = True,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        if op != AggregationType.COUNT:
-            assert feat is not None
-
-        if feat is not None:
-            mask = feat.notna()
-            feat, batch = feat[mask], batch[mask]
-
-        if op == AggregationType.LIST_DISTINCT:
-            df = pd.DataFrame(dict(feat=feat, batch=batch))
-            df = df.drop_duplicates()
-            out = df.groupby('batch')['feat'].agg(list)
-
-        else:
-            df = pd.DataFrame(dict(feat=feat, batch=batch))
-            if op == AggregationType.AVG:
-                agg = 'mean'
-            elif op == AggregationType.COUNT:
-                agg = 'size'
-            else:
-                agg = op.lower()
-            out = df.groupby('batch')['feat'].agg(agg)
-
-            if not pd.api.types.is_datetime64_any_dtype(out):
-                out = out.astype('float32')
-
-        out.name = None
-        out.index.name = None
-
-        if op in {AggregationType.SUM, AggregationType.COUNT}:
-            out = out.reindex(range(batch_size), fill_value=0)
-            mask = np.ones(batch_size, dtype=bool)
-            return out, mask
-
-        mask = np.zeros(batch_size, dtype=bool)
-        mask[batch] = True
-
-        if filter_na:
-            return out.reset_index(drop=True), mask
-
-        out = out.reindex(range(batch_size), fill_value=pd.NA)
-
-        return out, mask
-
-    def eval_rel_op(
-        self,
-        left: pd.Series,
-        op: RelOp,
-        right: Union[Int, Float, Str, None],
-    ) -> pd.Series:
-
-        if right is None:
-            if op == RelOp.EQ:
-                return left.isna()
-            assert op == RelOp.NEQ
-            return left.notna()
-
-        value = pd.Series([right.value], dtype=left.dtype).iloc[0]
-
-        if op == RelOp.EQ:
-            return (left == value).fillna(False).astype(bool)
-        if op == RelOp.NEQ:
-            out = (left != value).fillna(False).astype(bool)
-            out[left.isna()] = False  # N/A != right should always be `False`.
-            return out
-        if op == RelOp.LEQ:
-            return (left <= value).fillna(False).astype(bool)
-        if op == RelOp.GEQ:
-            return (left >= value).fillna(False).astype(bool)
-        if op == RelOp.LT:
-            return (left < value).fillna(False).astype(bool)
-        if op == RelOp.GT:
-            return (left > value).fillna(False).astype(bool)
-
-        raise NotImplementedError(f"Operator '{op}' not implemented")
-
-    def eval_member_op(
-        self,
-        left: pd.Series,
-        op: MemberOp,
-        right: Union[IntList, FloatList, StrList],
-    ) -> pd.Series:
-
-        if op == MemberOp.IN:
-            ser = pd.Series(right.value, dtype=left.dtype)
-            return left.isin(ser).astype(bool)
-
-        raise NotImplementedError(f"Operator '{op}' not implemented")
-
-    def eval_bool_op(
-        self,
-        left: pd.Series,
-        op: BoolOp,
-        right: Optional[pd.Series],
-    ) -> pd.Series:
-
-        # TODO Implement Kleene-Priest three-value logic.
-        if op == BoolOp.AND:
-            assert right is not None
-            return left & right
-        if op == BoolOp.OR:
-            assert right is not None
-            return left | right
-        if op == BoolOp.NOT:
-            return ~left
-
-        raise NotImplementedError(f"Operator '{op}' not implemented")
-
-    def eval_column(
-        self,
-        column: Column,
-        feat_dict: Dict[str, pd.DataFrame],
-        filter_na: bool = True,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        out = feat_dict[column.table_name][column.column_name]
-        out = out.reset_index(drop=True)
-
-        if pd.api.types.is_float_dtype(out):
-            out = out.astype('float32')
-
-        out.name = None
-        out.index.name = None
-
-        mask = out.notna().to_numpy()
-
-        if not filter_na:
-            return out, mask
-
-        out = out[mask].reset_index(drop=True)
-
-        # Cast to primitive dtype:
-        if pd.api.types.is_integer_dtype(out):
-            out = out.astype('int64')
-        elif pd.api.types.is_bool_dtype(out):
-            out = out.astype('bool')
-
-        return out, mask
-
-    def eval_aggregation(
-        self,
-        aggr: Aggregation,
-        feat_dict: Dict[str, pd.DataFrame],
-        time_dict: Dict[str, pd.Series],
-        batch_dict: Dict[str, np.ndarray],
-        anchor_time: pd.Series,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        target_table = aggr.column.table_name
-        target_batch = batch_dict[target_table]
-        target_time = time_dict[target_table]
-
-        outs: List[pd.Series] = []
-        masks: List[np.ndarray] = []
-        for _ in range(num_forecasts):
-            anchor_target_time = anchor_time[target_batch]
-            anchor_target_time = anchor_target_time.reset_index(drop=True)
-
-            target_mask = target_time <= anchor_target_time + aggr.end_offset
-
-            if aggr.start is not None:
-                start_offset = aggr.start * aggr.time_unit.to_offset()
-                target_mask &= target_time > anchor_target_time + start_offset
-            else:
-                assert num_forecasts == 1
-
-            if aggr.filter is not None:
-                target_mask &= self.eval_filter(
-                    filter=aggr.filter,
-                    feat_dict=feat_dict,
-                    time_dict=time_dict,
-                    batch_dict=batch_dict,
-                    anchor_time=anchor_time,
-                )
-
-            if (aggr.type == AggregationType.COUNT
-                    and aggr.column.column_name == '*'):
-                target_feat = None
-            else:
-                target_feat, _ = self.eval_column(
-                    aggr.column,
-                    feat_dict,
-                    filter_na=False,
-                )
-                target_feat = target_feat[target_mask]
-
-            out, mask = self.eval_aggregation_type(
-                aggr.type,
-                feat=target_feat,
-                batch=target_batch[target_mask],
-                batch_size=len(anchor_time),
-                filter_na=False if num_forecasts > 1 else filter_na,
-            )
-            outs.append(out)
-            masks.append(mask)
-
-            if num_forecasts > 1:
-                anchor_time = anchor_time + aggr.end_offset
-
-        if len(outs) == 1:
-            assert len(masks) == 1
-            return outs[0], masks[0]
-
-        out = pd.Series([list(ser) for ser in zip(*outs)])
-        mask = np.stack(masks, axis=-1).any(axis=-1)  # type: ignore
-
-        if filter_na:
-            out = out[mask].reset_index(drop=True)
-
-        return out, mask
-
-    def eval_condition(
-        self,
-        condition: Condition,
-        feat_dict: Dict[str, pd.DataFrame],
-        time_dict: Dict[str, pd.Series],
-        batch_dict: Dict[str, np.ndarray],
-        anchor_time: pd.Series,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        if num_forecasts > 1:
-            raise NotImplementedError("Forecasting not yet implemented for "
-                                      "non-regression tasks")
-
-        if isinstance(condition.left, Column):
-            left, mask = self.eval_column(
-                column=condition.left,
-                feat_dict=feat_dict,
-                filter_na=filter_na if condition.right is not None else False,
-            )
-        else:
-            assert isinstance(condition.left, Aggregation)
-            left, mask = self.eval_aggregation(
-                aggr=condition.left,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=filter_na if condition.right is not None else False,
-            )
-
-        if filter_na and condition.right is None:
-            mask = np.ones(len(left), dtype=bool)
-
-        if isinstance(condition.op, RelOp):
-            out = self.eval_rel_op(
-                left=left,
-                op=condition.op,
-                right=condition.right,
-            )
-        else:
-            assert isinstance(condition.op, MemberOp)
-            out = self.eval_member_op(
-                left=left,
-                op=condition.op,
-                right=condition.right,
-            )
-
-        return out, mask
-
-    def eval_logical_operation(
-        self,
-        logical_operation: LogicalOperation,
-        feat_dict: Dict[str, pd.DataFrame],
-        time_dict: Dict[str, pd.Series],
-        batch_dict: Dict[str, np.ndarray],
-        anchor_time: pd.Series,
-        filter_na: bool = True,
-        num_forecasts: int = 1,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        if num_forecasts > 1:
-            raise NotImplementedError("Forecasting not yet implemented for "
-                                      "non-regression tasks")
-
-        if isinstance(logical_operation.left, Condition):
-            left, mask = self.eval_condition(
-                condition=logical_operation.left,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )
-        else:
-            assert isinstance(logical_operation.left, LogicalOperation)
-            left, mask = self.eval_logical_operation(
-                logical_operation=logical_operation.left,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )
-
-        right = right_mask = None
-        if isinstance(logical_operation.right, Condition):
-            right, right_mask = self.eval_condition(
-                condition=logical_operation.right,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )
-        elif isinstance(logical_operation.right, LogicalOperation):
-            right, right_mask = self.eval_logical_operation(
-                logical_operation=logical_operation.right,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )
-
-        out = self.eval_bool_op(left, logical_operation.op, right)
-
-        if right_mask is not None:
-            mask &= right_mask
-
-        if filter_na:
-            out = out[mask].reset_index(drop=True)
-
-        return out, mask
-
-    def eval_filter(
-        self,
-        filter: Filter,
-        feat_dict: Dict[str, pd.DataFrame],
-        time_dict: Dict[str, pd.Series],
-        batch_dict: Dict[str, np.ndarray],
-        anchor_time: pd.Series,
-    ) -> np.ndarray:
-        if isinstance(filter.condition, Condition):
-            return self.eval_condition(
-                condition=filter.condition,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )[0].to_numpy()
-        else:
-            assert isinstance(filter.condition, LogicalOperation)
-            return self.eval_logical_operation(
-                logical_operation=filter.condition,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=False,
-            )[0].to_numpy()
-
-    def eval_pquery(
-        self,
-        query: PQueryDefinition,
-        feat_dict: Dict[str, pd.DataFrame],
-        time_dict: Dict[str, pd.Series],
-        batch_dict: Dict[str, np.ndarray],
-        anchor_time: pd.Series,
-        num_forecasts: int = 1,
-    ) -> Tuple[pd.Series, np.ndarray]:
-
-        mask = np.ones(len(anchor_time), dtype=bool)
-
-        if query.entity.filter is not None:
-            mask &= self.eval_filter(
-                filter=query.entity.filter,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-            )
-
-        if getattr(query, 'assuming', None) is not None:
-            if isinstance(query.assuming, Condition):
-                mask &= self.eval_condition(
-                    condition=query.assuming,
-                    feat_dict=feat_dict,
-                    time_dict=time_dict,
-                    batch_dict=batch_dict,
-                    anchor_time=anchor_time,
-                    filter_na=False,
-                )[0].to_numpy()
-            else:
-                assert isinstance(query.assuming, LogicalOperation)
-                mask &= self.eval_logical_operation(
-                    logical_operation=query.assuming,
-                    feat_dict=feat_dict,
-                    time_dict=time_dict,
-                    batch_dict=batch_dict,
-                    anchor_time=anchor_time,
-                    filter_na=False,
-                )[0].to_numpy()
-
-        if isinstance(query.target, Column):
-            out, _mask = self.eval_column(
-                column=query.target,
-                feat_dict=feat_dict,
-                filter_na=True,
-            )
-        elif isinstance(query.target, Aggregation):
-            out, _mask = self.eval_aggregation(
-                aggr=query.target,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=True,
-                num_forecasts=num_forecasts,
-            )
-        elif isinstance(query.target, Condition):
-            out, _mask = self.eval_condition(
-                condition=query.target,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=True,
-                num_forecasts=num_forecasts,
-            )
-        else:
-            assert isinstance(query.target, LogicalOperation)
-            out, _mask = self.eval_logical_operation(
-                logical_operation=query.target,
-                feat_dict=feat_dict,
-                time_dict=time_dict,
-                batch_dict=batch_dict,
-                anchor_time=anchor_time,
-                filter_na=True,
-                num_forecasts=num_forecasts,
-            )
-
-        out = out[mask[_mask]]
-        mask &= _mask
-
-        out = out.reset_index(drop=True)
-
-        return out, mask