kumoai 2.10.0.dev202509291830__cp312-cp312-macosx_11_0_arm64.whl → 2.13.0.dev202511161731__cp312-cp312-macosx_11_0_arm64.whl

kumoai/__init__.py

@@ -200,9 +200,11 @@ def init(
 
     logger = logging.getLogger('kumoai')
     log_level = logging.getLevelName(logger.getEffectiveLevel())
+
     logger.info(
-        "Successfully initialized the Kumo SDK against deployment %s, with "
-        "log level %s.", url, log_level)
+        f"Successfully initialized the Kumo SDK (version {__version__}) "
+        f"against deployment {url}, with "
+        f"log level {log_level}.")
 
 
 def set_log_level(level: str) -> None:

kumoai/_version.py

@@ -1 +1 @@
-__version__ = '2.10.0.dev202509291830'
+__version__ = '2.13.0.dev202511161731'

kumoai/client/client.py

@@ -33,6 +33,7 @@ class KumoClient:
         url: str,
         api_key: Optional[str],
         spcs_token: Optional[str] = None,
+        verify_ssl: bool = True,
     ) -> None:
         r"""Creates a client against the Kumo public API, provided a URL of
         the endpoint and an authentication token.
@@ -42,11 +43,14 @@ class KumoClient:
             api_key: the public API authentication token.
             spcs_token: the SPCS token used for authentication to access the
                 Kumo API endpoint.
+            verify_ssl: whether to verify SSL certificates. Set to False to
+                skip SSL certificate verification (equivalent to curl -k).
         """
         self._url = url
         self._api_url = f"{url}/{API_VERSION}"
         self._api_key = api_key
         self._spcs_token = spcs_token
+        self._verify_ssl = verify_ssl
 
         retry_strategy = Retry(
             total=10,  # Maximum number of retries
@@ -73,7 +77,8 @@ class KumoClient:
         r"""Raises an exception if authentication fails. Succeeds if the
         client is properly formed.
         """
-        return self._session.get(f"{self._url}/v1/connectors").ok
+        return self._session.get(f"{self._url}/v1/connectors",
+                                 verify=self._verify_ssl).ok
 
     def set_spcs_token(self, spcs_token: str) -> None:
         r"""Sets the SPCS token for the client and updates the session
@@ -184,7 +189,7 @@ class KumoClient:
         :meth:`requests.Session.get`.
         """
         url = self._format_endpoint_url(endpoint)
-        return self._session.get(url=url, **kwargs)
+        return self._session.get(url=url, verify=self._verify_ssl, **kwargs)
 
     def _post(self, endpoint: str, **kwargs: Any) -> requests.Response:
         r"""Send a POST request to the specified endpoint, with keyword
@@ -192,7 +197,7 @@ class KumoClient:
         :meth:`requests.Session.post`.
         """
         url = self._format_endpoint_url(endpoint)
-        return self._session.post(url=url, **kwargs)
+        return self._session.post(url=url, verify=self._verify_ssl, **kwargs)
 
     def _patch(self, endpoint: str, **kwargs: Any) -> requests.Response:
         r"""Send a PATCH request to the specified endpoint, with keyword
@@ -200,7 +205,7 @@ class KumoClient:
         :meth:`requests.Session.patch`.
         """
         url = self._format_endpoint_url(endpoint)
-        return self._session.patch(url=url, **kwargs)
+        return self._session.patch(url=url, verify=self._verify_ssl, **kwargs)
 
     def _delete(self, endpoint: str, **kwargs: Any) -> requests.Response:
         r"""Send a DELETE request to the specified endpoint, with keyword
@@ -208,7 +213,7 @@ class KumoClient:
         :meth:`requests.Session.delete`.
         """
         url = self._format_endpoint_url(endpoint)
-        return self._session.delete(url=url, **kwargs)
+        return self._session.delete(url=url, verify=self._verify_ssl, **kwargs)
 
     def _format_endpoint_url(self, endpoint: str) -> str:
         if endpoint[0] == "/":

kumoai/client/endpoints.py

@@ -147,3 +147,4 @@ class RFMEndpoints:
     explain = Endpoint(f"{BASE}/explain", HTTPMethod.POST)
     evaluate = Endpoint(f"{BASE}/evaluate", HTTPMethod.POST)
     validate_query = Endpoint(f"{BASE}/validate_query", HTTPMethod.POST)
+    parse_query = Endpoint(f"{BASE}/parse_query", HTTPMethod.POST)

kumoai/client/rfm.py

@@ -1,6 +1,11 @@
+from typing import Any
+
 from kumoapi.json_serde import to_json_dict
 from kumoapi.rfm import (
     RFMEvaluateResponse,
+    RFMExplanationResponse,
+    RFMParseQueryRequest,
+    RFMParseQueryResponse,
     RFMPredictResponse,
     RFMValidateQueryRequest,
     RFMValidateQueryResponse,
@@ -25,28 +30,35 @@ class RFMAPI:
         Returns:
             RFMPredictResponse containing the predictions
         """
-        # Send binary data to the predict endpoint
         response = self._client._request(
-            RFMEndpoints.predict, data=request,
-            headers={'Content-Type': 'application/x-protobuf'})
+            RFMEndpoints.predict,
+            data=request,
+            headers={'Content-Type': 'application/x-protobuf'},
+        )
         raise_on_error(response)
         return parse_response(RFMPredictResponse, response)
 
-    def explain(self, request: bytes) -> RFMPredictResponse:
+    def explain(
+        self,
+        request: bytes,
+        skip_summary: bool = False,
+    ) -> RFMExplanationResponse:
         """Explain the RFM model on the given context.
 
         Args:
             request: The predict request as serialized protobuf.
+            skip_summary: Whether to skip generating a human-readable summary
+                of the explanation.
 
         Returns:
             RFMPredictResponse containing the explanations
         """
-        # Send binary data to the explain endpoint
+        params: dict[str, Any] = {'generate_summary': not skip_summary}
         response = self._client._request(
-            RFMEndpoints.explain, data=request,
+            RFMEndpoints.explain, data=request, params=params,
             headers={'Content-Type': 'application/x-protobuf'})
         raise_on_error(response)
-        return parse_response(RFMPredictResponse, response)
+        return parse_response(RFMExplanationResponse, response)
 
     def evaluate(self, request: bytes) -> RFMEvaluateResponse:
         """Evaluate the RFM model on the given context.
@@ -57,7 +69,6 @@ class RFMAPI:
         Returns:
             RFMEvaluateResponse containing the computed metrics
         """
-        # Send binary data to the evaluate endpoint
         response = self._client._request(
             RFMEndpoints.evaluate, data=request,
             headers={'Content-Type': 'application/x-protobuf'})
@@ -81,3 +92,21 @@ class RFMAPI:
                                          json=to_json_dict(request))
         raise_on_error(response)
         return parse_response(RFMValidateQueryResponse, response)
+
+    def parse_query(
+        self,
+        request: RFMParseQueryRequest,
+    ) -> RFMParseQueryResponse:
+        """Validate a predictive query against a graph.
+
+        Args:
+            request: The request object containing
+                the query and graph definition
+
+        Returns:
+            RFMParseQueryResponse containing the QueryDefinition
+        """
+        response = self._client._request(RFMEndpoints.parse_query,
+                                         json=to_json_dict(request))
+        raise_on_error(response)
+        return parse_response(RFMParseQueryResponse, response)

kumoai/experimental/rfm/__init__.py

@@ -12,7 +12,7 @@ CPU architecture: {platform.machine()}
 glibc version: {platform.libc_ver()[1]}
 
 ✅ Supported Environments:
-* Python versions: 3.9, 3.10, 3.11, 3.12, 3.13
+* Python versions: 3.10, 3.11, 3.12, 3.13
 * Operating systems and CPU architectures:
   * Linux (x86_64)
   * macOS (arm64)
@@ -20,7 +20,7 @@ glibc version: {platform.libc_ver()[1]}
 * glibc versions: >=2.28
 
 ❌ Unsupported Environments:
-* Python versions: 3.8, 3.14
+* Python versions: 3.8, 3.9, 3.14
 * Operating systems and CPU architectures:
   * Linux (arm64)
   * macOS (x86_64)
@@ -36,7 +36,7 @@ import os
 import kumoai
 from .local_table import LocalTable
 from .local_graph import LocalGraph
-from .rfm import KumoRFM
+from .rfm import ExplainConfig, Explanation, KumoRFM
 from .authenticate import authenticate
 
 
@@ -60,6 +60,8 @@ __all__ = [
     'LocalTable',
     'LocalGraph',
     'KumoRFM',
+    'ExplainConfig',
+    'Explanation',
     'authenticate',
     'init',
 ]

kumoai/experimental/rfm/infer/timestamp.py

@@ -21,9 +21,7 @@ def contains_timestamp(ser: pd.Series, column_name: str, dtype: Dtype) -> bool:
         column_name,
         re.IGNORECASE,
     )
-
-    if match is not None:
-        return True
+    score = 0.3 if match is not None else 0.0
 
     ser = ser.iloc[:100]
     ser = ser.dropna()
@@ -37,4 +35,7 @@ def contains_timestamp(ser: pd.Series, column_name: str, dtype: Dtype) -> bool:
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', UnknownTimezoneWarning)
         warnings.filterwarnings('ignore', message='Could not infer format')
-        return pd.to_datetime(ser, errors='coerce').notna().all()
+        mask = pd.to_datetime(ser, errors='coerce').notna()
+        score += int(mask.sum()) / len(mask)
+
+    return score >= 1.0

kumoai/experimental/rfm/local_graph.py

@@ -29,45 +29,46 @@ class LocalGraph:
 
     .. code-block:: python
 
-        import pandas as pd
-        import kumoai.experimental.rfm as rfm
-
-        # Load data frames into memory:
-        df1 = pd.DataFrame(...)
-        df2 = pd.DataFrame(...)
-        df3 = pd.DataFrame(...)
-
-        # Define tables from data frames:
-        table1 = rfm.LocalTable(name="table1", data=df1)
-        table2 = rfm.LocalTable(name="table2", data=df2)
-        table3 = rfm.LocalTable(name="table3", data=df3)
-
-        # Create a graph from a dictionary of tables:
-        graph = rfm.LocalGraph({
-            "table1": table1,
-            "table2": table2,
-            "table3": table3,
-        })
-
-        # Infer table metadata:
-        graph.infer_metadata()
-
-        # Infer links/edges:
-        graph.infer_links()
-
-        # Inspect table metadata:
-        for table in graph.tables.values():
-            table.print_metadata()
-
-        # Visualize graph (if graphviz is installed):
-        graph.visualize()
-
-        # Add/Remove edges between tables:
-        graph.link(src_table="table1", fkey="id1", dst_table="table2")
-        graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
-
-        # Validate graph:
-        graph.validate()
+        >>> # doctest: +SKIP
+        >>> import pandas as pd
+        >>> import kumoai.experimental.rfm as rfm
+
+        >>> # Load data frames into memory:
+        >>> df1 = pd.DataFrame(...)
+        >>> df2 = pd.DataFrame(...)
+        >>> df3 = pd.DataFrame(...)
+
+        >>> # Define tables from data frames:
+        >>> table1 = rfm.LocalTable(name="table1", data=df1)
+        >>> table2 = rfm.LocalTable(name="table2", data=df2)
+        >>> table3 = rfm.LocalTable(name="table3", data=df3)
+
+        >>> # Create a graph from a dictionary of tables:
+        >>> graph = rfm.LocalGraph({
+        ...     "table1": table1,
+        ...     "table2": table2,
+        ...     "table3": table3,
+        ... })
+
+        >>> # Infer table metadata:
+        >>> graph.infer_metadata()
+
+        >>> # Infer links/edges:
+        >>> graph.infer_links()
+
+        >>> # Inspect table metadata:
+        >>> for table in graph.tables.values():
+        ...     table.print_metadata()
+
+        >>> # Visualize graph (if graphviz is installed):
+        >>> graph.visualize()
+
+        >>> # Add/Remove edges between tables:
+        >>> graph.link(src_table="table1", fkey="id1", dst_table="table2")
+        >>> graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
+
+        >>> # Validate graph:
+        >>> graph.validate()
     """
 
     # Constructors ############################################################
@@ -104,27 +105,28 @@ class LocalGraph:
 
         .. code-block:: python
 
-            import pandas as pd
-            import kumoai.experimental.rfm as rfm
+            >>> # doctest: +SKIP
+            >>> import pandas as pd
+            >>> import kumoai.experimental.rfm as rfm
 
-            # Load data frames into memory:
-            df1 = pd.DataFrame(...)
-            df2 = pd.DataFrame(...)
-            df3 = pd.DataFrame(...)
+            >>> # Load data frames into memory:
+            >>> df1 = pd.DataFrame(...)
+            >>> df2 = pd.DataFrame(...)
+            >>> df3 = pd.DataFrame(...)
 
-            # Create a graph from a dictionary of data frames:
-            graph = rfm.LocalGraph.from_data({
-                "table1": df1,
-                "table2": df2,
-                "table3": df3,
-            })
+            >>> # Create a graph from a dictionary of data frames:
+            >>> graph = rfm.LocalGraph.from_data({
+            ...     "table1": df1,
+            ...     "table2": df2,
+            ...     "table3": df3,
+            ... })
 
-            # Inspect table metadata:
-            for table in graph.tables.values():
-                table.print_metadata()
+            >>> # Inspect table metadata:
+            >>> for table in graph.tables.values():
+            ...     table.print_metadata()
 
-            # Visualize graph (if graphviz is installed):
-            graph.visualize()
+            >>> # Visualize graph (if graphviz is installed):
+            >>> graph.visualize()
 
         Args:
             df_dict: A dictionary of data frames, where the keys are the names
@@ -141,6 +143,7 @@ class LocalGraph:
             graph.
 
         Example:
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
             >>> df1 = pd.DataFrame(...)
             >>> df2 = pd.DataFrame(...)
@@ -150,7 +153,7 @@ class LocalGraph:
             ...     "table2": df2,
             ...     "table3": df3,
             ... })
-            ... graph.validate()
+            >>> graph.validate()
         """
         tables = [LocalTable(df, name) for name, df in df_dict.items()]
 
@@ -231,16 +234,17 @@ class LocalGraph:
         r"""Returns a :class:`pandas.DataFrame` object containing metadata
         information about the tables in this graph.
 
-        The returned dataframe has columns ``name``, ``primary_key``, and
-        ``time_column``, which provide an aggregate view of the properties of
-        the tables of this graph.
+        The returned dataframe has columns ``name``, ``primary_key``,
+        ``time_column``, and ``end_time_column``, which provide an aggregate
+        view of the properties of the tables of this graph.
 
         Example:
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
             >>> graph = rfm.LocalGraph(tables=...).infer_metadata()
-            >>> graph.metadata
-                name  primary_key time_column
-            0   users     user_id           -
+            >>> graph.metadata  # doctest: +SKIP
+                name   primary_key  time_column  end_time_column
+            0   users      user_id            -                -
         """
         tables = list(self.tables.values())
 
@@ -251,6 +255,11 @@ class LocalGraph:
             pd.Series(dtype=str, data=[t._primary_key or '-' for t in tables]),
             'time_column':
             pd.Series(dtype=str, data=[t._time_column or '-' for t in tables]),
+            'end_time_column':
+            pd.Series(
+                dtype=str,
+                data=[t._end_time_column or '-' for t in tables],
+            ),
         })
 
     def print_metadata(self) -> None:
@@ -602,8 +611,8 @@ class LocalGraph:
                 raise ValueError(f"{edge} is invalid as foreign key "
                                  f"'{fkey}' and primary key '{dst_key.name}' "
                                  f"have incompatible data types (got "
-                                 f"fkey.dtype '{dst_key.dtype}' and "
-                                 f"pkey.dtype '{src_key.dtype}')")
+                                 f"fkey.dtype '{src_key.dtype}' and "
+                                 f"pkey.dtype '{dst_key.dtype}')")
 
         return self
 
@@ -676,6 +685,11 @@ class LocalGraph:
             ]
             if time_column := table.time_column:
                 keys += [f'{time_column.name}: Time ({time_column.dtype})']
+            if end_time_column := table.end_time_column:
+                keys += [
+                    f'{end_time_column.name}: '
+                    f'End Time ({end_time_column.dtype})'
+                ]
             key_repr = left_align(keys)
 
             columns = []
@@ -683,9 +697,9 @@ class LocalGraph:
                 columns += [
                     f'{column.name}: {column.stype} ({column.dtype})'
                     for column in table.columns
-                    if column.name not in fkeys_dict[table_name]
-                    and column.name != table._primary_key
-                    and column.name != table._time_column
+                    if column.name not in fkeys_dict[table_name] and
+                    column.name != table._primary_key and column.name != table.
+                    _time_column and column.name != table._end_time_column
                 ]
             column_repr = left_align(columns)
 
@@ -752,16 +766,18 @@ class LocalGraph:
     def _to_api_graph_definition(self) -> GraphDefinition:
         tables: Dict[str, TableDefinition] = {}
         col_groups: List[ColumnKeyGroup] = []
-        for t_name, table in self.tables.items():
-            tables[t_name] = table._to_api_table_definition()
+        for table_name, table in self.tables.items():
+            tables[table_name] = table._to_api_table_definition()
             if table.primary_key is None:
                 continue
-            keys = [ColumnKey(t_name, table.primary_key.name)]
+            keys = [ColumnKey(table_name, table.primary_key.name)]
             for edge in self.edges:
-                if edge.dst_table == t_name:
+                if edge.dst_table == table_name:
                     keys.append(ColumnKey(edge.src_table, edge.fkey))
-            keys = sorted(list(set(keys)),
-                          key=lambda x: f'{x.table_name}.{x.col_name}')
+            keys = sorted(
+                list(set(keys)),
+                key=lambda x: f'{x.table_name}.{x.col_name}',
+            )
             if len(keys) > 1:
                 col_groups.append(ColumnKeyGroup(keys))
         return GraphDefinition(tables, col_groups)

kumoai/experimental/rfm/local_graph_sampler.py

@@ -92,15 +92,23 @@ class LocalGraphSampler:
                 )
                 continue
 
-            # Only store unique rows in `df` above a certain threshold:
-            unique_node, inverse_node = np.unique(node, return_inverse=True)
-            if len(node) > 1.05 * len(unique_node):
-                df = df.iloc[unique_node]
-                row = inverse_node
+            row: Optional[np.ndarray] = None
+            if table_name in self._graph_store.end_time_column_dict:
+                # Set end time to NaT for all values greater than anchor time:
+                df = df.iloc[node].reset_index(drop=True)
+                col_name = self._graph_store.end_time_column_dict[table_name]
+                ser = df[col_name]
+                value = ser.astype('datetime64[ns]').astype(int).to_numpy()
+                mask = value > time[batch]
+                df.loc[mask, col_name] = pd.NaT
             else:
-                df = df.iloc[node]
-                row = None
-            df = df.reset_index(drop=True)
+                # Only store unique rows in `df` above a certain threshold:
+                unique_node, inverse = np.unique(node, return_inverse=True)
+                if len(node) > 1.05 * len(unique_node):
+                    df = df.iloc[unique_node].reset_index(drop=True)
+                    row = inverse
+                else:
+                    df = df.iloc[node].reset_index(drop=True)
 
             # Filter data frame to minimal set of columns:
             df = df[columns]

kumoai/experimental/rfm/local_graph_store.py

@@ -45,6 +45,7 @@ class LocalGraphStore:
 
             (
                 self.time_column_dict,
+                self.end_time_column_dict,
                 self.time_dict,
                 self.min_time,
                 self.max_time,
@@ -219,16 +220,21 @@ class LocalGraphStore:
         self,
         graph: LocalGraph,
     ) -> Tuple[
+            Dict[str, str],
             Dict[str, str],
             Dict[str, np.ndarray],
             pd.Timestamp,
             pd.Timestamp,
     ]:
         time_column_dict: Dict[str, str] = {}
+        end_time_column_dict: Dict[str, str] = {}
         time_dict: Dict[str, np.ndarray] = {}
         min_time = pd.Timestamp.max
         max_time = pd.Timestamp.min
         for table in graph.tables.values():
+            if table._end_time_column is not None:
+                end_time_column_dict[table.name] = table._end_time_column
+
             if table._time_column is None:
                 continue
 
@@ -243,7 +249,13 @@ class LocalGraphStore:
                 min_time = min(min_time, time.min())
                 max_time = max(max_time, time.max())
 
-        return time_column_dict, time_dict, min_time, max_time
+        return (
+            time_column_dict,
+            end_time_column_dict,
+            time_dict,
+            min_time,
+            max_time,
+        )
 
     def get_csc(
         self,