tdfs4ds 0.2.4.38__py3-none-any.whl → 0.2.4.40__py3-none-any.whl

tdfs4ds/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.2.4.38'
+__version__ = '0.2.4.40'
 import logging
 import json
 
@@ -800,7 +800,13 @@ def _upload_features(
             do_compute = True
             if process_id and tdfs4ds.FEATURE_STORE_TIME:
                 # see if already computed
-                follow_up = tdfs4ds.process_store.process_followup.follow_up_report()
+                follow_up = tdfs4ds.process_store.process_followup.follow_up_report(process_id=process_id, filtermanager=filtermanager)
+                follow_up = follow_up[
+                    (follow_up.STATUS == 'COMPLETED') &
+                    (follow_up.VALIDTIME_DATE.isna() == False) &
+                    (follow_up.VALIDTIME_DATE == tdfs4ds.FEATURE_STORE_TIME)
+                    ]                
+                
                 if follow_up.shape[0] > 0:
                     do_compute = False
 

tdfs4ds/feature_store/feature_store_management.py

@@ -130,57 +130,27 @@ def feature_store_catalog_creation(if_exists='replace', comment='this table is a
     return tdfs4ds.FEATURE_CATALOG_NAME
 
 
-def feature_store_table_creation(entity_id, feature_type, if_exists='fail', primary_index = None, partitioning = ''):
+def feature_store_table_creation(entity_id, feature_type, if_exists='fail', primary_index=None, partitioning=''):
     """
     Creates a table and a corresponding view for feature storage in a Teradata database schema, based on specified entity ID and feature type.
-
-    This function automates the creation of a table and view tailored for storing features in a structured manner. It leverages provided entity identifiers and feature types to generate table and view names dynamically, integrating with an existing feature catalog for consistency and reference. The table and view are created with considerations for primary indexing and optional partitioning strategies to optimize data management and access.
-
-    Parameters:
-    - entity_id (dict): Maps column names to their respective data types, defining the structure of the entity identifier(s).
-    - feature_type (str): Specifies the data type of the feature (e.g., 'FLOAT', 'BIGINT', 'VARCHAR_LATIN', 'VARCHAR_UNICODE').
-    - if_exists (str, optional): Determines the action if the table already exists. Options include:
-                                 'fail' (default), which raises an error; and 'replace', which drops the existing table and creates a new one.
-    - primary_index (list, optional): Specifies the columns to be used as the primary index for the table. Enhances data retrieval performance.
-    - partitioning (str, optional): SQL clause to define table partitioning. Aids in managing large datasets efficiently.
-
-    Returns:
-    str: The name of the newly created feature store table.
-
-    Note:
-    - Utilizes default schema and feature catalog names as defined in the tdfs4ds module.
-    - The primary index typically includes the entity ID, feature ID, and feature version for optimal data organization.
-    - A secondary index on the feature ID facilitates efficient querying.
-    - Corresponding views offer a snapshot of the current valid-time features, simplifying temporal queries.
-    - Existing tables are handled based on the 'if_exists' parameter, with support for replacing or retaining the tables.
-    - Assumes necessary database access and permissions are available for table and view creation.
-
-    Example Usage:
-    >>> entity_id_dict = {'customer_id': 'INTEGER'}
-    >>> table_name = feature_store_table_creation(entity_id_dict, 'FLOAT')
-    >>> print(f"Feature store table {table_name} created successfully.")
     """
-
-
-    table_name, view_name = get_feature_store_table_name(entity_id, feature_type, primary_index = primary_index, partitioning = partitioning)
-    if len([t for t in tdml.db_list_tables(schema_name=tdfs4ds.SCHEMA).TableName if t.lower() ==table_name.lower()]) > 0:
-        if tdfs4ds.DISPLAY_LOGS:
-            print(f'table {table_name} in the {tdfs4ds.SCHEMA} database already exists. No need to create it.')
+    table_name, view_name = get_feature_store_table_name(entity_id, feature_type, primary_index=primary_index, partitioning=partitioning)
+    if len([t for t in tdml.db_list_tables(schema_name=tdfs4ds.SCHEMA).TableName if t.lower() == table_name.lower()]) > 0:
+        logger_safe('info', f'table {table_name} in the {tdfs4ds.SCHEMA} database already exists. No need to create it.')
         return table_name
     else:
-        if tdfs4ds.DISPLAY_LOGS:
-            print(f'table {table_name} in the {tdfs4ds.SCHEMA} database does not exists. Need to create it.')
+        logger_safe('info', f'table {table_name} in the {tdfs4ds.SCHEMA} database does not exists. Need to create it.')
 
     query_feature_value = {
         'FLOAT':            'FEATURE_VALUE FLOAT',
         'BIGINT':           'FEATURE_VALUE BIGINT',
         'VARCHAR_LATIN':    f'FEATURE_VALUE VARCHAR({tdfs4ds.VARCHAR_SIZE}) CHARACTER SET LATIN',
         'VARCHAR_UNICODE':  f'FEATURE_VALUE VARCHAR({tdfs4ds.VARCHAR_SIZE}) CHARACTER SET UNICODE',
-        'TIMESTAMP0' :      'FEATURE_VALUE TIMESTAMP(0)',
-        'TIMESTAMP0TZ' :    'FEATURE_VALUE TIMESTAMP(0) WITH TIME ZONE',
-        'PERIODTS0' :       'FEATURE_VALUE PERIOD(TIMESTAMP(0))',
+        'TIMESTAMP0':       'FEATURE_VALUE TIMESTAMP(0)',
+        'TIMESTAMP0TZ':     'FEATURE_VALUE TIMESTAMP(0) WITH TIME ZONE',
+        'PERIODTS0':        'FEATURE_VALUE PERIOD(TIMESTAMP(0))',
         'PERIODTS0TZ':      'FEATURE_VALUE PERIOD(TIMESTAMP(0) WITH TIME ZONE)',
-        'DECIMAL' :         'FEATURE_VALUE DECIMAL(38,19)'
+        'DECIMAL':          'FEATURE_VALUE DECIMAL(38,19)'
     }
 
     # Construct the column definitions for the table based on the entity ID
@@ -197,12 +167,14 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
     # SQL query to create the feature store table
     if feature_type.lower() == 'ref':
         partitioning = partitioning.replace('"', "'")
-        partitioning = partitioning.replace(f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH}),','')
+        partitioning = partitioning.replace(f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH}),', '')
         partitioning = partitioning.replace(
             f'RANGE_N(FEATURE_ID BETWEEN 0 AND {tdfs4ds.FEATURE_PARTITION_N} EACH {tdfs4ds.FEATURE_PARTITION_EACH})',
-            '')
+            ''
+        )
         substr = extract_partition_content(partitioning.upper())
-        if len(substr)==0: partitioning =  ''
+        if len(substr) == 0:
+            partitioning = ''
         query = f"""
         CREATE MULTISET TABLE {tdfs4ds.SCHEMA}.{table_name},
             FALLBACK,
@@ -218,7 +190,7 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
             {partitioning};
     """
     else:
-        partitioning = partitioning.replace('"',"'")
+        partitioning = partitioning.replace('"', "'")
         query = f"""
         CREATE MULTISET TABLE {tdfs4ds.SCHEMA}.{table_name},
                 FALLBACK,
@@ -267,39 +239,40 @@ def feature_store_table_creation(entity_id, feature_type, if_exists='fail', prim
 
     try:
         # Attempt to execute the create table query
-        execute_query(query)
-        execute_query(query3)
+        execute_query(query, raise_error=True)
+        execute_query(query3, raise_error=True)
         if tdml.display.print_sqlmr_query:
-            print(query)
-            print(query3)
-        if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been created')
-        #execute_query(query2)
+            logger_safe('info', query)
+            logger_safe('info', query3)
+        logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been created')
+        # execute_query(query2)
     except Exception as e:
-        # If the table already exists and if_exists is set to 'replace', drop the table and recreate it
-        print(str(e).split('\n')[0])
-        if str(e).split('\n')[0].endswith('already exists.') and (if_exists == 'replace'):
-            execute_query(f'DROP TABLE  {tdfs4ds.SCHEMA}.{table_name}')
-            if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been dropped')
+        msg = str(e).split('\n')[0]
+        logger_safe('error', msg)
+        if msg.endswith('already exists.') and (if_exists == 'replace'):
+            execute_query(f'DROP TABLE  {tdfs4ds.SCHEMA}.{table_name}', raise_error=True)
+            logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been dropped')
             try:
                 # Attempt to recreate the table after dropping it
-                execute_query(query)
-                if tdfs4ds.DISPLAY_LOGS: print(f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been re-created')
+                execute_query(query, raise_error=True)
+                logger_safe('info', f'TABLE {tdfs4ds.SCHEMA}.{table_name} has been re-created')
                 if tdml.display.print_sqlmr_query:
-                    print(query)
-            except Exception as e:
-                print(str(e).split('\n')[0])
+                    logger_safe('info', query)
+            except Exception as e2:
+                logger_safe('error', str(e2).split('\n')[0])
 
     try:
         # Attempt to create the view
-        execute_query(query_view)
+        execute_query(query_view, raise_error=True)
         if tdml.display.print_sqlmr_query:
-            print(query)
-        if tdfs4ds.DISPLAY_LOGS: print(f'VIEW {tdfs4ds.SCHEMA}.{view_name} has been created')
+            logger_safe('info', query_view)
+        logger_safe('info', f'VIEW {tdfs4ds.SCHEMA}.{view_name} has been created')
     except Exception as e:
-        print(str(e).split('\n')[0])
+        logger_safe('error', str(e).split('\n')[0])
 
     return table_name
 
+
 def register_features(entity_id, feature_names_types, primary_index = None, partitioning = ''):
     """
     Orchestrates the registration or update of feature definitions in a Teradata database's feature catalog.

tdfs4ds/process_store/process_followup.py

@@ -1,6 +1,7 @@
 import tdfs4ds
 from tdfs4ds.utils.query_management import execute_query_wrapper
 import teradataml as tdml
+from tdfs4ds import logger_safe, logger
 
 @execute_query_wrapper
 def follow_up_table_creation():
@@ -194,5 +195,115 @@ def followup_close(run_id, process_type, process_id, status='COMPLETED', filterm
         raise
     return query
 
-def follow_up_report():
-    return tdml.DataFrame(tdml.in_schema(tdfs4ds.SCHEMA, tdfs4ds.FOLLOW_UP_NAME.replace('FS_', 'FS_V_'))).sort('START_DATETIME',ascending=False)
+from typing import Optional
+
+def follow_up_report(filtermanager: Optional[object] = None, process_id: Optional[str] = None):
+    """
+    Return a follow-up report as a `tdml.DataFrame`, optionally filtered by
+    `process_id` and/or a `filtermanager`'s applied filter.
+
+    Behavior by arguments:
+        - process_id is None and filtermanager is None:
+            Return all rows from SCHEMA.FOLLOW_UP_NAME, sorted by START_DATETIME desc.
+        - process_id is not None and filtermanager is None:
+            Return rows for the given PROCESS_ID.
+        - process_id is not None and filtermanager is not None:
+            Return rows for the given PROCESS_ID whose APPLIED_FILTER matches the
+            JSON_AGG of `filtermanager`'s columns coming from its schema/view.
+        - process_id is None and filtermanager is not None:
+            Return rows whose APPLIED_FILTER matches the JSON_AGG of `filtermanager`
+            (no PROCESS_ID constraint).
+
+    Args:
+        filtermanager: An object exposing `col_names`, `schema_name`, and `view_name`.
+            Its columns are aggregated via `JSON_AGG(col1, col2, ...)` to compare
+            against A.APPLIED_FILTER.
+        process_id: Optional process identifier used to filter by PROCESS_ID.
+
+    Returns:
+        tdml.DataFrame: The resulting dataframe sorted by START_DATETIME (descending).
+
+    Raises:
+        ValueError: If `filtermanager` is provided but is missing required attributes
+            or has an empty `col_names` list.
+        RuntimeError: If the query fails.
+    """
+    logger_safe("debug", "follow_up_report called with process_id=%s, filtermanager=%s",
+                process_id, type(filtermanager).__name__ if filtermanager else None)
+
+    table_fqn = f"{tdfs4ds.SCHEMA}.{tdfs4ds.FOLLOW_UP_NAME}"
+
+    # Case 1: No filters at all -> return full table
+    if process_id is None and filtermanager is None:
+        logger_safe("info", "Returning all follow-up rows (no filters).")
+        try:
+            return tdml.DataFrame(tdml.in_schema(tdfs4ds.SCHEMA, tdfs4ds.FOLLOW_UP_NAME)) \
+                      .sort('START_DATETIME', ascending=False)
+        except Exception as e:
+            logger_safe("error", "Failed to fetch all follow-up rows: %s", e)
+            raise RuntimeError("Database query failed while fetching follow-up report.") from e
+
+    # Helper to build the FILTER_MANAGER scalar subquery when filtermanager is provided
+    def _build_filter_manager_subquery(fm: object) -> str:
+        required_attrs = ("col_names", "schema_name", "view_name")
+        if not all(hasattr(fm, a) for a in required_attrs):
+            raise ValueError("filtermanager must have col_names, schema_name, and view_name.")
+        if not getattr(fm, "col_names", None):
+            raise ValueError("filtermanager.col_names must be a non-empty list.")
+
+        json_cols = ",".join(fm.col_names)
+        subq = f"""
+            (
+                SELECT JSON_AGG({json_cols}) AS APPLIED_FILTER
+                FROM {fm.schema_name}.{fm.view_name}
+            ) FILTER_MANAGER
+        """
+        logger_safe("debug", "Constructed FILTER_MANAGER subquery with columns: %s", json_cols)
+        return subq
+
+    # Defensive escaping for process_id if used in a literal (prefer bind params if available)
+    def _escape_literal(val: str) -> str:
+        return val.replace("'", "''")
+
+    try:
+        # Case 2: process_id only
+        if process_id is not None and filtermanager is None:
+            pid = _escape_literal(process_id)
+            query = f"""
+                SELECT *
+                FROM {table_fqn}
+                WHERE PROCESS_ID = '{pid}'
+            """
+            logger_safe("info", "Fetching follow-up rows filtered by PROCESS_ID only.")
+            return tdml.DataFrame.from_query(query).sort('START_DATETIME', ascending=False)
+
+        # Case 3: filtermanager only
+        if process_id is None and filtermanager is not None:
+            subq = _build_filter_manager_subquery(filtermanager)
+            query = f"""
+                SELECT A.*
+                FROM {table_fqn} A,
+                     {subq}
+                WHERE CAST(A.APPLIED_FILTER AS VARCHAR(20000)) =
+                      CAST(FILTER_MANAGER.APPLIED_FILTER AS VARCHAR(20000))
+            """
+            logger_safe("info", "Fetching follow-up rows filtered by FILTER_MANAGER only.")
+            return tdml.DataFrame.from_query(query).sort('START_DATETIME', ascending=False)
+
+        # Case 4: both process_id and filtermanager
+        pid = _escape_literal(process_id)  # type: ignore[arg-type]
+        subq = _build_filter_manager_subquery(filtermanager)  # type: ignore[arg-type]
+        query = f"""
+            SELECT A.*
+            FROM {table_fqn} A,
+                 {subq}
+            WHERE A.PROCESS_ID = '{pid}'
+              AND CAST(A.APPLIED_FILTER AS VARCHAR(20000)) =
+                  CAST(FILTER_MANAGER.APPLIED_FILTER AS VARCHAR(20000))
+        """
+        logger_safe("info", "Fetching follow-up rows filtered by PROCESS_ID and FILTER_MANAGER.")
+        return tdml.DataFrame.from_query(query).sort('START_DATETIME', ascending=False)
+
+    except Exception as e:
+        logger_safe("error", "Failed to fetch follow-up report: %s", e)
+        raise RuntimeError("Database query failed while fetching follow-up report.") from e

tdfs4ds/utils/filter_management.py

@@ -3,6 +3,7 @@ import numpy as np  # Needed for np.datetime64 handling in get_date_in_the_past
 import teradataml as tdml
 import tdfs4ds
 from tdfs4ds import logger, logger_safe
+import json
 
 
 def get_hidden_table_name(table_name):
@@ -556,3 +557,61 @@ class FilterManager:
         )
         self._owns_hidden = True
         return self
+
+    def get_filter_condition(self, output_type: str = "str"):
+        """
+        Retrieve the currently applied filter condition from the database.
+
+        This method executes a SQL query that aggregates the filter columns from a
+        filter manager view and returns the result either as a Python dictionary
+        or a raw JSON string.
+
+        Args:
+            output_type (str, optional): Format of the returned filter condition.
+                - "dict": Returns a Python dictionary (default).
+                - "str": Returns a raw JSON string.
+
+        Returns:
+            dict | str | None: The current filter condition in the requested format.
+                Returns None if no filter is present.
+
+        Raises:
+            ValueError: If `output_type` is not "dict" or "str".
+            RuntimeError: If the SQL execution fails.
+
+        Example:
+            >>> filters = self.get_filter_condition(output_type="dict")
+            >>> print(filters)
+            {'country': 'US', 'status': 'active'}
+        """
+        logger_safe("debug", "Fetching current filter condition from the database")
+
+        # Build JSON_AGG expression safely
+        json_columns = ",".join(self.col_names)
+
+        query = f"""
+            SELECT JSON_AGG({json_columns}) AS applied_filter
+            FROM {self.schema_name}.{self.view_name} FILTER_MANAGER
+        """
+
+        try:
+            result = tdml.execute_sql(query).fetchall()
+        except Exception as e:
+            logger_safe("error", "Failed to execute SQL for filter condition: %s", e)
+            raise RuntimeError("Database query failed while fetching filter condition") from e
+
+        # Handle no result
+        if not result or result[0][0] is None:
+            logger_safe("info", "No filter conditions found")
+            return None
+
+        json_result = result[0][0]
+
+        if output_type == "dict":
+            logger_safe("debug", "Returning filter as Python dictionary")
+            return json.loads(json_result)
+        elif output_type == "str":
+            logger_safe("debug", "Returning filter as JSON string")
+            return json_result
+
+        raise ValueError("Invalid output_type. Expected 'dict' or 'str'.")

tdfs4ds/utils/query_management.py

@@ -84,71 +84,49 @@ def execute_query_wrapper(f):
     return wrapped_f
 
 
-def execute_query(query):
+def execute_query(query, raise_error=False):
     """
     Execute a SQL query or a list of queries using the tdml module.
 
-    This function checks the version of the tdml module and executes the query or queries accordingly.
-    For versions greater than 17.20.00.03, it uses `tdml.execute_sql`; otherwise, it uses `tdml.get_context().execute`.
-
     Args:
         query (str or list): A single SQL query string or a list of SQL query strings.
+        raise_error (bool): If True, re-raise exceptions after printing them. Default is False.
 
     Returns:
         The result of the SQL execution if a single query is passed. None if a list of queries is passed or an exception occurs.
+    """
+    def handle_exception(e, q):
+        # Always print error
+        print(str(e).split('\n')[0])
+        print(q)
 
-    Example:
-        To execute a single SQL query and retrieve the result:
-        >>> result = execute_query("SELECT * FROM my_table")
-
-        To execute a list of SQL queries:
-        >>> execute_query(["UPDATE table1 SET column1 = 42", "DELETE FROM table2 WHERE condition"])
-
-    Note:
-        - If a single query is passed, the function returns the result of the SQL execution.
-        - If a list of queries is passed, the function executes each query and returns None.
-        - If an exception occurs during execution, the error message and the problematic query are printed,
-          and the function returns None.
+        # Raise exception only if requested
+        if raise_error:
+            raise e
 
-    """
-    # Check if the version of tdml is greater than the specified base version
     if is_version_greater_than(tdml.__version__, base_version="17.20.00.03"):
-        # If query is a list, iterate and execute each query
-        if type(query) == list:
+        if isinstance(query, list):
             for q in query:
                 try:
-                    tdml.execute_sql(q)  # Execute the query
+                    tdml.execute_sql(q)
                 except Exception as e:
-                    # Print the first line of the exception and the query that caused it
-                    print(str(e).split('\n')[0])
-                    print(q)
+                    handle_exception(e, q)
         else:
-            # If query is not a list, execute it and return the result
             try:
                 return tdml.execute_sql(query)
             except Exception as e:
-                # Print the first line of the exception and the query
-                print(str(e).split('\n')[0])
-                print(query)
+                handle_exception(e, query)
     else:
-        # For tdml versions not greater than the specified version
-        if type(query) == list:
+        if isinstance(query, list):
             for q in query:
                 try:
-                    # Use the older execution method for the query
                     tdml.get_context().execute(q)
                 except Exception as e:
-                    # Print the first line of the exception and the query
-                    print(str(e).split('\n')[0])
-                    print(q)
+                    handle_exception(e, q)
         else:
             try:
-                # Execute the single query using the older method and return the result
                 return tdml.get_context().execute(query)
             except Exception as e:
-                # Print the first line of the exception and the query
-                print(str(e).split('\n')[0])
-                print(query)
+                handle_exception(e, query)
 
-    # No return value if a list of queries is executed or if an exception occurs
-    return
+    return None

{tdfs4ds-0.2.4.38.dist-info → tdfs4ds-0.2.4.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tdfs4ds
-Version: 0.2.4.38
+Version: 0.2.4.40
 Summary: A python package to simplify the usage of feature store using Teradata Vantage ...
 Author: Denis Molin
 Requires-Python: >=3.6

{tdfs4ds-0.2.4.38.dist-info → tdfs4ds-0.2.4.40.dist-info}/RECORD

@@ -2,7 +2,7 @@ tdfs/__init__.py,sha256=7AcO7uB1opRCt7t2JOHworKimfAaDeO3boRW7u9Geo8,23
 tdfs/datasets.py,sha256=-b2MPEKGki2V1M8iUcoDR9uc2krIK7u1CK-EhChvihs,985
 tdfs/feature_store.py,sha256=Honu7eOAXxP4Ivz0mRlhuNkfTDzgZl5HB1WlQUwzcZ0,31354
 tdfs/data/curves.csv,sha256=q0Tm-0yu7VMK4lHvHpgi1LMeRq0lO5gJy2Q17brKbEM,112488
-tdfs4ds/__init__.py,sha256=vOFDL9B3mamt3Cd6ponz4EpZ4BkTBmYFAoxXIkL7CqE,60855
+tdfs4ds/__init__.py,sha256=Iaje0388sV4rstHa_fI1wRo2DxxXRgBh0N2r7X0Da_0,61203
 tdfs4ds/datasets.py,sha256=LE4Gn0muwdyrIrCrbkE92cnafUML63z1lj5bFIIVzmc,3524
 tdfs4ds/feature_engineering.py,sha256=oVnZ2V_XNGE12LKC_fNfkrWSQZLgtYRmaf8Dispi6S4,7081
 tdfs4ds/feature_store.py,sha256=y-oItPZw6nBkBcGAceaATZbkLPTsvpk0OnpzTxYofDs,68576
@@ -19,20 +19,20 @@ tdfs4ds/feature_store/__init__.py,sha256=a7NPCkpTx40UR5LRErwnskpABG2Vuib7F5wUjaU
 tdfs4ds/feature_store/entity_management.py,sha256=9ltytv3yCTG84NZXBpb1Tlkf9pOxvrNb0MVidU4pwvE,10157
 tdfs4ds/feature_store/feature_data_processing.py,sha256=gjwypiTfwTyGyrP20v35Vu2uGIrCY80OBBeMVBsdjuk,45020
 tdfs4ds/feature_store/feature_query_retrieval.py,sha256=51c6ZNlLFiBIxNPinS8ot8bjWEIb1QV2eVg69yzVF80,35381
-tdfs4ds/feature_store/feature_store_management.py,sha256=yXLbINYLA-lzd0t_6TzEe9a8Anlum4x8TRoxZU3FIr8,54276
+tdfs4ds/feature_store/feature_store_management.py,sha256=mtPQkdMDhcOrhj9IAaH-FEP_znK53cYtEv8zXAbsigg,52123
 tdfs4ds/process_store/__init__.py,sha256=npHR_xju5ecGmWfYHDyteLwiU3x-cL4HD3sFK_th7xY,229
-tdfs4ds/process_store/process_followup.py,sha256=PvLcU7meg3ljBlPfuez3qwTVqpHHhVJxYxGqjgiHE8E,7265
+tdfs4ds/process_store/process_followup.py,sha256=E4jgQahjhVRBbfAW3JXNLId7H5qV8ozRt-6PyAQuPzg,12583
 tdfs4ds/process_store/process_query_administration.py,sha256=AOufkJ6DFUpBiGm-6Q6Dq0Aovw31UGTscZ3Ya0ewS-0,7851
 tdfs4ds/process_store/process_registration_management.py,sha256=2fFjt4Pmh3An1BUFvRX3xABSlQrlWiEiPQStH3A9Xpk,36130
 tdfs4ds/process_store/process_store_catalog_management.py,sha256=eVUU9uanyXCUkzi2vcHbJPL9qFiXVasnCxPGr-r9EY8,16090
 tdfs4ds/utils/__init__.py,sha256=-yTMfDLZbQnIRQ64s_bczzT21tDW2A8FZeq9PX5SgFU,168
-tdfs4ds/utils/filter_management.py,sha256=5_8fYYtl8RQgbIi6L_1geNM0wJMm3t1n4QvNA5DnaQg,24760
+tdfs4ds/utils/filter_management.py,sha256=fBcFKetmyyeiuBgrGZfcbf9YfCBXrDOnjoFLq6R9QcI,27047
 tdfs4ds/utils/info.py,sha256=sShnUxXMlvCtQ6xtShDhqdpTr6sMG0dZQhNBFgUENDY,12058
 tdfs4ds/utils/lineage.py,sha256=gy5M42qy5fvdWmlohAY3WPYoqAyp5VakeEmeT1YjrJQ,37839
-tdfs4ds/utils/query_management.py,sha256=nAcE8QY1GWAKgOtb-ubSfDVcnYbU7Ge8CruVRLoPtmY,6356
+tdfs4ds/utils/query_management.py,sha256=kWDeTdsYcbpV5Tyhh-8uLRWvXh16nIdXNIJ97w76aNU,4848
 tdfs4ds/utils/time_management.py,sha256=asIWvK5K81NNwAGqC-9Tv4Timscxyv0vyuPFs01whu0,31461
 tdfs4ds/utils/visualization.py,sha256=5S528KoKzzkrAdCxfy7ecyqKvAXBoibNvHwz_u5ISMs,23167
-tdfs4ds-0.2.4.38.dist-info/METADATA,sha256=pQ1JgtC75eThV0c0tnNXblLCvIhWz5GQHmCLDmX_de8,14326
-tdfs4ds-0.2.4.38.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-tdfs4ds-0.2.4.38.dist-info/top_level.txt,sha256=wMyVkMvnBn8RRt1xBveGQxOpWFijPMPkMiE7G2mi8zo,8
-tdfs4ds-0.2.4.38.dist-info/RECORD,,
+tdfs4ds-0.2.4.40.dist-info/METADATA,sha256=WBbjnL-uXkEPdrqrnEr78QZmRrs5E4h6XD8Ss50W_H0,14326
+tdfs4ds-0.2.4.40.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+tdfs4ds-0.2.4.40.dist-info/top_level.txt,sha256=wMyVkMvnBn8RRt1xBveGQxOpWFijPMPkMiE7G2mi8zo,8
+tdfs4ds-0.2.4.40.dist-info/RECORD,,