Flowfile 0.3.9__py3-none-any.whl → 0.5.1__py3-none-any.whl

flowfile_core/flowfile/code_generator/code_generator.py

@@ -63,7 +63,6 @@ class FlowGraphToPolarsConverter:
         """Generate Polars code for a specific node."""
         node_type = node.node_type
         settings = node.setting_input
-        # Skip placeholder nodes
         if isinstance(settings, input_schema.NodePromise):
             self._add_comment(f"# Skipping uninitialized node: {node.node_id}")
             return
@@ -71,7 +70,7 @@ class FlowGraphToPolarsConverter:
         var_name = f"df_{node.node_id}"
         self.node_var_mapping[node.node_id] = var_name
         self.handle_output_node(node, var_name)
-        if node.node_template.output>0:
+        if node.node_template.output > 0:
             self.last_node_var = var_name
         # Get input variable names
         input_vars = self._get_input_vars(node)
@@ -111,25 +110,25 @@ class FlowGraphToPolarsConverter:
         return input_vars
 
     def _handle_csv_read(self, file_settings: input_schema.ReceivedTable, var_name: str):
-        if file_settings.encoding.lower() in ('utf-8', 'utf8'):
+        if file_settings.table_settings.encoding.lower() in ('utf-8', 'utf8'):
             encoding = "utf8-lossy"
             self._add_code(f"{var_name} = pl.scan_csv(")
             self._add_code(f'    "{file_settings.abs_file_path}",')
-            self._add_code(f'    separator="{file_settings.delimiter}",')
-            self._add_code(f'    has_header={file_settings.has_headers},')
-            self._add_code(f'    ignore_errors={file_settings.ignore_errors},')
+            self._add_code(f'    separator="{file_settings.table_settings.delimiter}",')
+            self._add_code(f'    has_header={file_settings.table_settings.has_headers},')
+            self._add_code(f'    ignore_errors={file_settings.table_settings.ignore_errors},')
             self._add_code(f'    encoding="{encoding}",')
-            self._add_code(f'    skip_rows={file_settings.starting_from_line},')
+            self._add_code(f'    skip_rows={file_settings.table_settings.starting_from_line},')
             self._add_code(")")
         else:
             self._add_code(f"{var_name} = pl.read_csv(")
             self._add_code(f'    "{file_settings.abs_file_path}",')
-            self._add_code(f'    separator="{file_settings.delimiter}",')
-            self._add_code(f'    has_header={file_settings.has_headers},')
-            self._add_code(f'    ignore_errors={file_settings.ignore_errors},')
-            if file_settings.encoding:
-                self._add_code(f'    encoding="{file_settings.encoding}",')
-            self._add_code(f'    skip_rows={file_settings.starting_from_line},')
+            self._add_code(f'    separator="{file_settings.table_settings.delimiter}",')
+            self._add_code(f'    has_header={file_settings.table_settings.has_headers},')
+            self._add_code(f'    ignore_errors={file_settings.table_settings.ignore_errors},')
+            if file_settings.table_settings.encoding:
+                self._add_code(f'    encoding="{file_settings.table_settings.encoding}",')
+            self._add_code(f'    skip_rows={file_settings.table_settings.starting_from_line},')
             self._add_code(").lazy()")
 
     def _handle_cloud_storage_reader(self, settings: input_schema.NodeCloudStorageReader, var_name: str, input_vars: Dict[str, str]):
@@ -181,8 +180,8 @@ class FlowGraphToPolarsConverter:
         elif file_settings.file_type in ('xlsx', 'excel'):
             self._add_code(f"{var_name} = pl.read_excel(")
             self._add_code(f'    "{file_settings.abs_file_path}",')
-            if file_settings.sheet_name:
-                self._add_code(f'    sheet_name="{file_settings.sheet_name}",')
+            if file_settings.table_settings.sheet_name:
+                self._add_code(f'    sheet_name="{file_settings.table_settings.sheet_name}",')
             self._add_code(").lazy()")
 
         self._add_code("")
@@ -296,7 +295,6 @@ class FlowGraphToPolarsConverter:
         """
         left_df = input_vars.get('main', input_vars.get('main_0', 'df_left'))
         right_df = input_vars.get('right', input_vars.get('main_1', 'df_right'))
-
         # Ensure left and right DataFrames are distinct
         if left_df == right_df:
             right_df = "df_right"
@@ -359,26 +357,25 @@ class FlowGraphToPolarsConverter:
         Returns:
             None: Modifies internal state by adding generated code
         """
-        settings.join_input.auto_rename()
-
+        join_input_manager = transform_schema.JoinInputManager(settings.join_input)
+        join_input_manager.auto_rename()
         # Get join keys
-        left_on, right_on = self._get_join_keys(settings)
+        left_on, right_on = self._get_join_keys(join_input_manager)
 
         # Apply pre-join transformations
-        left_df, right_df = self._apply_pre_join_transformations(settings, left_df, right_df)
-
+        left_df, right_df = self._apply_pre_join_transformations(join_input_manager, left_df, right_df)
         # Handle join-specific key transformations
         left_on, right_on, reverse_action, after_join_drop_cols = self._handle_join_key_transformations(
-            settings, left_df, right_df, left_on, right_on
+            join_input_manager, left_df, right_df, left_on, right_on
         )
-
         # Execute the join
         self._execute_join_with_post_processing(
             settings, var_name, left_df, right_df, left_on, right_on,
             after_join_drop_cols, reverse_action
         )
 
-    def _get_join_keys(self, settings: input_schema.NodeJoin) -> Tuple[List[str], List[str]]:
+    @staticmethod
+    def _get_join_keys(settings: transform_schema.JoinInputManager) -> Tuple[List[str], List[str]]:
         """Extract join keys based on join type.
 
         Different join types require different handling of join keys:
@@ -391,16 +388,16 @@ class FlowGraphToPolarsConverter:
         Returns:
             Tuple[List[str], List[str]]: Lists of (left_on, right_on) column names
         """
-        left_on = [jm.left_col for jm in settings.join_input.get_names_for_table_rename()]
+        left_on = [jm.left_col for jm in settings.get_names_for_table_rename()]
 
-        if settings.join_input.how in ("outer", "right"):
-            right_on = [jm.right_col for jm in settings.join_input.get_names_for_table_rename()]
+        if settings.how in ("outer", "right"):
+            right_on = [jm.right_col for jm in settings.get_names_for_table_rename()]
         else:
-            right_on = [jm.right_col for jm in settings.join_input.join_mapping]
+            right_on = [jm.right_col for jm in settings.join_mapping]
 
         return left_on, right_on
 
-    def _apply_pre_join_transformations(self, settings: input_schema.NodeJoin, left_df: str, right_df: str) -> Tuple[
+    def _apply_pre_join_transformations(self, settings: transform_schema.JoinInputManager, left_df: str, right_df: str) -> Tuple[
         str, str]:
         """Apply column renames and drops before the join operation.
 
@@ -421,24 +418,24 @@ class FlowGraphToPolarsConverter:
         # Calculate renames and drops
         right_renames = {
             column.old_name: column.new_name
-            for column in settings.join_input.right_select.renames
+            for column in settings.right_select.renames
             if
-            column.old_name != column.new_name and not column.join_key or settings.join_input.how in ("outer", "right")
+            column.old_name != column.new_name and not column.join_key or settings.how in ("outer", "right")
         }
 
         left_renames = {
             column.old_name: column.new_name
-            for column in settings.join_input.left_select.renames
+            for column in settings.left_select.renames
             if column.old_name != column.new_name
         }
 
         left_drop_columns = [
-            column.old_name for column in settings.join_input.left_select.renames
+            column.old_name for column in settings.left_select.renames
             if not column.keep and not column.join_key
         ]
 
         right_drop_columns = [
-            column.old_name for column in settings.join_input.right_select.renames
+            column.old_name for column in settings.right_select.renames
             if not column.keep and not column.join_key
         ]
 
@@ -454,7 +451,7 @@ class FlowGraphToPolarsConverter:
 
         return left_df, right_df
 
-    def _handle_join_key_transformations(self, settings: input_schema.NodeJoin, left_df: str, right_df: str,
+    def _handle_join_key_transformations(self, settings: transform_schema.JoinInputManager, left_df: str, right_df: str,
                                          left_on: List[str], right_on: List[str]) \
             -> Tuple[List[str], List[str], Optional[Dict], List[str]]:
         """Route to appropriate join-specific key transformation handler.
@@ -476,7 +473,7 @@ class FlowGraphToPolarsConverter:
                 - reverse_action: Dictionary for renaming columns after join (or None)
                 - after_join_drop_cols: List of columns to drop after join
         """
-        join_type = settings.join_input.how
+        join_type = settings.how
 
         if join_type in ("left", "inner"):
             return self._handle_left_inner_join_keys(settings, right_df, left_on, right_on)
@@ -487,7 +484,7 @@ class FlowGraphToPolarsConverter:
         else:
             return left_on, right_on, None, []
 
-    def _handle_left_inner_join_keys(self, settings: input_schema.NodeJoin, right_df: str,
+    def _handle_left_inner_join_keys(self, settings: transform_schema.JoinInputManager, right_df: str,
                                      left_on: List[str], right_on: List[str]) -> Tuple[
         List[str], List[str], Dict, List[str]]:
         """Handle key transformations for left and inner joins.
@@ -510,29 +507,28 @@ class FlowGraphToPolarsConverter:
                 - reverse_action: Mapping to rename __DROP__ columns after join
                 - after_join_drop_cols: Left join keys marked for dropping
         """
-        left_join_keys_to_keep = [jk.new_name for jk in settings.join_input.left_select.join_key_selects if jk.keep]
-
+        left_join_keys_to_keep = [jk.new_name for jk in settings.left_select.join_key_selects if jk.keep]
         join_key_duplication_command = [
             f'pl.col("{rjk.old_name}").alias("__DROP__{rjk.new_name}__DROP__")'
-            for rjk in settings.join_input.right_select.join_key_selects if rjk.keep
+            for rjk in settings.right_select.join_key_selects if rjk.keep
         ]
 
         reverse_action = {
             f"__DROP__{rjk.new_name}__DROP__": rjk.new_name
-            for rjk in settings.join_input.right_select.join_key_selects if rjk.keep
+            for rjk in settings.right_select.join_key_selects if rjk.keep
         }
 
         if join_key_duplication_command:
             self._add_code(f"{right_df} = {right_df}.with_columns([{', '.join(join_key_duplication_command)}])")
 
         after_join_drop_cols = [
-            k.new_name for k in settings.join_input.left_select.join_key_selects
+            k.new_name for k in settings.left_select.join_key_selects
             if not k.keep
         ]
 
         return left_on, right_on, reverse_action, after_join_drop_cols
 
-    def _handle_right_join_keys(self, settings: input_schema.NodeJoin, left_df: str,
+    def _handle_right_join_keys(self, settings: transform_schema.JoinInputManager, left_df: str,
                                 left_on: List[str], right_on: List[str]) -> Tuple[
         List[str], List[str], None, List[str]]:
         """Handle key transformations for right joins.
@@ -557,12 +553,12 @@ class FlowGraphToPolarsConverter:
         """
         join_key_duplication_command = [
             f'pl.col("{ljk.new_name}").alias("__jk_{ljk.new_name}")'
-            for ljk in settings.join_input.left_select.join_key_selects if ljk.keep
+            for ljk in settings.left_select.join_key_selects if ljk.keep
         ]
 
         # Update left_on keys
         for position, left_on_key in enumerate(left_on):
-            left_on_select = settings.join_input.left_select.get_select_input_on_new_name(left_on_key)
+            left_on_select = settings.left_select.get_select_input_on_new_name(left_on_key)
             if left_on_select and left_on_select.keep:
                 left_on[position] = f"__jk_{left_on_select.new_name}"
 
@@ -570,18 +566,17 @@ class FlowGraphToPolarsConverter:
             self._add_code(f"{left_df} = {left_df}.with_columns([{', '.join(join_key_duplication_command)}])")
 
         # Calculate columns to drop after join
-        left_join_keys_keep = {jk.new_name for jk in settings.join_input.left_select.join_key_selects if jk.keep}
+        left_join_keys_keep = {jk.new_name for jk in settings.left_select.join_key_selects if jk.keep}
         after_join_drop_cols_right = [
             jk.new_name if jk.new_name not in left_join_keys_keep else jk.new_name + "_right"
-            for jk in settings.join_input.right_select.join_key_selects if not jk.keep
+            for jk in settings.right_select.join_key_selects if not jk.keep
         ]
         after_join_drop_cols = list(set(after_join_drop_cols_right))
-
         return left_on, right_on, None, after_join_drop_cols
 
-    def _handle_outer_join_keys(self, settings: input_schema.NodeJoin, right_df: str,
-                                left_on: List[str], right_on: List[str]) -> Tuple[
-        List[str], List[str], Dict, List[str]]:
+    def _handle_outer_join_keys(self, settings: transform_schema.JoinInputManager, right_df: str,
+                                left_on: List[str],
+                                right_on: List[str]) -> Tuple[List[str], List[str], Dict, List[str]]:
         """Handle key transformations for outer joins.
 
         For outer joins:
@@ -602,10 +597,10 @@ class FlowGraphToPolarsConverter:
                 - reverse_action: Mapping to remove __jk_ prefix after join
                 - after_join_drop_cols: Combined list of columns to drop from both sides
         """
-        left_join_keys = {jk.new_name for jk in settings.join_input.left_select.join_key_selects}
+        left_join_keys = {jk.new_name for jk in settings.left_select.join_key_selects}
 
         join_keys_to_keep_and_rename = [
-            rjk for rjk in settings.join_input.right_select.join_key_selects
+            rjk for rjk in settings.right_select.join_key_selects
             if rjk.keep and rjk.new_name in left_join_keys
         ]
 
@@ -616,7 +611,7 @@ class FlowGraphToPolarsConverter:
 
         # Update right_on keys
         for position, right_on_key in enumerate(right_on):
-            right_on_select = settings.join_input.right_select.get_select_input_on_new_name(right_on_key)
+            right_on_select = settings.right_select.get_select_input_on_new_name(right_on_key)
             if right_on_select and right_on_select.keep and right_on_select.new_name in left_join_keys:
                 right_on[position] = f"__jk_{right_on_select.new_name}"
 
@@ -627,11 +622,11 @@ class FlowGraphToPolarsConverter:
 
         # Calculate columns to drop after join
         after_join_drop_cols_left = [
-            jk.new_name for jk in settings.join_input.left_select.join_key_selects if not jk.keep
+            jk.new_name for jk in settings.left_select.join_key_selects if not jk.keep
         ]
         after_join_drop_cols_right = [
             jk.new_name if jk.new_name not in left_join_keys else jk.new_name + "_right"
-            for jk in settings.join_input.right_select.join_key_selects if not jk.keep
+            for jk in settings.right_select.join_key_selects if not jk.keep
         ]
         after_join_drop_cols = after_join_drop_cols_left + after_join_drop_cols_right
 
@@ -718,7 +713,7 @@ class FlowGraphToPolarsConverter:
         col_name = settings.function.field.name
         self._add_code(f"{var_name} = {input_df}.with_columns([")
         self._add_code(f'simple_function_to_expr({repr(formula)}).alias("{col_name}")')
-        if settings.function.field.data_type not in (None, "Auto"):
+        if settings.function.field.data_type not in (None, transform_schema.AUTO_DATA_TYPE):
             output_type = convert_pl_type_to_string(cast_str_to_polars_type(settings.function.field.data_type))
             if output_type[:3] != "pl.":
                 output_type = "pl." + output_type
@@ -829,6 +824,7 @@ class FlowGraphToPolarsConverter:
 
     @staticmethod
     def _transform_fuzzy_mappings_to_string(fuzzy_mappings: List[FuzzyMapping]) -> str:
+
         output_str = "["
         for i, fuzzy_mapping in enumerate(fuzzy_mappings):
 
@@ -844,18 +840,20 @@ class FlowGraphToPolarsConverter:
     def _handle_fuzzy_match(self, settings: input_schema.NodeFuzzyMatch, var_name: str, input_vars: Dict[str, str]) -> None:
         """Handle fuzzy match nodes."""
         self.imports.add("from pl_fuzzy_frame_match import FuzzyMapping, fuzzy_match_dfs")
+        fuzzy_match_handler = transform_schema.FuzzyMatchInputManager(settings.join_input)
         left_df = input_vars.get('main', input_vars.get('main_0', 'df_left'))
         right_df = input_vars.get('right', input_vars.get('main_1', 'df_right'))
+
         if left_df == right_df:
             right_df = "df_right"
             self._add_code(f"{right_df} = {left_df}")
 
-        if settings.join_input.left_select.has_drop_cols():
-            self._add_code(f"{left_df} = {left_df}.drop({[c.old_name for c in settings.join_input.left_select.non_jk_drop_columns]})")
-        if settings.join_input.right_select.has_drop_cols():
-            self._add_code(f"{right_df} = {right_df}.drop({[c.old_name for c in settings.join_input.right_select.non_jk_drop_columns]})")
+        if fuzzy_match_handler.left_select.has_drop_cols():
+            self._add_code(f"{left_df} = {left_df}.drop({[c.old_name for c in fuzzy_match_handler.left_select.non_jk_drop_columns]})")
+        if fuzzy_match_handler.right_select.has_drop_cols():
+            self._add_code(f"{right_df} = {right_df}.drop({[c.old_name for c in fuzzy_match_handler.right_select.non_jk_drop_columns]})")
 
-        fuzzy_join_mapping_settings = self._transform_fuzzy_mappings_to_string(settings.join_input.join_mapping)
+        fuzzy_join_mapping_settings = self._transform_fuzzy_mappings_to_string(fuzzy_match_handler.join_mapping)
         self._add_code(f"{var_name} = fuzzy_match_dfs(\n"
                        f"       left_df={left_df}, right_df={right_df},\n"
                        f"       fuzzy_maps={fuzzy_join_mapping_settings}\n"
@@ -961,7 +959,7 @@ class FlowGraphToPolarsConverter:
         if output_settings.file_type == 'csv':
             self._add_code(f'{input_df}.sink_csv(')
             self._add_code(f'    "{output_settings.abs_file_path}",')
-            self._add_code(f'    separator="{output_settings.output_csv_table.delimiter}"')
+            self._add_code(f'    separator="{output_settings.table_settings.delimiter}"')
             self._add_code(')')
 
         elif output_settings.file_type == 'parquet':
@@ -970,7 +968,7 @@ class FlowGraphToPolarsConverter:
         elif output_settings.file_type == 'excel':
             self._add_code(f'{input_df}.collect().write_excel(')
             self._add_code(f'    "{output_settings.abs_file_path}",')
-            self._add_code(f'    worksheet="{output_settings.output_excel_table.sheet_name}"')
+            self._add_code(f'    worksheet="{output_settings.table_settings.sheet_name}"')
             self._add_code(')')
 
         self._add_code("")

flowfile_core/flowfile/flow_data_engine/create/funcs.py

@@ -6,45 +6,50 @@ from flowfile_core.flowfile.flow_data_engine.read_excel_tables import df_from_op
 from polars._typing import CsvEncoding
 
 
-def create_from_json(received_table: input_schema.ReceivedCsvTable):
+def create_from_json(received_table: input_schema.ReceivedTable):
     f = received_table.abs_file_path
     gbs_to_load = os.path.getsize(f) / 1024 / 1000 / 1000
     low_mem = gbs_to_load > 10
-    if received_table.encoding.upper() == 'UTF8' or received_table.encoding.upper() == 'UTF-8':
+
+    if not isinstance(received_table.table_settings, input_schema.InputJsonTable):
+        raise ValueError("Received table settings are not of type InputJsonTable")
+    table_settings: input_schema.InputJsonTable = received_table.table_settings
+
+    if table_settings.encoding.upper() == 'UTF8' or table_settings.encoding.upper() == 'UTF-8':
         try:
             data = pl.scan_csv(f,
                                low_memory=low_mem,
                                try_parse_dates=True,
-                               separator=received_table.delimiter,
-                               has_header=received_table.has_headers,
-                               skip_rows=received_table.starting_from_line,
+                               separator=table_settings.delimiter,
+                               has_header=table_settings.has_headers,
+                               skip_rows=table_settings.starting_from_line,
                                encoding='utf8',
-                               infer_schema_length=received_table.infer_schema_length)
+                               infer_schema_length=table_settings.infer_schema_length)
             data.head(1).collect()
             return data
         except:
             try:
                 data = pl.scan_csv(f, low_memory=low_mem,
-                                   separator=received_table.delimiter,
-                                   has_header=received_table.has_headers,
-                                   skip_rows=received_table.starting_from_line,
+                                   separator=table_settings.delimiter,
+                                   has_header=table_settings.has_headers,
+                                   skip_rows=table_settings.starting_from_line,
                                    encoding='utf8-lossy',
                                    ignore_errors=True)
                 return data
             except:
                 data = pl.scan_csv(f, low_memory=low_mem,
-                                   separator=received_table.delimiter,
-                                   has_header=received_table.has_headers,
-                                   skip_rows=received_table.starting_from_line,
+                                   separator=table_settings.delimiter,
+                                   has_header=table_settings.has_headers,
+                                   skip_rows=table_settings.starting_from_line,
                                    encoding='utf8',
                                    ignore_errors=True)
                 return data
     else:
         data = pl.read_csv(f, low_memory=low_mem,
-                           separator=received_table.delimiter,
-                           has_header=received_table.has_headers,
-                           skip_rows=received_table.starting_from_line,
-                           encoding=received_table.encoding,
+                           separator=table_settings.delimiter,
+                           has_header=table_settings.has_headers,
+                           skip_rows=table_settings.starting_from_line,
+                           encoding=table_settings.encoding,
                            ignore_errors=True)
         return data
 
@@ -58,48 +63,54 @@ def standardize_utf8_encoding(non_standardized_encoding: str) -> CsvEncoding:
         raise ValueError(f"Encoding {non_standardized_encoding} is not supported.")
 
 
-def create_from_path_csv(received_table: input_schema.ReceivedCsvTable) -> pl.LazyFrame:
+def create_from_path_csv(received_table: input_schema.ReceivedTable) -> pl.LazyFrame:
+    if not isinstance(received_table.table_settings, input_schema.InputCsvTable):
+        raise ValueError("Received table settings are not of type InputCsvTable")
+
+    table_settings: input_schema.InputCsvTable = received_table.table_settings
+
     f = received_table.abs_file_path
     gbs_to_load = os.path.getsize(f) / 1024 / 1000 / 1000
     low_mem = gbs_to_load > 10
-    if received_table.encoding.upper() in ("UTF-8", "UTF8", 'UTF8-LOSSY', 'UTF-8-LOSSY'):
-        encoding: CsvEncoding = standardize_utf8_encoding(received_table.encoding)
+
+    if table_settings.encoding.upper() in ("UTF-8", "UTF8", 'UTF8-LOSSY', 'UTF-8-LOSSY'):
+        encoding: CsvEncoding = standardize_utf8_encoding(table_settings.encoding)
         try:
             data = pl.scan_csv(f,
                                low_memory=low_mem,
                                try_parse_dates=True,
-                               separator=received_table.delimiter,
-                               has_header=received_table.has_headers,
-                               skip_rows=received_table.starting_from_line,
+                               separator=table_settings.delimiter,
+                               has_header=table_settings.has_headers,
+                               skip_rows=table_settings.starting_from_line,
                                encoding=encoding,
-                               infer_schema_length=received_table.infer_schema_length)
+                               infer_schema_length=table_settings.infer_schema_length)
             data.head(1).collect()
             return data
         except:
 
             try:
                 data = pl.scan_csv(f, low_memory=low_mem,
-                                   separator=received_table.delimiter,
-                                   has_header=received_table.has_headers,
-                                   skip_rows=received_table.starting_from_line,
+                                   separator=table_settings.delimiter,
+                                   has_header=table_settings.has_headers,
+                                   skip_rows=table_settings.starting_from_line,
                                    encoding='utf8-lossy',
                                    ignore_errors=True)
                 return data
             except:
                 data = pl.scan_csv(f, low_memory=False,
-                                   separator=received_table.delimiter,
-                                   has_header=received_table.has_headers,
-                                   skip_rows=received_table.starting_from_line,
+                                   separator=table_settings.delimiter,
+                                   has_header=table_settings.has_headers,
+                                   skip_rows=table_settings.starting_from_line,
                                    encoding=encoding,
                                    ignore_errors=True)
                 return data
     else:
         data = pl.read_csv_batched(f,
                                    low_memory=low_mem,
-                                   separator=received_table.delimiter,
-                                   has_header=received_table.has_headers,
-                                   skip_rows=received_table.starting_from_line,
-                                   encoding=received_table.encoding,
+                                   separator=table_settings.delimiter,
+                                   has_header=table_settings.has_headers,
+                                   skip_rows=table_settings.starting_from_line,
+                                   encoding=table_settings.encoding,
                                    ignore_errors=True, batch_size=2).next_batches(1)
         return data[0].lazy()
 
@@ -108,50 +119,56 @@ def create_random(number_of_records: int = 1000) -> pl.LazyFrame:
     return create_fake_data(number_of_records).lazy()
 
 
-def create_from_path_parquet(received_table: input_schema.ReceivedParquetTable) -> pl.LazyFrame:
+def create_from_path_parquet(received_table: input_schema.ReceivedTable) -> pl.LazyFrame:
+    if not isinstance(received_table.table_settings, input_schema.InputParquetTable):
+        raise ValueError("Received table settings are not of type InputParquetTable")
     low_mem = (os.path.getsize(received_table.abs_file_path) / 1024 / 1000 / 1000) > 2
     return pl.scan_parquet(source=received_table.abs_file_path, low_memory=low_mem)
 
 
-def create_from_path_excel(received_table: input_schema.ReceivedExcelTable):
-    if received_table.type_inference:
+def create_from_path_excel(received_table: input_schema.ReceivedTable):
+    if not isinstance(received_table.table_settings, input_schema.InputExcelTable):
+        raise ValueError("Received table settings are not of type InputExcelTable")
+
+    table_settings: input_schema.InputExcelTable = received_table.table_settings
+    if table_settings.type_inference:
         engine = 'openpyxl'
-    elif received_table.start_row > 0 and received_table.start_column == 0:
-        engine = 'calamine' if received_table.has_headers else 'xlsx2csv'
-    elif received_table.start_column > 0 or received_table.start_row > 0:
+    elif table_settings.start_row > 0 and table_settings.start_column == 0:
+        engine = 'calamine' if table_settings.has_headers else 'xlsx2csv'
+    elif table_settings.start_column > 0 or table_settings.start_row > 0:
         engine = 'openpyxl'
     else:
         engine = 'calamine'
 
-    sheet_name = received_table.sheet_name
+    sheet_name = table_settings.sheet_name
 
     if engine == 'calamine':
         df = df_from_calamine_xlsx(file_path=received_table.abs_file_path, sheet_name=sheet_name,
-                                   start_row=received_table.start_row, end_row=received_table.end_row)
-        if received_table.end_column > 0:
-            end_col_index = received_table.end_column
-            cols_to_select = [df.columns[i] for i in range(received_table.start_column, end_col_index)]
+                                   start_row=table_settings.start_row, end_row=table_settings.end_row)
+        if table_settings.end_column > 0:
+            end_col_index = table_settings.end_column
+            cols_to_select = [df.columns[i] for i in range(table_settings.start_column, end_col_index)]
             df = df.select(cols_to_select)
 
     elif engine == 'xlsx2csv':
-        csv_options = {'has_header': received_table.has_headers, 'skip_rows': received_table.start_row}
+        csv_options = {'has_header': table_settings.has_headers, 'skip_rows': table_settings.start_row}
         df = pl.read_excel(source=received_table.abs_file_path,
                            read_options=csv_options,
                            engine='xlsx2csv',
-                           sheet_name=received_table.sheet_name)
-        end_col_index = received_table.end_column if received_table.end_column > 0 else len(df.columns)
-        cols_to_select = [df.columns[i] for i in range(received_table.start_column, end_col_index)]
+                           sheet_name=table_settings.sheet_name)
+        end_col_index = table_settings.end_column if table_settings.end_column > 0 else len(df.columns)
+        cols_to_select = [df.columns[i] for i in range(table_settings.start_column, end_col_index)]
         df = df.select(cols_to_select)
-        if 0 < received_table.end_row < len(df):
-            df = df.head(received_table.end_row)
+        if 0 < table_settings.end_row < len(df):
+            df = df.head(table_settings.end_row)
 
     else:
-        max_col = received_table.end_column if received_table.end_column > 0 else None
-        max_row = received_table.end_row + 1 if received_table.end_row > 0 else None
+        max_col = table_settings.end_column if table_settings.end_column > 0 else None
+        max_row = table_settings.end_row + 1 if table_settings.end_row > 0 else None
         df = df_from_openpyxl(file_path=received_table.abs_file_path,
-                              sheet_name=received_table.sheet_name,
-                              min_row=received_table.start_row + 1,
-                              min_col=received_table.start_column + 1,
+                              sheet_name=table_settings.sheet_name,
+                              min_row=table_settings.start_row + 1,
+                              min_col=table_settings.start_column + 1,
                               max_row=max_row,
-                              max_col=max_col, has_headers=received_table.has_headers)
+                              max_col=max_col, has_headers=table_settings.has_headers)
     return df