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

tdfs4ds/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.2.4.39'
+__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/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-0.2.4.39.dist-info → tdfs4ds-0.2.4.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tdfs4ds
-Version: 0.2.4.39
+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.39.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=u0hoIQLWP7mLjqLJdGuyVtoxfKl-4mps8bVc5_c3EnI,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
@@ -21,18 +21,18 @@ tdfs4ds/feature_store/feature_data_processing.py,sha256=gjwypiTfwTyGyrP20v35Vu2u
 tdfs4ds/feature_store/feature_query_retrieval.py,sha256=51c6ZNlLFiBIxNPinS8ot8bjWEIb1QV2eVg69yzVF80,35381
 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=kWDeTdsYcbpV5Tyhh-8uLRWvXh16nIdXNIJ97w76aNU,4848
 tdfs4ds/utils/time_management.py,sha256=asIWvK5K81NNwAGqC-9Tv4Timscxyv0vyuPFs01whu0,31461
 tdfs4ds/utils/visualization.py,sha256=5S528KoKzzkrAdCxfy7ecyqKvAXBoibNvHwz_u5ISMs,23167
-tdfs4ds-0.2.4.39.dist-info/METADATA,sha256=X-V3kUdNWlXm7SKllAbGKQ2yAeHfw1da7pK_METpB-Q,14326
-tdfs4ds-0.2.4.39.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-tdfs4ds-0.2.4.39.dist-info/top_level.txt,sha256=wMyVkMvnBn8RRt1xBveGQxOpWFijPMPkMiE7G2mi8zo,8
-tdfs4ds-0.2.4.39.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,,