tdfs4ds 0.2.4.32__py3-none-any.whl → 0.2.4.34__py3-none-any.whl

tdfs4ds/feature_store/feature_store_management.py

@@ -9,6 +9,7 @@ import pandas as pd
 import tqdm
 import inspect
 import re
+from tdfs4ds import logger_safe, logger
 
 @execute_query_wrapper
 def feature_store_catalog_view_creation():
@@ -350,46 +351,47 @@ def register_features(entity_id, feature_names_types, primary_index = None, part
 
 def _register_features_merge(entity_id, feature_names_types, primary_index=None, partitioning=''):
     """
-    Registers or updates feature definitions in a Teradata database's feature catalog, associating entity identifiers
-    with feature names, types, and other metadata. This function prepares and executes SQL operations to insert new
-    feature definitions or update existing ones, considering partitioning strategies and primary index configurations.
-
-    Parameters:
-    - entity_id (dict): Specifies the entity's identifiers with keys representing attribute names. This dictionary
-                        is crucial for defining the scope and granularity of feature data.
-    - feature_names_types (dict): Maps feature names to their properties, including data types and unique identifiers.
-                                  Each value is a dictionary with keys 'type' and 'id' indicating the feature's data
-                                  type and a unique identifier, respectively.
-    - primary_index (list, optional): Identifies the primary index column(s) for the feature data. This influences
-                                      the organization and performance of database operations. If not specified,
-                                      defaults are used based on the entity_id structure.
-    - partitioning (str, optional): Describes the partitioning strategy through a string listing column names used
-                                    for partitioning. This can impact data storage and retrieval performance.
-
-    Returns:
-    pd.DataFrame: Contains details of the registered features, including names, types, IDs, and references to the
-                  respective feature store table and view names, alongside metadata about the entity and database schema.
-
-    Note:
-    - The function dynamically constructs SQL queries for inserting new features or updating existing ones in the
-      feature catalog, adapting to the provided partitioning and primary index settings.
-    - Assumes the existence of a Teradata feature catalog table in the specified schema and that the database connection
-      is correctly configured.
-    - Utilizes the tdfs4ds module for database schema configurations and valid-time temporal table considerations.
-
-    Example Usage:
-    >>> entity_id = {'customer_id': 'INTEGER'}
-    >>> feature_names_types = {'age': {'type': 'BIGINT', 'id': 1}, 'gender': {'type': 'VARCHAR_LATIN', 'id': 2}}
-    >>> registered_features = register_features(entity_id, feature_names_types)
-    >>> print(registered_features)
-
-    This example demonstrates registering features for an entity with attributes customer_id, age, and gender,
-    where age and gender features have specified types and unique IDs.
+    Register or update feature definitions in the feature catalog, with temporal support.
+
+    This function builds (or refreshes) entries in the Teradata feature catalog from a
+    mapping of feature names to their metadata, computes the target feature store table
+    and view names, stages the metadata to a temporary table, and executes a MERGE into
+    the catalog (with optional VALIDTIME support based on `tdfs4ds.FEATURE_STORE_TIME`).
+
+    Parameters
+    ----------
+    entity_id : dict[str, Any]
+        Mapping of entity-key column names to types. Only the keys (column names) are
+        required here; values are not used by this function.
+    feature_names_types : dict[str, dict]
+        Dict of feature name -> {"type": <SQL_TYPE>, "id": <int>} describing each
+        feature’s storage type and identifier in the catalog.
+    primary_index : list[str] | None, optional
+        Primary index column(s) to use when deriving the feature store table/view names.
+        If None, defaults are inferred by `get_feature_store_table_name`.
+    partitioning : str, optional
+        Partitioning expression or comma-separated column list used by
+        `get_feature_store_table_name`.
+
+    Returns
+    -------
+    pd.DataFrame
+        A dataframe of the features that were (up)registered, including:
+        FEATURE_NAME, FEATURE_TYPE, FEATURE_ID, FEATURE_TABLE, FEATURE_VIEW,
+        ENTITY_NAME, FEATURE_DATABASE, DATA_DOMAIN.
+
+    Notes
+    -----
+    - When `tdfs4ds.FEATURE_STORE_TIME is None`, uses CURRENT VALIDTIME (non-explicit start/end).
+      Otherwise uses `VALIDTIME PERIOD ('<FEATURE_STORE_TIME>', '<END_PERIOD>')` and adds
+      the valid-time start/end when inserting.
+    - Respects `tdfs4ds.DISPLAY_LOGS` via `logger_safe`.
     """
 
-    if tdfs4ds.FEATURE_STORE_TIME == None:
+    # --- VALIDTIME setup -----------------------------------------------------
+    if tdfs4ds.FEATURE_STORE_TIME is None:
         validtime_statement = 'CURRENT VALIDTIME'
-        validtime_start = 'CAST(CURRENT_TIME AS TIMESTAMP(0) WITH TIME ZONE)'
+        validtime_start = "CAST(CURRENT_TIME AS TIMESTAMP(0) WITH TIME ZONE)"
     else:
         validtime_statement = f"VALIDTIME PERIOD '({tdfs4ds.FEATURE_STORE_TIME},{tdfs4ds.END_PERIOD})'"
         validtime_start = f"CAST('{tdfs4ds.FEATURE_STORE_TIME}' AS TIMESTAMP(0) WITH TIME ZONE)"
@@ -399,154 +401,174 @@ def _register_features_merge(entity_id, feature_names_types, primary_index=None,
     else:
         end_period_ = tdfs4ds.END_PERIOD
 
-    if len(list(feature_names_types.keys())) == 0:
-        if tdfs4ds.DISPLAY_LOGS: print('no new feature to register')
+    # --- Input checks & early exit ------------------------------------------
+    if not feature_names_types:
+        logger_safe("info", "register_features: no new features to register")
         return
 
-    # Create a comma-separated string of entity IDs
-    entity_id_list = list(entity_id.keys())
-    entity_id_list.sort()
-    ENTITY_ID__ = ','.join([k for k in entity_id_list])
-
-    # Create a DataFrame from the feature_names_types dictionary
-    if len(feature_names_types.keys()) > 1:
-        df = pd.DataFrame(feature_names_types).transpose().reset_index()
-        df.columns = ['FEATURE_NAME', 'FEATURE_TYPE', 'FEATURE_ID']
-    else:
-        df = pd.DataFrame(columns=['FEATURE_NAME', 'FEATURE_TYPE', 'FEATURE_ID'])
-        k = list(feature_names_types.keys())[0]
-        df['FEATURE_NAME'] = [k]
-        df['FEATURE_TYPE'] = [feature_names_types[k]['type']]
-        df['FEATURE_ID'] = [feature_names_types[k]['id']]
-
-
+    # --- Entity columns (ordered, stable) -----------------------------------
+    entity_cols = sorted(list(entity_id.keys()))
+    ENTITY_ID__ = ",".join(entity_cols)
 
-    if tdfs4ds.DEBUG_MODE:
-        print('register_features', 'primary_index', primary_index)
-        print('register_features', 'partitioning', partitioning)
-        print('df', df)
-
-    # Generate the feature table and view names based on the entity ID and feature type
-    df['FEATURE_TABLE'] = df.apply(lambda row: get_feature_store_table_name(entity_id, row.iloc[1],
-                                                                            primary_index=primary_index,
-                                                                            partitioning=partitioning)[0],
-                                   axis=1)
-    df['FEATURE_VIEW'] = df.apply(lambda row: get_feature_store_table_name(entity_id, row.iloc[1],
-                                                                           primary_index=primary_index,
-                                                                           partitioning=partitioning)[1],
-                                  axis=1)
-
-    # Add additional columns to the DataFrame
-    df['ENTITY_NAME'] = ENTITY_ID__
-    df['FEATURE_DATABASE'] = tdfs4ds.SCHEMA
-    df['DATA_DOMAIN'] = tdfs4ds.DATA_DOMAIN
-
-    # Copy the DataFrame to a temporary table in Teradata
-    tdml.copy_to_sql(df, table_name='temp', schema_name=tdfs4ds.SCHEMA, if_exists='replace',
-                     primary_index='FEATURE_ID',
-                     types={'FEATURE_ID': tdml.BIGINT})
-
-
-
-    if tdfs4ds.DEBUG_MODE:
-        print("-----------_register_features_merge - df")
-        print(df)
-
-    if tdfs4ds.FEATURE_STORE_TIME == None:
+    # --- Build dataframe safely (no transpose tricks) ------------------------
+    rows = []
+    for fname, meta in feature_names_types.items():
+        try:
+            rows.append({
+                "FEATURE_NAME": fname,
+                "FEATURE_TYPE": meta["type"],
+                "FEATURE_ID":   meta["id"],
+            })
+        except KeyError as e:
+            logger_safe("error", "register_features: missing key %s in feature '%s' meta=%s", str(e), fname, meta)
+            raise
+
+    df = pd.DataFrame(rows, columns=["FEATURE_NAME", "FEATURE_TYPE", "FEATURE_ID"])
+
+    logger_safe(
+        "debug",
+        "register_features: features_count=%d | entity_cols=%s | primary_index=%s | partitioning=%s",
+        len(df),
+        entity_cols,
+        primary_index,
+        partitioning,
+    )
+
+    # --- Compute feature table & view names ---------------------------------
+    # Use apply to preserve original order; get_feature_store_table_name returns (table, view)
+    df["FEATURE_TABLE"] = df.apply(
+        lambda row: get_feature_store_table_name(
+            entity_id,
+            row["FEATURE_TYPE"],
+            primary_index=primary_index,
+            partitioning=partitioning
+        )[0],
+        axis=1
+    )
+    df["FEATURE_VIEW"] = df.apply(
+        lambda row: get_feature_store_table_name(
+            entity_id,
+            row["FEATURE_TYPE"],
+            primary_index=primary_index,
+            partitioning=partitioning
+        )[1],
+        axis=1
+    )
+
+    # --- Add catalog columns -------------------------------------------------
+    df["ENTITY_NAME"] = ENTITY_ID__
+    df["FEATURE_DATABASE"] = tdfs4ds.SCHEMA
+    df["DATA_DOMAIN"] = tdfs4ds.DATA_DOMAIN
+
+    # --- Stage to temp table -------------------------------------------------
+    tdml.copy_to_sql(
+        df,
+        table_name="temp",
+        schema_name=tdfs4ds.SCHEMA,
+        if_exists="replace",
+        primary_index="FEATURE_ID",
+        types={"FEATURE_ID": tdml.BIGINT},
+    )
+    logger_safe("debug", "register_features: staged %d rows to %s.temp", len(df), tdfs4ds.SCHEMA)
+
+    # --- Build MERGE statement ----------------------------------------------
+    if tdfs4ds.FEATURE_STORE_TIME is None:
+        # no explicit start/end in INSERT branch
         query_merge = f"""
          {validtime_statement}
-         MERGE INTO  {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
+         MERGE INTO {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
          USING (
              SELECT
-                CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
-            ,   A.FEATURE_NAME
-            ,   A.FEATURE_TYPE
-            ,   A.FEATURE_TABLE
-            ,   A.FEATURE_DATABASE
-            ,   A.FEATURE_VIEW
-            ,   A.ENTITY_NAME
-            ,   A.DATA_DOMAIN
-            FROM {tdfs4ds.SCHEMA}.temp A
-            LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
-            ON A.FEATURE_NAME = B.FEATURE_NAME
-            AND A.ENTITY_NAME = B.ENTITY_NAME -- modified
-            AND A.DATA_DOMAIN = B.DATA_DOMAIN
-             ) UPDATED_FEATURES
-         ON UPDATED_FEATURES.FEATURE_ID = EXISTING_FEATURES.FEATURE_ID
-         AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
-         AND UPDATED_FEATURES.DATA_DOMAIN = EXISTING_FEATURES.DATA_DOMAIN
-         WHEN MATCHED THEN
-             UPDATE
-             SET
-                FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE,
-                FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE,
-                FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE,
-                FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
-                --,ENTITY_NAME      = UPDATED_FEATURES.ENTITY_NAME -- modified
-         WHEN NOT MATCHED THEN
-             INSERT
+                   CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
+                 , A.FEATURE_NAME
+                 , A.FEATURE_TYPE
+                 , A.FEATURE_TABLE
+                 , A.FEATURE_DATABASE
+                 , A.FEATURE_VIEW
+                 , A.ENTITY_NAME
+                 , A.DATA_DOMAIN
+             FROM {tdfs4ds.SCHEMA}.temp A
+             LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
+               ON A.FEATURE_NAME = B.FEATURE_NAME
+              AND A.ENTITY_NAME = B.ENTITY_NAME
+              AND A.DATA_DOMAIN = B.DATA_DOMAIN
+         ) UPDATED_FEATURES
+           ON UPDATED_FEATURES.FEATURE_ID   = EXISTING_FEATURES.FEATURE_ID
+          AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
+          AND UPDATED_FEATURES.DATA_DOMAIN  = EXISTING_FEATURES.DATA_DOMAIN
+         WHEN MATCHED THEN UPDATE SET
+               FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE
+             , FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE
+             , FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE
+             , FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
+         WHEN NOT MATCHED THEN INSERT
              (  UPDATED_FEATURES.FEATURE_ID
-            ,   UPDATED_FEATURES.FEATURE_NAME
-            ,   UPDATED_FEATURES.FEATURE_TYPE
-            ,   UPDATED_FEATURES.FEATURE_TABLE
-            ,   UPDATED_FEATURES.FEATURE_DATABASE
-            ,   UPDATED_FEATURES.FEATURE_VIEW
-            ,   UPDATED_FEATURES.ENTITY_NAME
-            ,   UPDATED_FEATURES.DATA_DOMAIN
-            )
-         """
+              , UPDATED_FEATURES.FEATURE_NAME
+              , UPDATED_FEATURES.FEATURE_TYPE
+              , UPDATED_FEATURES.FEATURE_TABLE
+              , UPDATED_FEATURES.FEATURE_DATABASE
+              , UPDATED_FEATURES.FEATURE_VIEW
+              , UPDATED_FEATURES.ENTITY_NAME
+              , UPDATED_FEATURES.DATA_DOMAIN
+             );
+        """
     else:
+        # insert with explicit valid-time start/end
         query_merge = f"""
          {validtime_statement}
-         MERGE INTO  {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
+         MERGE INTO {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME} EXISTING_FEATURES
          USING (
              SELECT
-                CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
-            ,   A.FEATURE_NAME
-            ,   A.FEATURE_TYPE
-            ,   A.FEATURE_TABLE
-            ,   A.FEATURE_DATABASE
-            ,   A.FEATURE_VIEW
-            ,   A.ENTITY_NAME
-            ,   A.DATA_DOMAIN
-            FROM {tdfs4ds.SCHEMA}.temp A
-            LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
-            ON A.FEATURE_NAME = B.FEATURE_NAME
-            AND A.ENTITY_NAME = B.ENTITY_NAME -- modified
-            AND A.DATA_DOMAIN = B.DATA_DOMAIN
-             ) UPDATED_FEATURES
-         ON  UPDATED_FEATURES.FEATURE_ID = EXISTING_FEATURES.FEATURE_ID
-         AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
-         AND UPDATED_FEATURES.DATA_DOMAIN = EXISTING_FEATURES.DATA_DOMAIN
-         WHEN MATCHED THEN
-             UPDATE
-             SET
-                FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE,
-                FEATURE_TYPE    = UPDATED_FEATURES.FEATURE_TYPE,
-                FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE,
-                FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
-                --,ENTITY_NAME      = UPDATED_FEATURES.ENTITY_NAME -- modified
-         WHEN NOT MATCHED THEN
-             INSERT
+                   CASE WHEN B.FEATURE_ID IS NULL THEN A.FEATURE_ID ELSE B.FEATURE_ID END AS FEATURE_ID
+                 , A.FEATURE_NAME
+                 , A.FEATURE_TYPE
+                 , A.FEATURE_TABLE
+                 , A.FEATURE_DATABASE
+                 , A.FEATURE_VIEW
+                 , A.ENTITY_NAME
+                 , A.DATA_DOMAIN
+             FROM {tdfs4ds.SCHEMA}.temp A
+             LEFT JOIN {tdfs4ds.SCHEMA}.{tdfs4ds.FEATURE_CATALOG_NAME_VIEW} B
+               ON A.FEATURE_NAME = B.FEATURE_NAME
+              AND A.ENTITY_NAME = B.ENTITY_NAME
+              AND A.DATA_DOMAIN = B.DATA_DOMAIN
+         ) UPDATED_FEATURES
+           ON UPDATED_FEATURES.FEATURE_ID   = EXISTING_FEATURES.FEATURE_ID
+          AND UPDATED_FEATURES.FEATURE_NAME = EXISTING_FEATURES.FEATURE_NAME
+          AND UPDATED_FEATURES.DATA_DOMAIN  = EXISTING_FEATURES.DATA_DOMAIN
+         WHEN MATCHED THEN UPDATE SET
+               FEATURE_TABLE    = UPDATED_FEATURES.FEATURE_TABLE
+             , FEATURE_TYPE     = UPDATED_FEATURES.FEATURE_TYPE
+             , FEATURE_DATABASE = UPDATED_FEATURES.FEATURE_DATABASE
+             , FEATURE_VIEW     = UPDATED_FEATURES.FEATURE_VIEW
+         WHEN NOT MATCHED THEN INSERT
              (  UPDATED_FEATURES.FEATURE_ID
-            ,   UPDATED_FEATURES.FEATURE_NAME
-            ,   UPDATED_FEATURES.FEATURE_TYPE
-            ,   UPDATED_FEATURES.FEATURE_TABLE
-            ,   UPDATED_FEATURES.FEATURE_DATABASE
-            ,   UPDATED_FEATURES.FEATURE_VIEW
-            ,   UPDATED_FEATURES.ENTITY_NAME
-            ,   UPDATED_FEATURES.DATA_DOMAIN,
-             {validtime_start},
-             '{end_period_}')
-         """
+              , UPDATED_FEATURES.FEATURE_NAME
+              , UPDATED_FEATURES.FEATURE_TYPE
+              , UPDATED_FEATURES.FEATURE_TABLE
+              , UPDATED_FEATURES.FEATURE_DATABASE
+              , UPDATED_FEATURES.FEATURE_VIEW
+              , UPDATED_FEATURES.ENTITY_NAME
+              , UPDATED_FEATURES.DATA_DOMAIN
+              , {validtime_start}
+              , '{end_period_}'
+             );
+        """
 
-    if tdfs4ds.DEBUG_MODE:
-        print("-----------_register_features_merge - query_merge")
-        print(query_merge)
-    # Execute the update and insert queries
+    logger_safe("debug", "register_features: merge_sql_preview=%s", " ".join(query_merge.split())[:400] + " ...")
+
+    # --- Execute MERGE -------------------------------------------------------
     execute_query(query_merge)
+    logger_safe(
+        "info",
+        "register_features: merged %d features into %s.%s",
+        len(df),
+        tdfs4ds.SCHEMA,
+        tdfs4ds.FEATURE_CATALOG_NAME,
+    )
 
     return df
+
 def _register_features_update_insert(entity_id, feature_names_types, primary_index = None, partitioning = ''):
     """
     Registers or updates feature definitions in a Teradata database's feature catalog, associating entity identifiers

tdfs4ds/process_store/process_query_administration.py

@@ -28,7 +28,7 @@ def list_processes():
         return tdml.DataFrame(tdml.in_schema(tdfs4ds.SCHEMA, tdfs4ds.PROCESS_CATALOG_NAME_VIEW))
     except Exception as e:
         print(str(e))
-        print(query)
+        print(tdml.DataFrame(tdml.in_schema(tdfs4ds.SCHEMA, tdfs4ds.PROCESS_CATALOG_NAME_VIEW)).show_query())
 
 def list_processes_feature_split():
     """

tdfs4ds/process_store/process_registration_management.py

@@ -3,6 +3,7 @@ import tdfs4ds
 from tdfs4ds.utils.query_management import execute_query_wrapper
 import uuid
 import json
+from tdfs4ds import logger,logger_safe
 
 @execute_query_wrapper
 def register_process_view(view_name, entity_id, feature_names, metadata={}, entity_null_substitute = {}, **kwargs):
@@ -74,80 +75,91 @@ def _register_process_view_merge(view_name, entity_id, feature_names, metadata={
     - Requires 'tdml' module for DataFrame operations and 'uuid' for generating unique identifiers.
     """
 
-
-    # Handling the case where the view name is provided as a DataFrame
-    if type(view_name) == tdml.dataframe.dataframe.DataFrame:
+    # Handle teradataml DataFrame input
+    if isinstance(view_name, tdml.dataframe.dataframe.DataFrame):
         try:
             view_name = view_name._table_name
-        except:
-            print(
-                'create your teradata dataframe using tdml.DataFrame(<view name>). Crystallize your view if needed')
+        except Exception:
+            logger_safe(
+                "error",
+                "Invalid DataFrame for view registration. Use: tdml.DataFrame(<table/view>). Crystallize if needed."
+            )
             raise
 
+    # Prevent using temporary teradataml views
     if view_name.split('.')[1].startswith('ml__'):
-        tdfs4ds.logger.error('Your dataframe is a temporary teradataml dataframe. Please crystallize your view first.')
-        raise ValueError("Invalid process view name: it starts with 'ml__'. Please consider view crystallization")
-
-    # Get filter manager:
+        logger_safe(
+            "error",
+            "Invalid view name '%s': starts with 'ml__'. Please crystallize your view first.",
+            view_name
+        )
+        raise ValueError("Invalid process view name: temporary teradataml views are not allowed.")
+
+    # Get optional arguments
     filtermanager = kwargs.get('filtermanager', None)
-    if filtermanager is None:
-        query_upsert_filtermanager = None
-
-    # Get data distribution related inputs:
-    primary_index = kwargs.get('primary_index', [e for e in entity_id.keys()])
+    query_upsert_filtermanager = None
+    primary_index = kwargs.get('primary_index', list(entity_id.keys()))
     partitioning = kwargs.get('partitioning', '').replace("'", '"')
 
     if primary_index is None:
-        primary_index = [e for e in entity_id.keys()]
+        primary_index = list(entity_id.keys())
 
+    feature_names = ','.join(feature_names)
 
+    # Validtime period
+    end_period_ = '9999-01-01 00:00:00' if tdfs4ds.END_PERIOD == 'UNTIL_CHANGED' else tdfs4ds.END_PERIOD
+    validtime_statement = (
+        'CURRENT VALIDTIME'
+        if tdfs4ds.FEATURE_STORE_TIME is None
+        else f"VALIDTIME PERIOD '({tdfs4ds.FEATURE_STORE_TIME},{end_period_})'"
+    )
 
-    # Joining the feature names into a comma-separated string
-    feature_names = ','.join(feature_names)
+    logger_safe("info", "Registering process view: %s", view_name)
 
-    # Setting the end period for the view
-    if tdfs4ds.END_PERIOD == 'UNTIL_CHANGED':
-        end_period_ = '9999-01-01 00:00:00'
-    else:
-        end_period_ = tdfs4ds.END_PERIOD
+    # Check if view already exists in catalog
+    query_process_id = f"""
+        SEL PROCESS_ID FROM {tdfs4ds.SCHEMA}.{tdfs4ds.PROCESS_CATALOG_NAME_VIEW}
+        WHERE view_name = '{view_name}'
+    """
+    process_id_result = tdml.execute_sql(query_process_id).fetchall()
 
-    if tdfs4ds.FEATURE_STORE_TIME == None:
-        validtime_statement = 'CURRENT VALIDTIME'
-    else:
-        validtime_statement = f"VALIDTIME PERIOD '({tdfs4ds.FEATURE_STORE_TIME},{end_period_})'"
+    if process_id_result:
+        process_id = process_id_result[0][0]
+        logger_safe("info", "Updating existing process_id=%s", process_id)
 
+        query_feature_version = f"""
+            SEL PROCESS_VERSION FROM {tdfs4ds.SCHEMA}.{tdfs4ds.PROCESS_CATALOG_NAME_VIEW}
+            WHERE view_name = '{view_name}'
+        """
+        feature_version = tdml.execute_sql(query_feature_version).fetchall()[0][0]
 
-    query_process_id = f"SEL PROCESS_ID FROM {tdfs4ds.SCHEMA}.{tdfs4ds.PROCESS_CATALOG_NAME_VIEW} WHERE view_name = '{view_name}'"
-    process_id = tdml.execute_sql(query_process_id).fetchall()
-    if len(process_id)>0:
-        process_id            = process_id[0][0]
-        query_feature_version = f"SEL PROCESS_VERSION FROM {tdfs4ds.SCHEMA}.{tdfs4ds.PROCESS_CATALOG_NAME_VIEW} WHERE view_name = '{view_name}'"
-        feature_version       = tdml.execute_sql(query_feature_version).fetchall()[0][0]
-        query_primary_index   = f"SEL FOR_PRIMARY_INDEX, FOR_DATA_PARTITIONING FROM {tdfs4ds.SCHEMA}.{tdfs4ds.DATA_DISTRIBUTION_NAME} WHERE process_id = '{process_id}'"
-        query_primary_index_res = tdml.execute_sql(query_primary_index).fetchall()
-        if len(query_primary_index_res)>0:
-            FOR_PRIMARY_INDEX, FOR_DATA_PARTITIONING = tdml.execute_sql(query_primary_index).fetchall()[0]
+        query_primary_index = f"""
+            SEL FOR_PRIMARY_INDEX, FOR_DATA_PARTITIONING
+            FROM {tdfs4ds.SCHEMA}.{tdfs4ds.DATA_DISTRIBUTION_NAME}
+            WHERE process_id = '{process_id}'
+        """
+        dist_res = tdml.execute_sql(query_primary_index).fetchall()
+        if dist_res:
+            FOR_PRIMARY_INDEX, FOR_DATA_PARTITIONING = dist_res[0]
         else:
-            raise ValueError(f"""
-                There is not information on primary index and partitioning for process: {process_id}.
-                The working date is: {validtime_statement}
-                The content of the distribution table is:
-                {print(tdml.DataFrame.from_query(f"SEL * FROM {tdfs4ds.SCHEMA}.{tdfs4ds.DATA_DISTRIBUTION_NAME} WHERE process_id = '{process_id}'"))}
-            """)
+            logger_safe(
+                "error",
+                "Missing data distribution info for existing process %s. Check distribution table.",
+                process_id
+            )
+            raise ValueError("Missing distribution info.")
     else:
-        # Generating a unique process identifier
         process_id = str(uuid.uuid4())
         feature_version = 1
         FOR_PRIMARY_INDEX = ",".join(primary_index)
         FOR_DATA_PARTITIONING = partitioning
+        logger_safe("info", "Generated new process_id=%s", process_id)
 
-    # Create a comma-separated string of entity IDs
-    entity_id_list = list(entity_id.keys())
-    entity_id_list.sort()
-    ENTITY_ID__ = ','.join([k for k in entity_id_list])
+    # Build entity_id string
+    ENTITY_ID__ = ','.join(sorted(entity_id.keys()))
+    logger_safe("debug", "Entity IDs: %s", ENTITY_ID__)
+    logger_safe("debug", "Feature names: %s", feature_names)
 
-    print('feature_version :',feature_version)
-    print('int(feature_version) :', int(feature_version))
     if tdfs4ds.FEATURE_STORE_TIME == None:
 
 
@@ -402,16 +414,16 @@ def _register_process_view_merge(view_name, entity_id, feature_names, metadata={
             """
 
 
-    # Logging the process registration
-    print(f'register process with id : {process_id}')
-    print(f"to run the process again just type : run(process_id='{process_id}')")
-    print(f"to update your dataset : dataset = run(process_id='{process_id}',return_dataset=True)")
+    logger_safe("info", "Process registered: process_id=%s", process_id)
+    logger_safe("info", "To rerun: run(process_id='%s')", process_id)
+    logger_safe("info", "To build dataset: dataset = run(process_id='%s', return_dataset=True)", process_id)
 
-    #print('query_insert_dist', query_upsert_dist)
+    # Return queries
     if kwargs.get('with_process_id'):
         return query_upsert, process_id, query_upsert_dist, query_upsert_filtermanager
     else:
         return query_upsert, query_upsert_dist, query_upsert_filtermanager
+    
 @execute_query_wrapper
 def _register_process_view_update_insert(view_name, entity_id, feature_names, metadata={}, entity_null_substitute={}, **kwargs):
     """