kumoai 2.11.0.dev202510191831__cp311-cp311-win_amd64.whl → 2.12.0.dev202511061731__cp311-cp311-win_amd64.whl

kumoai/experimental/rfm/rfm.py

@@ -5,19 +5,18 @@ from collections import defaultdict
 from collections.abc import Generator
 from contextlib import contextmanager
 from dataclasses import dataclass, replace
-from typing import Iterator, List, Literal, Optional, Union, overload
+from typing import Iterator, List, Literal, Optional, Tuple, Union, overload
 
 import numpy as np
 import pandas as pd
 from kumoapi.model_plan import RunMode
-from kumoapi.pquery import QueryType
+from kumoapi.pquery import QueryType, ValidatedPredictiveQuery
 from kumoapi.rfm import Context
 from kumoapi.rfm import Explanation as ExplanationConfig
 from kumoapi.rfm import (
-    PQueryDefinition,
     RFMEvaluateRequest,
+    RFMParseQueryRequest,
     RFMPredictRequest,
-    RFMValidateQueryRequest,
 )
 from kumoapi.task import TaskType
 
@@ -199,6 +198,7 @@ class KumoRFM:
         max_pq_iterations: int = 20,
         random_seed: Optional[int] = _RANDOM_SEED,
         verbose: Union[bool, ProgressLogger] = True,
+        use_prediction_time: bool = False,
     ) -> pd.DataFrame:
         pass
 
@@ -217,6 +217,7 @@ class KumoRFM:
         max_pq_iterations: int = 20,
         random_seed: Optional[int] = _RANDOM_SEED,
         verbose: Union[bool, ProgressLogger] = True,
+        use_prediction_time: bool = False,
     ) -> Explanation:
         pass
 
@@ -234,6 +235,7 @@ class KumoRFM:
         max_pq_iterations: int = 20,
         random_seed: Optional[int] = _RANDOM_SEED,
         verbose: Union[bool, ProgressLogger] = True,
+        use_prediction_time: bool = False,
     ) -> Union[pd.DataFrame, Explanation]:
         """Returns predictions for a predictive query.
 
@@ -264,6 +266,9 @@ class KumoRFM:
                 entities to find valid labels.
             random_seed: A manual seed for generating pseudo-random numbers.
             verbose: Whether to print verbose output.
+            use_prediction_time: Whether to use the anchor timestamp as an
+                additional feature during prediction. This is typically
+                beneficial for time series forecasting tasks.
 
         Returns:
             The predictions as a :class:`pandas.DataFrame`.
@@ -283,15 +288,12 @@ class KumoRFM:
                           f"suppress this warning.")
 
         if indices is None:
-            if query_def.entity.ids is None:
+            if query_def.rfm_entity_ids is None:
                 raise ValueError("Cannot find entities to predict for. Please "
                                  "pass them via `predict(query, indices=...)`")
-            indices = query_def.entity.ids.value
+            indices = query_def.get_rfm_entity_id_list()
         else:
-            query_def = replace(
-                query_def,
-                entity=replace(query_def.entity, ids=None),
-            )
+            query_def = replace(query_def, rfm_entity_ids=None)
 
         if len(indices) == 0:
             raise ValueError("At least one entity is required")
@@ -314,8 +316,8 @@ class KumoRFM:
 
             batch_size: Optional[int] = None
             if self._batch_size == 'max':
-                task_type = query_def.get_task_type(
-                    stypes=self._graph_store.stype_dict,
+                task_type = LocalPQueryDriver.get_task_type(
+                    query_def,
                     edge_types=self._graph_store.edge_types,
                 )
                 batch_size = _MAX_PRED_SIZE[task_type]
@@ -353,6 +355,7 @@ class KumoRFM:
                 request = RFMPredictRequest(
                     context=context,
                     run_mode=RunMode(run_mode),
+                    use_prediction_time=use_prediction_time,
                 )
                 with warnings.catch_warnings():
                     warnings.filterwarnings('ignore', message='gencode')
@@ -385,7 +388,7 @@ class KumoRFM:
 
                         # Cast 'ENTITY' to correct data type:
                         if 'ENTITY' in df:
-                            entity = query_def.entity.pkey.table_name
+                            entity = query_def.entity_table
                             pkey_map = self._graph_store.pkey_map_dict[entity]
                             df['ENTITY'] = df['ENTITY'].astype(
                                 type(pkey_map.index[0]))
@@ -461,11 +464,11 @@ class KumoRFM:
         query_def = self._parse_query(query)
 
         if indices is None:
-            if query_def.entity.ids is None:
+            if query_def.rfm_entity_ids is None:
                 raise ValueError("Cannot find entities to predict for. Please "
                                  "pass them via "
                                  "`is_valid_entity(query, indices=...)`")
-            indices = query_def.entity.ids.value
+            indices = query_def.get_rfm_entity_id_list()
 
         if len(indices) == 0:
             raise ValueError("At least one entity is required")
@@ -477,14 +480,13 @@ class KumoRFM:
             self._validate_time(query_def, anchor_time, None, False)
         else:
             assert anchor_time == 'entity'
-            if (query_def.entity.pkey.table_name
-                    not in self._graph_store.time_dict):
+            if (query_def.entity_table not in self._graph_store.time_dict):
                 raise ValueError(f"Anchor time 'entity' requires the entity "
-                                 f"table '{query_def.entity.pkey.table_name}' "
-                                 f"to have a time column")
+                                 f"table '{query_def.entity_table}' "
+                                 f"to have a time column.")
 
         node = self._graph_store.get_node_id(
-            table_name=query_def.entity.pkey.table_name,
+            table_name=query_def.entity_table,
             pkey=pd.Series(indices),
         )
         query_driver = LocalPQueryDriver(self._graph_store, query_def)
@@ -503,6 +505,7 @@ class KumoRFM:
         max_pq_iterations: int = 20,
         random_seed: Optional[int] = _RANDOM_SEED,
         verbose: Union[bool, ProgressLogger] = True,
+        use_prediction_time: bool = False,
     ) -> pd.DataFrame:
         """Evaluates a predictive query.
 
@@ -526,6 +529,9 @@ class KumoRFM:
                 entities to find valid labels.
             random_seed: A manual seed for generating pseudo-random numbers.
             verbose: Whether to print verbose output.
+            use_prediction_time: Whether to use the anchor timestamp as an
+                additional feature during prediction. This is typically
+                beneficial for time series forecasting tasks.
 
         Returns:
             The metrics as a :class:`pandas.DataFrame`
@@ -536,10 +542,10 @@ class KumoRFM:
             warnings.warn(f"Received custom 'num_neighbors' option; ignoring "
                           f"custom 'num_hops={num_hops}' option")
 
-        if query_def.entity.ids is not None:
+        if query_def.rfm_entity_ids is not None:
             query_def = replace(
                 query_def,
-                entity=replace(query_def.entity, ids=None),
+                rfm_entity_ids=None,
             )
 
         query_repr = query_def.to_string(rich=True, exclude_predict=True)
@@ -569,6 +575,7 @@ class KumoRFM:
                 context=context,
                 run_mode=RunMode(run_mode),
                 metrics=metrics,
+                use_prediction_time=use_prediction_time,
             )
             with warnings.catch_warnings():
                 warnings.filterwarnings('ignore', message='Protobuf gencode')
@@ -627,18 +634,19 @@ class KumoRFM:
 
         if anchor_time is None:
             anchor_time = self._graph_store.max_time
-            anchor_time = anchor_time - (query_def.target.end_offset *
-                                         query_def.num_forecasts)
+            if query_def.target_ast.date_offset_range is not None:
+                anchor_time = anchor_time - (
+                    query_def.target_ast.date_offset_range.end_date_offset *
+                    query_def.num_forecasts)
 
         assert anchor_time is not None
         if isinstance(anchor_time, pd.Timestamp):
             self._validate_time(query_def, anchor_time, None, evaluate=True)
         else:
             assert anchor_time == 'entity'
-            if (query_def.entity.pkey.table_name
-                    not in self._graph_store.time_dict):
+            if (query_def.entity_table not in self._graph_store.time_dict):
                 raise ValueError(f"Anchor time 'entity' requires the entity "
-                                 f"table '{query_def.entity.pkey.table_name}' "
+                                 f"table '{query_def.entity_table}' "
                                  f"to have a time column")
 
         query_driver = LocalPQueryDriver(self._graph_store, query_def,
@@ -653,7 +661,7 @@ class KumoRFM:
         )
 
         entity = self._graph_store.pkey_map_dict[
-            query_def.entity.pkey.table_name].index[node]
+            query_def.entity_table].index[node]
 
         return pd.DataFrame({
             'ENTITY': entity,
@@ -663,8 +671,8 @@ class KumoRFM:
 
     # Helpers #################################################################
 
-    def _parse_query(self, query: str) -> PQueryDefinition:
-        if isinstance(query, PQueryDefinition):
+    def _parse_query(self, query: str) -> ValidatedPredictiveQuery:
+        if isinstance(query, ValidatedPredictiveQuery):
             return query
 
         if isinstance(query, str) and query.strip()[:9].lower() == 'evaluate ':
@@ -674,12 +682,12 @@ class KumoRFM:
                              "predictions or evaluations.")
 
         try:
-            request = RFMValidateQueryRequest(
+            request = RFMParseQueryRequest(
                 query=query,
                 graph_definition=self._graph_def,
             )
 
-            resp = global_state.client.rfm_api.validate_query(request)
+            resp = global_state.client.rfm_api.parse_query(request)
             # TODO Expose validation warnings.
 
             if len(resp.validation_response.warnings) > 0:
@@ -690,7 +698,7 @@ class KumoRFM:
                 warnings.warn(f"Encountered the following warnings during "
                               f"parsing:\n{msg}")
 
-            return resp.query_definition
+            return resp.query
         except HTTPException as e:
             try:
                 msg = json.loads(e.detail)['detail']
@@ -701,7 +709,7 @@ class KumoRFM:
 
     def _validate_time(
         self,
-        query: PQueryDefinition,
+        query: ValidatedPredictiveQuery,
         anchor_time: pd.Timestamp,
         context_anchor_time: Union[pd.Timestamp, None],
         evaluate: bool,
@@ -724,6 +732,11 @@ class KumoRFM:
                              f"only contains data back to "
                              f"'{self._graph_store.min_time}'.")
 
+        if query.target_ast.date_offset_range is not None:
+            end_offset = query.target_ast.date_offset_range.end_date_offset
+        else:
+            end_offset = pd.DateOffset(0)
+        forecast_end_offset = end_offset * query.num_forecasts
         if (context_anchor_time is not None
                 and context_anchor_time > anchor_time):
             warnings.warn(f"Context anchor timestamp "
@@ -732,19 +745,18 @@ class KumoRFM:
                           f"(got '{anchor_time}'). Please make sure this is "
                           f"intended.")
         elif (query.query_type == QueryType.TEMPORAL
-              and context_anchor_time is not None and context_anchor_time +
-              query.target.end_offset * query.num_forecasts > anchor_time):
+              and context_anchor_time is not None
+              and context_anchor_time + forecast_end_offset > anchor_time):
             warnings.warn(f"Aggregation for context examples at timestamp "
                           f"'{context_anchor_time}' will leak information "
                           f"from the prediction anchor timestamp "
                           f"'{anchor_time}'. Please make sure this is "
                           f"intended.")
 
-        elif (context_anchor_time is not None and context_anchor_time -
-              query.target.end_offset * query.num_forecasts
+        elif (context_anchor_time is not None
+              and context_anchor_time - forecast_end_offset
               < self._graph_store.min_time):
-            _time = context_anchor_time - (query.target.end_offset *
-                                           query.num_forecasts)
+            _time = context_anchor_time - forecast_end_offset
             warnings.warn(f"Context anchor timestamp is too early or "
                           f"aggregation time range is too large. To form "
                           f"proper input data, we would need data back to "
@@ -757,8 +769,7 @@ class KumoRFM:
                           f"latest timestamp '{self._graph_store.max_time}' "
                           f"in the data. Please make sure this is intended.")
 
-        max_eval_time = (self._graph_store.max_time -
-                         query.target.end_offset * query.num_forecasts)
+        max_eval_time = self._graph_store.max_time - forecast_end_offset
         if evaluate and anchor_time > max_eval_time:
             raise ValueError(
                 f"Anchor timestamp for evaluation is after the latest "
@@ -766,7 +777,7 @@ class KumoRFM:
 
     def _get_context(
         self,
-        query: PQueryDefinition,
+        query: ValidatedPredictiveQuery,
         indices: Union[List[str], List[float], List[int], None],
         anchor_time: Union[pd.Timestamp, Literal['entity'], None],
         context_anchor_time: Union[pd.Timestamp, None],
@@ -794,8 +805,8 @@ class KumoRFM:
                              f"must go beyond this for your use-case.")
 
         query_driver = LocalPQueryDriver(self._graph_store, query, random_seed)
-        task_type = query.get_task_type(
-            stypes=self._graph_store.stype_dict,
+        task_type = LocalPQueryDriver.get_task_type(
+            query,
             edge_types=self._graph_store.edge_types,
         )
 
@@ -827,11 +838,15 @@ class KumoRFM:
             else:
                 num_neighbors = [64, 64, 8, 8, 4, 4][:num_hops]
 
+        if query.target_ast.date_offset_range is None:
+            end_offset = pd.DateOffset(0)
+        else:
+            end_offset = query.target_ast.date_offset_range.end_date_offset
+        forecast_end_offset = end_offset * query.num_forecasts
         if anchor_time is None:
             anchor_time = self._graph_store.max_time
             if evaluate:
-                anchor_time = anchor_time - (query.target.end_offset *
-                                             query.num_forecasts)
+                anchor_time = anchor_time - forecast_end_offset
             if logger is not None:
                 assert isinstance(anchor_time, pd.Timestamp)
                 if anchor_time == pd.Timestamp.min:
@@ -846,15 +861,14 @@ class KumoRFM:
         assert anchor_time is not None
         if isinstance(anchor_time, pd.Timestamp):
             if context_anchor_time is None:
-                context_anchor_time = anchor_time - (query.target.end_offset *
-                                                     query.num_forecasts)
+                context_anchor_time = anchor_time - forecast_end_offset
             self._validate_time(query, anchor_time, context_anchor_time,
                                 evaluate)
         else:
             assert anchor_time == 'entity'
-            if query.entity.pkey.table_name not in self._graph_store.time_dict:
+            if query.entity_table not in self._graph_store.time_dict:
                 raise ValueError(f"Anchor time 'entity' requires the entity "
-                                 f"table '{query.entity.pkey.table_name}' to "
+                                 f"table '{query.entity_table}' to "
                                  f"have a time column")
             if context_anchor_time is not None:
                 warnings.warn("Ignoring option 'context_anchor_time' for "
@@ -905,7 +919,7 @@ class KumoRFM:
                                  f"in batches")
 
             test_node = self._graph_store.get_node_id(
-                table_name=query.entity.pkey.table_name,
+                table_name=query.entity_table,
                 pkey=pd.Series(indices),
             )
 
@@ -913,8 +927,7 @@ class KumoRFM:
                 test_time = pd.Series(anchor_time).repeat(
                     len(test_node)).reset_index(drop=True)
             else:
-                time = self._graph_store.time_dict[
-                    query.entity.pkey.table_name]
+                time = self._graph_store.time_dict[query.entity_table]
                 time = time[test_node] * 1000**3
                 test_time = pd.Series(time, dtype='datetime64[ns]')
 
@@ -947,12 +960,23 @@ class KumoRFM:
                 raise NotImplementedError
             logger.log(msg)
 
-        entity_table_names = query.get_entity_table_names(
-            self._graph_store.edge_types)
+        entity_table_names: Tuple[str, ...]
+        if task_type.is_link_pred:
+            final_aggr = query.get_final_target_aggregation()
+            assert final_aggr is not None
+            edge_fkey = final_aggr._get_target_column_name()
+            for edge_type in self._graph_store.edge_types:
+                if edge_fkey == f'{edge_type[0]}.{edge_type[1]}':
+                    entity_table_names = (
+                        query.entity_table,
+                        edge_type[2],
+                    )
+        else:
+            entity_table_names = (query.entity_table, )
 
         # Exclude the entity anchor time from the feature set to prevent
         # running out-of-distribution between in-context and test examples:
-        exclude_cols_dict = query.exclude_cols_dict
+        exclude_cols_dict = query.get_exclude_cols_dict()
         if anchor_time == 'entity':
             if entity_table_names[0] not in exclude_cols_dict:
                 exclude_cols_dict[entity_table_names[0]] = []
@@ -981,7 +1005,7 @@ class KumoRFM:
 
         step_size: Optional[int] = None
         if query.query_type == QueryType.TEMPORAL:
-            step_size = date_offset_to_seconds(query.target.end_offset)
+            step_size = date_offset_to_seconds(end_offset)
 
         return Context(
             task_type=task_type,

kumoai/trainer/trainer.py

@@ -20,7 +20,6 @@ from kumoapi.jobs import (
     TrainingJobResource,
 )
 from kumoapi.model_plan import ModelPlan
-from kumoapi.task import TaskType
 
 from kumoai import global_state
 from kumoai.artifact_export.config import OutputConfig
@@ -405,15 +404,15 @@ class Trainer:
                 pred_table_data_path = prediction_table.table_data_uri
 
         api = global_state.client.batch_prediction_job_api
-
-        from kumoai.pquery.predictive_query import PredictiveQuery
-        pquery = PredictiveQuery.load_from_training_job(training_job_id)
-        if pquery.get_task_type() == TaskType.BINARY_CLASSIFICATION:
-            if binary_classification_threshold is None:
-                logger.warning("No binary classification threshold provided. "
-                               "Using default threshold of 0.5.")
-                binary_classification_threshold = 0.5
-
+        # Remove to resolve https://github.com/kumo-ai/kumo/issues/24250
+        # from kumoai.pquery.predictive_query import PredictiveQuery
+        # pquery = PredictiveQuery.load_from_training_job(training_job_id)
+        # if pquery.get_task_type() == TaskType.BINARY_CLASSIFICATION:
+        #     if binary_classification_threshold is None:
+        #         logger.warning(
+        # "No binary classification threshold provided. "
+        # "Using default threshold of 0.5.")
+        #         binary_classification_threshold = 0.5
         job_id, response = api.maybe_create(
             BatchPredictionRequest(
                 dict(custom_tags),

{kumoai-2.11.0.dev202510191831.dist-info → kumoai-2.12.0.dev202511061731.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kumoai
-Version: 2.11.0.dev202510191831
+Version: 2.12.0.dev202511061731
 Summary: AI on the Modern Data Stack
 Author-email: "Kumo.AI" <hello@kumo.ai>
 License-Expression: MIT
@@ -23,7 +23,7 @@ Requires-Dist: requests>=2.28.2
 Requires-Dist: urllib3
 Requires-Dist: plotly
 Requires-Dist: typing_extensions>=4.5.0
-Requires-Dist: kumo-api==0.38.0
+Requires-Dist: kumo-api==0.45.0
 Requires-Dist: tqdm>=4.66.0
 Requires-Dist: aiohttp>=3.10.0
 Requires-Dist: pydantic>=1.10.21

{kumoai-2.11.0.dev202510191831.dist-info → kumoai-2.12.0.dev202511061731.dist-info}/RECORD

@@ -1,13 +1,13 @@
-kumoai/__init__.py,sha256=7YoN_aogTFbuPKHjwvu8Pr8DqkZGCSUTqXj-yofcUFM,10965
+kumoai/__init__.py,sha256=4efagNAotP3c8mj8yyDGfVFcbgQ9l4wRC4FP-Yt0J3E,11002
 kumoai/_logging.py,sha256=qL4JbMQwKXri2f-SEJoFB8TY5ALG12S-nobGTNWxW-A,915
 kumoai/_singleton.py,sha256=i2BHWKpccNh5SJGDyU0IXsnYzJAYr8Xb0wz4c6LRbpo,861
-kumoai/_version.py,sha256=JSP05nqaobLN0J1ztXNtUg_1syTRFFjFDeMCPsIiUmo,39
+kumoai/_version.py,sha256=VXH5_higm9yOZfANxKmE3Z04HWIkHPFRAKVXx3JcG4s,39
 kumoai/databricks.py,sha256=ahwJz6DWLXMkndT0XwEDBxF-hoqhidFR8wBUQ4TLZ68,490
 kumoai/exceptions.py,sha256=7TMs0SC8xrU009_Pgd4QXtSF9lxJq8MtRbeX9pcQUy4,859
 kumoai/formatting.py,sha256=o3uCnLwXPhe1KI5WV9sBgRrcU7ed4rgu_pf89GL9Nc0,983
 kumoai/futures.py,sha256=J8rtZMEYFzdn5xF_x-LAiKJz3KGL6PT02f6rq_2bOJk,3836
 kumoai/jobs.py,sha256=dCi7BAdfm2tCnonYlGU4WJokJWbh3RzFfaOX2EYCIHU,2576
-kumoai/kumolib.cp311-win_amd64.pyd,sha256=aLNos9XcHakJa_BLt8Y1rXgvS6v7E8ZBDEis7leCdyw,195584
+kumoai/kumolib.cp311-win_amd64.pyd,sha256=gYxmlmFJnGDOi4hWT_K8mo__KVzRBukEivTzuip4TQY,195584
 kumoai/mixin.py,sha256=IaiB8SAI0VqOoMVzzIaUlqMt53-QPUK6OB0HikG-V9E,840
 kumoai/spcs.py,sha256=SWvfkeJvb_7sGkjSqyMBIuPbMTWCP6v0BC9HBXM1uSI,4398
 kumoai/artifact_export/__init__.py,sha256=UXAQI5q92ChBzWAk8o3J6pElzYHudAzFZssQXd4o7i8,247
@@ -16,12 +16,12 @@ kumoai/artifact_export/job.py,sha256=lOFIdPCrvhwdfvvDhQ2yzW8J4qIdYQoHZO1Rz3kJky4
 kumoai/client/__init__.py,sha256=v0ISO1QD8JJhIJS6IzWz5-SL3EhtNCPeX3j1b2HBY0s,69
 kumoai/client/client.py,sha256=IoZ6WH-VIAdwpwmd5DhP4HqjQL_YpB5vaWjtaWrNECk,8801
 kumoai/client/connector.py,sha256=CO2LG5aDpCLxWNYYFRXGZs1AhYH3dRcbqBEUGwHQGzQ,4030
-kumoai/client/endpoints.py,sha256=gyVxVkdlO7FMR_UHof3RWsoTY-87JTD7y1lLIw1kh8A,5464
+kumoai/client/endpoints.py,sha256=DpEKEQ1yvL15iHZadXZKO94t-qXrYLaeV1sknX4IuPg,5532
 kumoai/client/graph.py,sha256=6MFyPYxDPfGTWeAI_84RUgWx9rVvqbLnR0Ourtgj5rg,3951
 kumoai/client/jobs.py,sha256=Y8wKiTk1I5ywc-2cxR72LaBjfhPTCVOezSCTeDpTs8Q,17521
 kumoai/client/online.py,sha256=4s_8Sv8m_k_tty4CO7RuAt0e6BDMkGvsZZ3VX8zyDb8,2798
 kumoai/client/pquery.py,sha256=0pXgQLxjoaFWDif0XRAuC_P-X3OSnXNWsiVrXej9uMk,7094
-kumoai/client/rfm.py,sha256=z5XGwnFCGJgcrfycdGNQf1zC4hluk6kvJw3_SCfk0r0,3002
+kumoai/client/rfm.py,sha256=XCLJsSBe82fErLchpuS4Zb7fA3LBY8QxxIhrbw4_NPQ,3678
 kumoai/client/source_table.py,sha256=mMHJtQ_yUHRI9LdHLVHxNGt83bbzmC1_d-NmXjbiTuI,2154
 kumoai/client/table.py,sha256=VhjLEMLQS1Z7zjcb2Yt3gZfiVqiD7b1gj-WNux_504A,3336
 kumoai/client/utils.py,sha256=RSD5Ia0lQQDR1drRFBJFdo2KVHfQqhJuk6m6du7Kl4E,3979
@@ -58,20 +58,18 @@ kumoai/experimental/rfm/authenticate.py,sha256=G89_4TMeUpr5fG_0VTzMF5sdNhaciitA1
 kumoai/experimental/rfm/local_graph.py,sha256=nZ9hDfyWg1dHFLoTEKoLt0ZJPvf9MUA1MNyfTRzJThg,30886
 kumoai/experimental/rfm/local_graph_sampler.py,sha256=ZCnILozG95EzpgMqhGTG2AF85JphLvAhj-3YPaTqoaQ,6922
 kumoai/experimental/rfm/local_graph_store.py,sha256=eUuIMFcdIRqN1kRxnqOdJpKEt-S_oyupAyHr7YuQoSU,14206
-kumoai/experimental/rfm/local_pquery_driver.py,sha256=bIDXVm6NrXmzjxRUV8MPn_XmXVBVjqB8Szq3mAofe5k,19094
+kumoai/experimental/rfm/local_pquery_driver.py,sha256=XHxRTMRVUzKNlTItkOmW_ClEQ1xgvvwIC6MBLt7qihA,26857
 kumoai/experimental/rfm/local_table.py,sha256=5H08657TIyH7n_QnpFKr2g4BtVqdXTymmrfhSGaDmkU,20150
-kumoai/experimental/rfm/rfm.py,sha256=1m0LazxZ9iTil3Q8ZAYf4qfw8he6DqsaX3JfYbWOffY,46581
+kumoai/experimental/rfm/rfm.py,sha256=K9Fm6O3GWkoOCv9Bq8jSdnWvuMyPYk4lmU1WJIpLSPY,47815
 kumoai/experimental/rfm/utils.py,sha256=dLx2wdyTWg7vZI_7R-I0z_lA-2aV5M8h9n3bnnLyylI,11467
 kumoai/experimental/rfm/infer/__init__.py,sha256=fPsdDr4D3hgC8snW0j3pAVpCyR-xrauuogMnTOMrfok,304
 kumoai/experimental/rfm/infer/categorical.py,sha256=bqmfrE5ZCBTcb35lA4SyAkCu3MgttAn29VBJYMBNhVg,893
 kumoai/experimental/rfm/infer/id.py,sha256=xaJBETLZa8ttzZCsDwFSwfyCi3VYsLc_kDWT_t_6Ih4,954
 kumoai/experimental/rfm/infer/multicategorical.py,sha256=D-1KwYRkOSkBrOJr4Xa3eTCoAF9O9hPGa7Vg67V5_HU,1150
 kumoai/experimental/rfm/infer/timestamp.py,sha256=L2VxjtYTSyUBYAo4M-L08xSQlPpqnHMAVF5_vxjh3Y0,1135
-kumoai/experimental/rfm/pquery/__init__.py,sha256=lUY3aml-NjeiWJpxK5Aqbs1a4VTJyASfbMvs5kH6Qz0,294
-kumoai/experimental/rfm/pquery/backend.py,sha256=mGbRdDcZxRGhFGz55bDHCICkEzsYRO3Gyj95QkzxpKY,3423
+kumoai/experimental/rfm/pquery/__init__.py,sha256=RkTn0I74uXOUuOiBpa6S-_QEYctMutkUnBEfF9ztQzI,159
 kumoai/experimental/rfm/pquery/executor.py,sha256=S8wwXbAkH-YSnmEVYB8d6wyJF4JJ003mH_0zFTvOp_I,2843
-kumoai/experimental/rfm/pquery/pandas_backend.py,sha256=slG4WhuY0IOAtm_pKYuRDUQ-1wUcLESQsaUkFkQFq74,15874
-kumoai/experimental/rfm/pquery/pandas_executor.py,sha256=W0CEnjDdqxkBADSyvnupwS1k86N9DhFXejJEDKS1MBo,17832
+kumoai/experimental/rfm/pquery/pandas_executor.py,sha256=QQpOZ_ArH3eSAkenaY3J-gW1Wn5A7f85RiqZxaO5u1Q,19019
 kumoai/graph/__init__.py,sha256=QGk3OMwRzQJSGESdcc7hcQH6UDmNVJYTdqnRren4c7Q,240
 kumoai/graph/column.py,sha256=cQhioibTbIKIBZ-bf8-Bt4F4Iblhidps-CYWrkxRPnE,4295
 kumoai/graph/graph.py,sha256=Pq-dxi4MwoDtrrwm3xeyUB9Hl7ryNfHq4rMHuvyNB3c,39239
@@ -87,14 +85,14 @@ kumoai/trainer/baseline_trainer.py,sha256=oXweh8j1sar6KhQfr3A7gmQxcDq7SG0Bx3jIen
 kumoai/trainer/config.py,sha256=7_Jv1w1mqaokCQwQdJkqCSgVpmh8GqE3fL1Ky_vvttI,100
 kumoai/trainer/job.py,sha256=IBP2SeIk21XpRK1Um1NIs2dEKid319cHu6UkCjKO6jc,46130
 kumoai/trainer/online_serving.py,sha256=T1jicl-qXiiWGQWUCwlfQsyxWUODybj_975gx9yglH4,9824
-kumoai/trainer/trainer.py,sha256=RwqSznW2ubwzyL0f36fCIJ2sIJVj4h1D7HZszNzO63w,20570
+kumoai/trainer/trainer.py,sha256=AKumc3X2Vm3qxZSA85Dv_fSLC4JQ3rM7P0ixOWbEex0,20608
 kumoai/trainer/util.py,sha256=LCXkY5MNl6NbEVd2OZ0aVqF6fvr3KiCFh6pH0igAi_g,4165
 kumoai/utils/__init__.py,sha256=wAKgmwtMIGuiauW9D_GGKH95K-24Kgwmld27mm4nsro,278
 kumoai/utils/datasets.py,sha256=UyAII-oAn7x3ombuvpbSQ41aVF9SYKBjQthTD-vcT2A,3011
 kumoai/utils/forecasting.py,sha256=ZgKeUCbWLOot0giAkoigwU5du8LkrwAicFOi5hVn6wg,7624
 kumoai/utils/progress_logger.py,sha256=tzwFrUO5VuiArxx9_tSETno8JF5rnFOedX26I2yDW10,5046
-kumoai-2.11.0.dev202510191831.dist-info/licenses/LICENSE,sha256=ZUilBDp--4vbhsEr6f_Upw9rnIx09zQ3K9fXQ0rfd6w,1111
-kumoai-2.11.0.dev202510191831.dist-info/METADATA,sha256=UXe66X810YLpA80MJT08ZWvSK5wXb7LpO7CD-mZUwjs,2112
-kumoai-2.11.0.dev202510191831.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
-kumoai-2.11.0.dev202510191831.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
-kumoai-2.11.0.dev202510191831.dist-info/RECORD,,
+kumoai-2.12.0.dev202511061731.dist-info/licenses/LICENSE,sha256=ZUilBDp--4vbhsEr6f_Upw9rnIx09zQ3K9fXQ0rfd6w,1111
+kumoai-2.12.0.dev202511061731.dist-info/METADATA,sha256=SPJcCqBkl2zsVJpfx8Z4REvTS6tcT1w4RzwKwk8GJVI,2112
+kumoai-2.12.0.dev202511061731.dist-info/WHEEL,sha256=JLOMsP7F5qtkAkINx5UnzbFguf8CqZeraV8o04b0I8I,101
+kumoai-2.12.0.dev202511061731.dist-info/top_level.txt,sha256=YjU6UcmomoDx30vEXLsOU784ED7VztQOsFApk1SFwvs,7
+kumoai-2.12.0.dev202511061731.dist-info/RECORD,,

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