kumoai 2.9.0.dev202509081831__cp312-cp312-win_amd64.whl → 2.12.0.dev202511111731__cp312-cp312-win_amd64.whl

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/authenticate.py

@@ -264,14 +264,17 @@ def _authenticate_local(api_url: str, redirect_port: int = 8765) -> None:
                  f"?callback_url={urllib.parse.quote(callback_url)}" +
                  f"&token_name={urllib.parse.quote(token_name)}")
 
-    print("Opening browser page to automatically generate an API key...")
+    print(
+        "Opening browser page to automatically generate an API key...\n" +
+        "If the page does not open, manually create a new API key at " +
+        f"{api_url}/api-keys and set it using os.environ[\"KUMO_API_KEY\"] " +
+        "= \"YOUR_API_KEY\"")
+
     webbrowser.open(login_url)
 
     def get_user_input() -> None:
-        print("If the page does not open, manually create a new API key at " +
-              f"{api_url}/api-keys and paste it below:")
-
-        token_entered = getpass("API Key (type then press enter): ").strip()
+        token_entered = getpass(
+            "or paste the API key here and press enter: ").strip()
 
         while (len(token_entered) == 0):
             token_entered = getpass(

kumoai/experimental/rfm/infer/timestamp.py

@@ -2,6 +2,7 @@ import re
 import warnings
 
 import pandas as pd
+from dateutil.parser import UnknownTimezoneWarning
 from kumoapi.typing import Dtype, Stype
 
 
@@ -20,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()
@@ -34,5 +33,9 @@ def contains_timestamp(ser: pd.Series, column_name: str, dtype: Dtype) -> bool:
     ser = ser.astype(str)  # Avoid parsing numbers as unix timestamps.
 
     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()]
 
@@ -197,12 +200,6 @@ class LocalGraph:
             KeyError: If a table with the same name already exists in the
                 graph.
         """
-        if len(self.tables) >= 15:
-            raise ValueError("Cannot create a graph with more than 15 "
-                             "tables. Please create a feature request at "
-                             "'https://github.com/kumo-ai/kumo-rfm' if you "
-                             "must go beyond this for your use-case.")
-
         if table.name in self._tables:
             raise KeyError(f"Cannot add table with name '{table.name}' to "
                            f"this graph; table names must be globally unique.")
@@ -237,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())
 
@@ -257,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:
@@ -608,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
 
@@ -682,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 = []
@@ -689,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)
 
@@ -758,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,
@@ -201,11 +202,15 @@ class LocalGraphStore:
                 pkey_map = pkey_map[self.mask_dict[table.name]]
 
             if len(pkey_map) == 0:
-                raise ValueError(
-                    f"Found no valid rows in table '{table.name}' since there "
-                    f"exists not a single row with a non-N/A primary key."
-                    f"Consider fixing your underlying data or removing this "
-                    f"table from the graph.")
+                error_msg = f"Found no valid rows in table '{table.name}'. "
+                if table.has_time_column():
+                    error_msg += ("Please make sure that there exists valid "
+                                  "non-N/A primary key and time column pairs "
+                                  "in this table.")
+                else:
+                    error_msg += ("Please make sure that there exists valid "
+                                  "non-N/A primary keys in this table.")
+                raise ValueError(error_msg)
 
             pkey_map_dict[table.name] = pkey_map
 
@@ -215,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
 
@@ -239,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,