kumoai 2.10.0.dev202509281831__cp313-cp313-win_amd64.whl → 2.13.0.dev202511211730__cp313-cp313-win_amd64.whl

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

@@ -2,7 +2,6 @@ from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
-from kumoapi.model_plan import RunMode
 from kumoapi.rfm.context import EdgeLayout, Link, Subgraph, Table
 from kumoapi.typing import Stype
 
@@ -33,7 +32,6 @@ class LocalGraphSampler:
         entity_table_names: Tuple[str, ...],
         node: np.ndarray,
         time: np.ndarray,
-        run_mode: RunMode,
         num_neighbors: List[int],
         exclude_cols_dict: Dict[str, List[str]],
     ) -> Subgraph:
@@ -92,15 +90,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,