cloe-nessy 1.0.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

cloe_nessy/integration/reader/excel_reader.py

@@ -160,7 +160,7 @@ class ExcelDataFrameReader(BaseReader):
             "__metadata",
             F.create_map(
                 F.lit("timestamp"),
-                F.current_timestamp(),
+                F.current_timestamp().cast("string"),
                 F.lit("file_location"),
                 F.lit(location),
                 F.lit("sheet_name"),

cloe_nessy/integration/reader/file_reader.py

@@ -192,7 +192,8 @@ class FileReader(BaseReader):
         """Add all metadata columns to the DataFrame."""
         metadata_columns = df.select("_metadata.*").columns
 
-        entries = [(F.lit(field), F.col(f"_metadata.{field}")) for field in metadata_columns]
+        # Cast all metadata values to strings to ensure type consistency in the map
+        entries = [(F.lit(field), F.col(f"_metadata.{field}").cast("string")) for field in metadata_columns]
         flat_list = [item for tup in entries for item in tup]
 
         df = df.withColumn("__metadata", F.create_map(flat_list))

cloe_nessy/integration/writer/delta_writer/delta_merge_writer.py

@@ -29,6 +29,9 @@ class DeltaMergeConfig(BaseModel):
         use_partition_pruning: Flag to specify whether to use partition
             pruning to optimize the performance of the merge operation.
         partition_by: List of column names to partition by.
+        column_mapping: Mapping from target column names to source column names.
+            If a column is not in the mapping, it's assumed to have the same name
+            in both source and target.
     """
 
     dataframe_columns: list[str]
@@ -39,6 +42,7 @@ class DeltaMergeConfig(BaseModel):
     when_not_matched_insert: bool = True
     use_partition_pruning: bool = True
     partition_by: list[str] = Field(default_factory=list)
+    column_mapping: dict[str, str] = Field(default_factory=dict)
     cols_to_merge: list[str] = Field(default_factory=list, alias="_cols_to_merge")
     cols_to_update: set[str] = Field(default_factory=set, alias="_cols_to_update")
     cols_to_insert: set[str] = Field(default_factory=set, alias="_cols_to_insert")
@@ -58,11 +62,20 @@ class DeltaMergeConfig(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def _validate_key_columns(cls, config: Any):
-        """Key columns must exist in the data frame."""
+        """Key columns must exist in the data frame (considering column mapping)."""
         key_columns = config.get("key_columns")
         dataframe_columns = config.get("dataframe_columns")
-        if not set(key_columns).issubset(set(dataframe_columns)):
-            raise ValueError("Key columns must exist in the DataFrame columns.")
+        column_mapping = config.get("column_mapping", {})
+
+        # For each key column (target name), find the corresponding source column
+        missing_columns = []
+        for key_col in key_columns:
+            source_col = column_mapping.get(key_col, key_col)
+            if source_col not in dataframe_columns:
+                missing_columns.append(f"{key_col} (maps to {source_col})" if key_col != source_col else key_col)
+
+        if missing_columns:
+            raise ValueError(f"Key columns must exist in the DataFrame. Missing columns: {', '.join(missing_columns)}")
         return config
 
     @model_validator(mode="before")
@@ -70,15 +83,37 @@ class DeltaMergeConfig(BaseModel):
     def _derive_merge_columns(cls, config: Any):
         """Derive update and insert columns from the DataFrame columns."""
         dataframe_columns = config.get("dataframe_columns", [])
-        config["_cols_to_merge"] = list(set(dataframe_columns))
+        column_mapping = config.get("column_mapping", {})
+
+        # Build reverse mapping: source_col -> target_col
+        reverse_mapping = {v: k for k, v in column_mapping.items()}
+
+        # Determine which target columns we're working with
+        # For each dataframe column, find its corresponding target column
+        target_columns = []
+        for df_col in dataframe_columns:
+            target_col = reverse_mapping.get(df_col, df_col)
+            target_columns.append(target_col)
+
+        config["_cols_to_merge"] = list(set(target_columns))
+
         if config.get("cols_to_exclude_from_update"):
             config["_cols_to_update"] = set(config["_cols_to_merge"]) - set(config["cols_to_exclude_from_update"])
         else:
             config["_cols_to_update"] = set(config["_cols_to_merge"])
 
         config["_cols_to_insert"] = config["_cols_to_merge"]
-        config["final_cols_to_update"] = {col: f"source.{col}" for col in config["_cols_to_update"]}
-        config["final_cols_to_insert"] = {col: f"source.{col}" for col in config["_cols_to_insert"]}
+
+        # Build final mappings using column_mapping (target -> source)
+        # For each target column, find the corresponding source column
+        config["final_cols_to_update"] = {
+            target_col: f"source.`{column_mapping.get(target_col, target_col)}`"
+            for target_col in config["_cols_to_update"]
+        }
+        config["final_cols_to_insert"] = {
+            target_col: f"source.`{column_mapping.get(target_col, target_col)}`"
+            for target_col in config["_cols_to_insert"]
+        }
         return config
 
     @model_validator(mode="after")
@@ -127,7 +162,7 @@ class DeltaMergeWriter(BaseDeltaWriter):
 
     def _build_match_conditions(self, data_frame: DataFrame, config: DeltaMergeConfig) -> str:
         """Builds match conditions for the Delta table merge."""
-        match_conditions = self._merge_match_conditions(config.key_columns)
+        match_conditions = self._merge_match_conditions_with_mapping(config.key_columns, config.column_mapping)
         if config.use_partition_pruning:
             match_conditions_list = [match_conditions] + [
                 self._partition_pruning_conditions(data_frame, config.partition_by),
@@ -169,6 +204,11 @@ class DeltaMergeWriter(BaseDeltaWriter):
         function also supports partition pruning to optimize the performance of
         the merge operation.
 
+        When source and target tables have different column names, use the
+        `column_mapping` parameter to map target column names to source column names.
+        For any columns not in the mapping, the same name is assumed for both source
+        and target.
+
         Args:
             table: The Table object representing the Delta table.
             table_identifier: The identifier of the Delta table in the format
@@ -178,7 +218,16 @@ class DeltaMergeWriter(BaseDeltaWriter):
             ignore_empty_df: A flag indicating whether to ignore an empty source
                 dataframe.
             kwargs: Passed to the
-                [`DeltaMergeConfig`][cloe_nessy.integration.writer.delta_merge_writer.DeltaMergeConfig].
+                [`DeltaMergeConfig`][cloe_nessy.integration.writer.delta_writer.delta_merge_writer.DeltaMergeConfig].
+                Common kwargs include:
+                - key_columns: List of target column names to use as merge keys.
+                - column_mapping: Dict mapping target column names to source column names.
+                - when_matched_update: Whether to update matching records.
+                - when_matched_delete: Whether to delete matching records.
+                - when_not_matched_insert: Whether to insert non-matching records.
+                - cols_to_exclude_from_update: Target columns to exclude from updates.
+                - use_partition_pruning: Whether to use partition pruning.
+                - partition_by: List of partition columns.
 
         Raises:
             ValueError: If both, table and table_identifier or storage_path are provided.
@@ -189,6 +238,21 @@ class DeltaMergeWriter(BaseDeltaWriter):
                 merge operation.
             ValueError: If partition columns are not specified when using
                 partition pruning.
+
+        Example:
+            ```python
+            # Merge with different column names
+            writer.write(
+                data_frame=source_df,
+                table=target_table,
+                key_columns=["customer_id"],
+                column_mapping={
+                    "customer_id": "cust_id",
+                    "full_name": "name",
+                    "email_address": "email"
+                }
+            )
+            ```
         """
         if self._empty_dataframe_check(data_frame, ignore_empty_df):
             return

cloe_nessy/integration/writer/delta_writer/delta_writer_base.py

@@ -150,6 +150,42 @@ class BaseDeltaWriter(BaseWriter, ABC):
         """
         return " AND ".join([f"target.`{c}` <=> source.`{c}`" for c in columns])
 
+    @staticmethod
+    def _merge_match_conditions_with_mapping(
+        key_columns: list[str], column_mapping: dict[str, str] | None = None
+    ) -> str:
+        """Merges match conditions with support for column name mapping.
+
+        This function generates SQL match conditions for merging tables where source and target
+        columns may have different names.
+
+        Args:
+            key_columns: A list of target column names to use as keys for the merge operation.
+            column_mapping: A dictionary mapping target column names to source column names.
+                If None or empty, assumes source and target columns have the same names.
+
+        Returns:
+            A string containing the match conditions, separated by " AND "
+
+        Example:
+            ```python
+            # Without mapping (same column names):
+            _merge_match_conditions_with_mapping(["id", "customer_id"])
+            # "target.`id` <=> source.`id` AND target.`customer_id` <=> source.`customer_id`"
+
+            # With mapping (different column names):
+            _merge_match_conditions_with_mapping(
+                ["id", "customer_id"],
+                {"customer_id": "cust_id"}
+            )
+            # "target.`id` <=> source.`id` AND target.`customer_id` <=> source.`cust_id`"
+            ```
+        """
+        mapping = column_mapping or {}
+        return " AND ".join(
+            [f"target.`{target_col}` <=> source.`{mapping.get(target_col, target_col)}`" for target_col in key_columns]
+        )
+
     @staticmethod
     def _partition_pruning_conditions(df: "DataFrame", partition_cols: list[str] | None) -> str:
         """Generates partition pruning conditions for an SQL query.

cloe_nessy/pipeline/actions/__init__.py

@@ -19,6 +19,7 @@ from .transform_group_aggregate import TransformGroupAggregate
 from .transform_hash_columns import TransformHashColumnsAction
 from .transform_join import TransformJoinAction
 from .transform_json_normalize import TransformJsonNormalize
+from .transform_regex_extract import TransformRegexExtract
 from .transform_rename_columns import TransformRenameColumnsAction
 from .transform_replace_values import TransformReplaceValuesAction
 from .transform_select_columns import TransformSelectColumnsAction
@@ -56,6 +57,7 @@ __all__ = [
     "TransformGroupAggregate",
     "TransformJoinAction",
     "TransformJsonNormalize",
+    "TransformRegexExtract",
     "TransformRenameColumnsAction",
     "TransformReplaceValuesAction",
     "TransformSelectColumnsAction",

cloe_nessy/pipeline/actions/transform_regex_extract.py

@@ -0,0 +1,169 @@
+import re
+from typing import Any
+
+import pyspark.sql.functions as F
+
+from cloe_nessy.pipeline.pipeline_action import PipelineAction
+from cloe_nessy.pipeline.pipeline_context import PipelineContext
+
+
+class TransformRegexExtract(PipelineAction):
+    r"""Extract values from a specified column in a DataFrame using regex patterns.
+
+    This action extracts values from a column based on a regex pattern and stores
+    the result in a new column. Optionally, you can replace the matched pattern in
+    the original column with a different string, remove the original column, or add
+    a boolean column indicating which rows matched the pattern.
+
+    Example:
+        ```yaml
+        Extract Action:
+            action: TRANSFORM_REGEX_EXTRACT
+            options:
+                source_column_name: Email
+                extract_column_name: org_domain
+                pattern: (?<=@)([A-Za-z0-9-]+)
+                replace_by: exampledomain.org
+        ```
+
+    This action also supports processing multiple columns simultaneously. To use this
+    functionality, structure the configuration as a dictionary mapping each source
+    column name to its extraction parameters.
+
+    Example:
+        ```yaml
+        Extract Action:
+            action: TRANSFORM_REGEX_EXTRACT
+            options:
+                extract_columns:
+                    Name:
+                        pattern: (?<=\w+) (\w+)
+                        replace_by: ''
+                        extract_column_name: last_name
+                        match_info_column_name: has_last_name
+                    Email:
+                        pattern: @\w+\.\w+
+                        extract_column_name: domain
+                        keep_original_column: False
+        ```
+
+    """
+
+    name: str = "TRANSFORM_REGEX_EXTRACT"
+
+    def run(
+        self,
+        context: PipelineContext,
+        source_column_name: str = "",
+        extract_column_name: str = "",
+        pattern: str = "",
+        keep_original_column: bool = True,
+        replace_by: str = "",
+        match_info_column_name: str = "",
+        extract_columns: dict | None = None,
+        **_: Any,
+    ) -> PipelineContext:
+        """Performs a regex extract (and replace) on a specified column in a DataFrame.
+
+        This function performs a regex extract (and optionally a replace) on one or more columns.
+
+        Args:
+            context: The context in which this action is executed.
+            source_column_name: Column name to perform the regex replace on.
+            pattern: Regex pattern to match.
+            replace_by: String that should replace the extracted pattern in the source column.
+            extract_column_name: Column name to store the extract, default: <source_column_name>_extract
+            keep_original_column: Whether to keep the original column, default: True
+            match_info_column_name: Column name to store a boolean column whether a match was found, default: None
+            extract_columns: Dictionary of column names and their corresponding 1-column-case.
+
+        Raises:
+            ValueError: If any of the required arguments are not provided.
+            ValueError: If the regex pattern is invalid.
+
+        Returns:
+            PipelineContext: Transformed context with the modified DataFrame.
+        """
+        if context.data is None:
+            raise ValueError("Data from the context is required for the operation.")
+        if not extract_columns and not source_column_name:
+            raise ValueError("Either extract_columns or source_column_name must be provided.")
+
+        df = context.data
+
+        if source_column_name:
+            self._console_logger.info(f"Extracting from column '{source_column_name}' using pattern: {pattern}")
+            df = self._process_one_column(
+                df,
+                source_column_name,
+                pattern,
+                extract_column_name,
+                replace_by,
+                keep_original_column,
+                match_info_column_name,
+            )
+
+        elif isinstance(extract_columns, dict):
+            self._console_logger.info(f"Extracting from {len(extract_columns)} columns")
+            for one_source_column_name in extract_columns:
+                parameter_dict = self._get_default_dict() | extract_columns[one_source_column_name]
+                df = self._process_one_column(df, one_source_column_name, **parameter_dict)
+
+        else:
+            raise ValueError("extract_columns must be a dictionary. See documentation for proper format.")
+
+        return context.from_existing(data=df)
+
+    def _process_one_column(
+        self,
+        df,
+        source_column_name,
+        pattern,
+        extract_column_name,
+        replace_by,
+        keep_original_column,
+        match_info_column_name,
+    ):
+        # Extract the first captured group (group 0 is the entire match)
+        matched_group_id = 0
+
+        if not extract_column_name:
+            extract_column_name = f"{source_column_name}_extracted"
+
+        if not pattern:
+            raise ValueError(f"The regex pattern (pattern) for column {source_column_name} must be provided.")
+
+        # Validate regex pattern
+        try:
+            re.compile(pattern)
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern '{pattern}' for column {source_column_name}: {e}") from e
+
+        df = df.withColumn(extract_column_name, F.regexp_extract(source_column_name, pattern, matched_group_id))
+
+        if replace_by:
+            df = df.withColumn(source_column_name, F.regexp_replace(source_column_name, pattern, replace_by))
+
+        if match_info_column_name:
+            # Check if extraction is null or empty string
+            df = df.withColumn(
+                match_info_column_name,
+                F.when((F.col(extract_column_name).isNull()) | (F.col(extract_column_name) == ""), False).otherwise(
+                    True
+                ),
+            )
+
+        if not keep_original_column:
+            df = df.drop(source_column_name)
+
+        return df
+
+    def _get_default_dict(self) -> dict[str, Any]:
+        """Return default parameters for single column extraction."""
+        return {
+            "pattern": "",
+            "extract_column_name": "",
+            "replace_by": "",
+            "keep_original_column": True,
+            "match_info_column_name": "",
+        }

cloe_nessy/pipeline/actions/write_delta_merge.py

@@ -13,6 +13,7 @@ class WriteDeltaMergeAction(PipelineAction):
 
     Example:
         ```yaml
+        # Basic merge with same column names
         Write Delta Merge:
             action: WRITE_DELTA_MERGE
             options:
@@ -20,13 +21,25 @@ class WriteDeltaMergeAction(PipelineAction):
                 key_columns:
                     - id
                     - customer_id
-                cols_to_update:
-                    - name
-                    - email
-                    - updated_at
+                cols_to_exclude_from_update:
+                    - created_at
                 when_matched_update: true
                 when_not_matched_insert: true
                 use_partition_pruning: true
+
+        # Merge with different source and target column names
+        Write Delta Merge with Mapping:
+            action: WRITE_DELTA_MERGE
+            options:
+                table_identifier: my_catalog.my_schema.my_table
+                key_columns:
+                    - customer_id
+                column_mapping:
+                    customer_id: cust_id
+                    full_name: name
+                    email_address: email
+                when_matched_update: true
+                when_not_matched_insert: true
         ```
     """
 
@@ -38,11 +51,10 @@ class WriteDeltaMergeAction(PipelineAction):
         *,
         table_identifier: str | None = None,
         key_columns: list[str] | None = None,
-        cols_to_update: list[str] | None = None,
-        cols_to_insert: list[str] | None = None,
-        cols_to_exclude: list[str] | None = None,
+        cols_to_exclude_from_update: list[str] | None = None,
+        column_mapping: dict[str, str] | None = None,
         when_matched_update: bool = True,
-        when_matched_deleted: bool = False,
+        when_matched_delete: bool = False,
         when_not_matched_insert: bool = True,
         use_partition_pruning: bool = True,
         ignore_empty_df: bool = False,
@@ -57,23 +69,23 @@ class WriteDeltaMergeAction(PipelineAction):
             table_identifier: The identifier of the table. If passed, the
                 UC Adapter will be used to create a table object. Otherwise the Table
                 object will be created from the table metadata in the context.
-            key_columns: List of column names that form the
+            key_columns: List of target column names that form the
                 key for the merge operation.
+            cols_to_exclude_from_update: List of target column names to be
+                excluded from the update operation in the target Delta table.
+            column_mapping: Mapping from target column names to source column names.
+                Use this when source and target tables have different column names.
+                If a column is not in the mapping, it's assumed to have the same name
+                in both source and target.
             when_matched_update: Flag to specify whether to
-                perform an update operation whenmatching records are found in
+                perform an update operation when matching records are found in
                 the target Delta table.
-            when_matched_deleted: Flag to specify whether to
+            when_matched_delete: Flag to specify whether to
                 perform a delete operation when matching records are found in
                 the target Delta table.
             when_not_matched_insert: Flag to specify whether to perform an
                 insert operation when matching records are not found in the target
                 Delta table.
-            cols_to_update: List of column names to be
-                updated in the target Delta table.
-            cols_to_insert: List of column names to be
-                inserted into the target Delta table.
-            cols_to_exclude: List of column names to be
-                excluded from the merge operation.
             use_partition_pruning: Flag to specify whether to use partition
                 pruning to optimize the performance of the merge operation.
             ignore_empty_df: A flag indicating whether to ignore an empty source dataframe.
@@ -113,16 +125,15 @@ class WriteDeltaMergeAction(PipelineAction):
         assert key_columns is not None, "Key columns must be provided."
 
         delta_merge_writer.write(
-            table_identifier=context.table_metadata.identifier,
+            data_frame=context.data,
             table=context.table_metadata,
+            table_identifier=context.table_metadata.identifier,
             storage_path=str(context.table_metadata.storage_path),
-            data_frame=context.data,
             key_columns=key_columns,
-            cols_to_update=cols_to_update,
-            cols_to_insert=cols_to_insert,
-            cols_to_exclude=cols_to_exclude,
+            cols_to_exclude_from_update=cols_to_exclude_from_update or [],
+            column_mapping=column_mapping or {},
             when_matched_update=when_matched_update,
-            when_matched_deleted=when_matched_deleted,
+            when_matched_delete=when_matched_delete,
             when_not_matched_insert=when_not_matched_insert,
             use_partition_pruning=use_partition_pruning,
             partition_by=context.table_metadata.partition_by,

{cloe_nessy-1.0.0.dist-info → cloe_nessy-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloe-nessy
-Version: 1.0.0
+Version: 1.0.3
 Summary: Your friendly datalake monster.
 Project-URL: homepage, https://initions.com/
 Author-email: initions <ICSMC_EXT_PYPIORG@accenture.com>
@@ -12,7 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Database
-Requires-Python: <3.13,>=3.11
+Requires-Python: <3.14,>=3.11
 Requires-Dist: azure-identity<2.0.0,>=1.19.0
 Requires-Dist: cloe-logging[databricks,log-analytics]<0.4,>=0.3.8
 Requires-Dist: databricks-sdk<1.0.0,>=0.36.0

{cloe_nessy-1.0.0.dist-info → cloe_nessy-1.0.3.dist-info}/RECORD

@@ -30,9 +30,9 @@ cloe_nessy/integration/delta_loader/strategies/delta_timestamp_loader.py,sha256=
 cloe_nessy/integration/reader/__init__.py,sha256=NWQx-v6aKE8YOHhsxfeaZnMVq4KLKyRWXzUduf5aVsk,265
 cloe_nessy/integration/reader/api_reader.py,sha256=FbOyfLVG1ryL2GC-MgE1uClHICsQKBj9yZbY4TG5qrk,19637
 cloe_nessy/integration/reader/catalog_reader.py,sha256=DlnykmFjV_v8SCBh3qaCvf24QM-6TdMFVHx5Mqv7Nvs,4850
-cloe_nessy/integration/reader/excel_reader.py,sha256=JGmxQ16ux0HT-MLvAUp-9XMdKUToMb7cdObciZNsYSs,8027
+cloe_nessy/integration/reader/excel_reader.py,sha256=QXm0MaE_-tW5ix-f_3Pgn-Vx7VG5jA_uSp858rVV7lA,8042
 cloe_nessy/integration/reader/exceptions.py,sha256=_A9jFpe_RIDZCGY76qzjic9bsshxns6yXPSl141dq1c,203
-cloe_nessy/integration/reader/file_reader.py,sha256=t5zF-cmZo1X0a1rki6ry1rSiFEu5uXRP2rNGd90fwoY,8163
+cloe_nessy/integration/reader/file_reader.py,sha256=FFqqu1h003FY2Df3ru-G1JO4Bg2Ai8Rzh58fjOCN7NM,8262
 cloe_nessy/integration/reader/reader.py,sha256=YHriYkzsBduBjfI2FnP03VEo15a8UCRZ_sXtre8eaEs,1041
 cloe_nessy/integration/writer/__init__.py,sha256=3yzCAGiWZdQWtsbzlTih01sxVTJV2DDYwvl34lEAUlE,243
 cloe_nessy/integration/writer/catalog_writer.py,sha256=dQeXmtfs7J6rP6Ye3OCvxBraFScFX_3SHs7Md58hEeM,5296
@@ -40,9 +40,9 @@ cloe_nessy/integration/writer/file_writer.py,sha256=SUDbN13ZzDhbM8DpOGFgM_Gkg70T
 cloe_nessy/integration/writer/writer.py,sha256=elFPLFrWR-qVE9qnBtzzzhyRALLQcRVuOsPS0rNmRt4,1741
 cloe_nessy/integration/writer/delta_writer/__init__.py,sha256=h2CT6Hllmk0nodlek27uqwniCzVZKMkYcPGyG9K2Z24,164
 cloe_nessy/integration/writer/delta_writer/delta_append_writer.py,sha256=nribgHmapp59v3Rw_AfJg0_BRYhP7x2IJIeE74Ia_6A,4748
-cloe_nessy/integration/writer/delta_writer/delta_merge_writer.py,sha256=Yp_q_ycasW2_wwmzty_6fZeBVcW_0o8gLrr6F1gaUjQ,10195
+cloe_nessy/integration/writer/delta_writer/delta_merge_writer.py,sha256=aMpWa8GcnW9xu5eGE_AsVyfkL5hRIeJwfCLPniM8lak,13170
 cloe_nessy/integration/writer/delta_writer/delta_table_operation_type.py,sha256=m4YFY9_WgaOcnpBviVt3Km-w3wf3NF25wPS-n0NBGcE,970
-cloe_nessy/integration/writer/delta_writer/delta_writer_base.py,sha256=O7hw7YOa2FEzBlzjwPfxQTxm0ZrlszIjjfsHTwE_OhU,8609
+cloe_nessy/integration/writer/delta_writer/delta_writer_base.py,sha256=B7PwPHKrsJL0ZxBT-H9wWSy0gn7shqNDJ0AbrpMHyMg,10135
 cloe_nessy/integration/writer/delta_writer/exceptions.py,sha256=xPmGiYV0xQXauln5Oh34E5vbm0rVcs6xCh-SJSb2bw0,107
 cloe_nessy/logging/__init__.py,sha256=ySVCVbdyR3Dno_tl2ZfiER_7EVaDoQMHVkNyfdMZumY,65
 cloe_nessy/logging/logger_mixin.py,sha256=H8MyMEyb_kEDP0Ow5QStAFLuOkTIeUnneGaj916fKlU,7443
@@ -74,7 +74,7 @@ cloe_nessy/pipeline/pipeline_context.py,sha256=eCOcjyE16rGRom3L85Gy_BbncfQD6i1x3
 cloe_nessy/pipeline/pipeline_parsing_service.py,sha256=eeC4RbGBILGN6zkbUyjH-qGgEMtOWV4Kv_VxrHbHMY0,9021
 cloe_nessy/pipeline/pipeline_plotting_service.py,sha256=goMQj73FzUVchKn5c2SsPcWR6fr7DtVkVrcQfJsKCq4,13111
 cloe_nessy/pipeline/pipeline_step.py,sha256=oTnlvRpB0fbOBQXbPe1URstA5fv-97igCHt_41fKCAk,2082
-cloe_nessy/pipeline/actions/__init__.py,sha256=Yf6-EoF_iTXOIOhgMN-GwhqH5DeaogUklVulh9OVj4s,2902
+cloe_nessy/pipeline/actions/__init__.py,sha256=FfAnSIl-0T6pnaWhClkDqV8nfTdvLvZZJdwycsZMLPw,2990
 cloe_nessy/pipeline/actions/read_api.py,sha256=MAc7QfmhnaRUMdE09Ywt41RSAsuW4co8zF0zXHwbM8U,16193
 cloe_nessy/pipeline/actions/read_catalog_table.py,sha256=sx3dezd33c1FawMrxORwhK5GNo1IpjCyuLATWz7esZ0,6735
 cloe_nessy/pipeline/actions/read_excel.py,sha256=IG_VmDEt1TvGVEO0SY9Fm3awHNjfisR1_7DUmhC3NEE,7968
@@ -93,6 +93,7 @@ cloe_nessy/pipeline/actions/transform_group_aggregate.py,sha256=KUHeeP-RIDi34dpb
 cloe_nessy/pipeline/actions/transform_hash_columns.py,sha256=M5_wolJwzJpPTSrZq4yWV3TH7H6BGqbjJkJCwtqPlQo,8507
 cloe_nessy/pipeline/actions/transform_join.py,sha256=ez1M1wVc9khOZj1swMArJbBKXxEpjenUHrW1wL8H330,7200
 cloe_nessy/pipeline/actions/transform_json_normalize.py,sha256=petF7pnNq1EKc8MqVdG0weFALAHNILSe_eAu4Z5XxIo,4833
+cloe_nessy/pipeline/actions/transform_regex_extract.py,sha256=vMtUW0s_oXy8DC1-4Xh-WQN3CCp8jXYsJiFYvGdYrqE,6390
 cloe_nessy/pipeline/actions/transform_rename_columns.py,sha256=4zJcPCONMU4C67qeuzsrX3AORRRHoq_selUI7FJyeg0,1952
 cloe_nessy/pipeline/actions/transform_replace_values.py,sha256=1OPHTrjcphfyGepcO7ozYfeqfwA18pjlyHpVKUS_AAU,2049
 cloe_nessy/pipeline/actions/transform_select_columns.py,sha256=-GhSEsb7iNnZIsYRm3BG9BX4_qUDJMbpj1DsKPY046w,4574
@@ -100,7 +101,7 @@ cloe_nessy/pipeline/actions/transform_union.py,sha256=SZtEzh567CIExUj9yMEgshE28h
 cloe_nessy/pipeline/actions/transform_with_column.py,sha256=c-E1yYkeYmovbN1maT7ImpdQlW0nYvYsHCtDvfe4wt8,3357
 cloe_nessy/pipeline/actions/write_catalog_table.py,sha256=FyC0scQU8Ul3Uigpk6IN2IJpf_4jRjAqF5yHtDVwG00,4852
 cloe_nessy/pipeline/actions/write_delta_append.py,sha256=e1g4mDhwAZdKyt4Gb7ZzHcQrJ1duSl8qOn6ONizRsoM,2934
-cloe_nessy/pipeline/actions/write_delta_merge.py,sha256=fwinlTeZoDuTyrbln5vMu1UJ1LG8ZQrus3LoCVF__I4,5819
+cloe_nessy/pipeline/actions/write_delta_merge.py,sha256=kZL2PTIwB6Mj4UKg5f9SvU1VaakuYfFoymlcLf-L7dA,6443
 cloe_nessy/pipeline/actions/write_file.py,sha256=JZ8UZslxUn_ttYt5wDyvtHFq2FqYk3vOR8kvExJI8pk,3212
 cloe_nessy/pipeline/utils/__init__.py,sha256=xi02UjBMiXWD7b9gDvww4gyRyowb0eRd_6Wbu0F_cro,118
 cloe_nessy/pipeline/utils/delta_load_utils.py,sha256=KitMNruxePEkecI0h4Jint1JwJpaEog5mCOchMkgan8,1495
@@ -112,6 +113,6 @@ cloe_nessy/settings/settings.py,sha256=I4n129lrujriW-d8q4as2Kb4_kI932ModfZ5Ow_Up
 cloe_nessy/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cloe_nessy/utils/column_names.py,sha256=dCNtm61mc5aLkY2oE4rlfN3VLCrpot6fOESjAZmCmhA,361
 cloe_nessy/utils/file_and_directory_handler.py,sha256=r2EVt9xG81p6ScaJCwETC5an6pMT6WseB0jMOR-JlpU,602
-cloe_nessy-1.0.0.dist-info/METADATA,sha256=jaztxDdomowmj0qTJ4i5jtF0dE_T5TmqA8j9zywl0U0,3291
-cloe_nessy-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cloe_nessy-1.0.0.dist-info/RECORD,,
+cloe_nessy-1.0.3.dist-info/METADATA,sha256=fqBGuiBnOft_b6Q3yS_hxFPi5pqduBX7V7bBeXYwkvQ,3291
+cloe_nessy-1.0.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cloe_nessy-1.0.3.dist-info/RECORD,,