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

flowfile_core/schemas/transform_schema.py

@@ -1,18 +1,102 @@
-from typing import List, Dict, Tuple, Set, Optional, Literal, Callable
+from collections.abc import Callable
+from copy import deepcopy
 from dataclasses import asdict
+from enum import Enum
+from typing import Any, Literal, NamedTuple
+
 import polars as pl
+from pl_fuzzy_frame_match.models import FuzzyMapping
 from polars import selectors
-from copy import deepcopy
-from pydantic import BaseModel, ConfigDict, model_validator, Field
-from typing import NamedTuple, Union, Any
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
 from flowfile_core.schemas.yaml_types import (
-    SelectInputYaml, JoinInputsYaml, JoinInputYaml,
-    CrossJoinInputYaml, FuzzyMatchInputYaml
+    BasicFilterYaml,
+    CrossJoinInputYaml,
+    FilterInputYaml,
+    FuzzyMatchInputYaml,
+    JoinInputsYaml,
+    JoinInputYaml,
+    SelectInputYaml,
 )
-from pl_fuzzy_frame_match.models import FuzzyMapping
-
 from flowfile_core.types import DataType, DataTypeStr
 
+
+class FilterOperator(str, Enum):
+    """Supported filter comparison operators."""
+
+    EQUALS = "equals"
+    NOT_EQUALS = "not_equals"
+    GREATER_THAN = "greater_than"
+    GREATER_THAN_OR_EQUALS = "greater_than_or_equals"
+    LESS_THAN = "less_than"
+    LESS_THAN_OR_EQUALS = "less_than_or_equals"
+    CONTAINS = "contains"
+    NOT_CONTAINS = "not_contains"
+    STARTS_WITH = "starts_with"
+    ENDS_WITH = "ends_with"
+    IS_NULL = "is_null"
+    IS_NOT_NULL = "is_not_null"
+    IN = "in"
+    NOT_IN = "not_in"
+    BETWEEN = "between"
+
+    def __str__(self) -> str:
+        return self.value
+
+    @classmethod
+    def from_symbol(cls, symbol: str) -> "FilterOperator":
+        """Convert UI symbol to FilterOperator enum."""
+        symbol_mapping = {
+            "=": cls.EQUALS,
+            "==": cls.EQUALS,
+            "!=": cls.NOT_EQUALS,
+            "<>": cls.NOT_EQUALS,
+            ">": cls.GREATER_THAN,
+            ">=": cls.GREATER_THAN_OR_EQUALS,
+            "<": cls.LESS_THAN,
+            "<=": cls.LESS_THAN_OR_EQUALS,
+            "contains": cls.CONTAINS,
+            "not_contains": cls.NOT_CONTAINS,
+            "starts_with": cls.STARTS_WITH,
+            "ends_with": cls.ENDS_WITH,
+            "is_null": cls.IS_NULL,
+            "is_not_null": cls.IS_NOT_NULL,
+            "in": cls.IN,
+            "not_in": cls.NOT_IN,
+            "between": cls.BETWEEN,
+        }
+        if symbol in symbol_mapping:
+            return symbol_mapping[symbol]
+        # Try to match by value directly
+        try:
+            return cls(symbol)
+        except ValueError:
+            raise ValueError(f"Unknown filter operator symbol: {symbol}")
+
+    def to_symbol(self) -> str:
+        """Convert FilterOperator to UI-friendly symbol."""
+        symbol_mapping = {
+            FilterOperator.EQUALS: "=",
+            FilterOperator.NOT_EQUALS: "!=",
+            FilterOperator.GREATER_THAN: ">",
+            FilterOperator.GREATER_THAN_OR_EQUALS: ">=",
+            FilterOperator.LESS_THAN: "<",
+            FilterOperator.LESS_THAN_OR_EQUALS: "<=",
+            FilterOperator.CONTAINS: "contains",
+            FilterOperator.NOT_CONTAINS: "not_contains",
+            FilterOperator.STARTS_WITH: "starts_with",
+            FilterOperator.ENDS_WITH: "ends_with",
+            FilterOperator.IS_NULL: "is_null",
+            FilterOperator.IS_NOT_NULL: "is_not_null",
+            FilterOperator.IN: "in",
+            FilterOperator.NOT_IN: "not_in",
+            FilterOperator.BETWEEN: "between",
+        }
+        return symbol_mapping.get(self, self.value)
+
+
+FilterModeLiteral = Literal["basic", "advanced"]
+
 FuzzyMap = FuzzyMapping
 
 AUTO_DATA_TYPE = "Auto"
@@ -22,22 +106,22 @@ def get_func_type_mapping(func: str):
     """Infers the output data type of common aggregation functions."""
     if func in ["mean", "avg", "median", "std", "var"]:
         return "Float64"
-    elif func in ['min', 'max', 'first', 'last', "cumsum", "sum"]:
+    elif func in ["min", "max", "first", "last", "cumsum", "sum"]:
         return None
-    elif func in ['count', 'n_unique']:
+    elif func in ["count", "n_unique"]:
         return "Int64"
-    elif func in ['concat']:
+    elif func in ["concat"]:
         return "Utf8"
 
 
 def string_concat(*column: str):
     """A simple wrapper to concatenate string columns in Polars."""
-    return pl.col(column).cast(pl.Utf8).str.concat(delimiter=',')
+    return pl.col(column).cast(pl.Utf8).str.concat(delimiter=",")
 
 
 SideLit = Literal["left", "right"]
-JoinStrategy = Literal['inner', 'left', 'right', 'full', 'semi', 'anti', 'cross', 'outer']
-FuzzyTypeLiteral = Literal['levenshtein', 'jaro', 'jaro_winkler', 'hamming', 'damerau_levenshtein', 'indel']
+JoinStrategy = Literal["inner", "left", "right", "full", "semi", "anti", "cross", "outer"]
+FuzzyTypeLiteral = Literal["levenshtein", "jaro", "jaro_winkler", "hamming", "damerau_levenshtein", "indel"]
 
 
 def construct_join_key_name(side: SideLit, column_name: str) -> str:
@@ -47,18 +131,21 @@ def construct_join_key_name(side: SideLit, column_name: str) -> str:
 
 class JoinKeyRename(NamedTuple):
     """Represents the renaming of a join key from its original to a temporary name."""
+
     original_name: str
     temp_name: str
 
 
 class JoinKeyRenameResponse(NamedTuple):
     """Contains a list of join key renames for one side of a join."""
+
     side: SideLit
-    join_key_renames: List[JoinKeyRename]
+    join_key_renames: list[JoinKeyRename]
 
 
 class FullJoinKeyResponse(NamedTuple):
     """Holds the join key rename responses for both sides of a join."""
+
     left: JoinKeyRenameResponse
     right: JoinKeyRenameResponse
 
@@ -69,24 +156,25 @@ class SelectInput(BaseModel):
     This is a core building block for any operation that involves column manipulation.
     It holds all the configuration for a single field in a selection operation.
     """
+
     model_config = ConfigDict(frozen=False)
 
     old_name: str
-    original_position: Optional[int] = None
-    new_name: Optional[str] = None
-    data_type: Optional[str] = None
+    original_position: int | None = None
+    new_name: str | None = None
+    data_type: str | None = None
     data_type_change: bool = False
     join_key: bool = False
     is_altered: bool = False
-    position: Optional[int] = None
+    position: int | None = None
     is_available: bool = True
     keep: bool = True
 
     def __init__(self, old_name: str = None, new_name: str = None, **data):
         if old_name is not None:
-            data['old_name'] = old_name
+            data["old_name"] = old_name
         if new_name is not None:
-            data['new_name'] = new_name
+            data["new_name"] = new_name
         super().__init__(**data)
 
     def to_yaml_dict(self) -> SelectInputYaml:
@@ -114,7 +202,7 @@ class SelectInput(BaseModel):
             is_altered=old_name != new_name,
         )
 
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def set_default_new_name(self):
         """If new_name is None, default it to old_name."""
         if self.new_name is None:
@@ -137,76 +225,205 @@ class SelectInput(BaseModel):
     def polars_type(self) -> str:
         """Translates a user-friendly type name to a Polars data type string."""
         data_type_lower = self.data_type.lower()
-        if data_type_lower == 'string':
-            return 'Utf8'
-        elif data_type_lower == 'integer':
-            return 'Int64'
-        elif data_type_lower == 'double':
-            return 'Float64'
+        if data_type_lower == "string":
+            return "Utf8"
+        elif data_type_lower == "integer":
+            return "Int64"
+        elif data_type_lower == "double":
+            return "Float64"
         return self.data_type
 
 
 class FieldInput(BaseModel):
     """Represents a single field with its name and data type, typically for defining an output column."""
+
     name: str
     data_type: DataType | Literal["Auto"] | DataTypeStr | None = AUTO_DATA_TYPE
 
 
 class FunctionInput(BaseModel):
     """Defines a formula to be applied, including the output field information."""
+
     field: FieldInput
     function: str
 
     def __init__(self, field: FieldInput = None, function: str = None, **data):
         if field is not None:
-            data['field'] = field
+            data["field"] = field
         if function is not None:
-            data['function'] = function
+            data["function"] = function
         super().__init__(**data)
 
 
 class BasicFilter(BaseModel):
-    """Defines a simple, single-condition filter (e.g., 'column' 'equals' 'value')."""
-    field: Optional[str] = ''
-    filter_type: Optional[str] = ''
-    filter_value: Optional[str] = ''
+    """Defines a simple, single-condition filter (e.g., 'column' 'equals' 'value').
+
+    Attributes:
+        field: The column name to filter on.
+        operator: The comparison operator (FilterOperator enum value or symbol).
+        value: The value to compare against.
+        value2: Second value for BETWEEN operator (optional).
+    """
+
+    field: str = ""
+    operator: FilterOperator | str = FilterOperator.EQUALS
+    value: str = ""
+    value2: str | None = None  # For BETWEEN operator
+
+    # Keep old field names for backward compatibility
+    filter_type: str | None = None
+    filter_value: str | None = None
+
+    def __init__(
+        self,
+        field: str = None,
+        operator: FilterOperator | str = None,
+        value: str = None,
+        value2: str = None,
+        # Backward compatibility parameters
+        filter_type: str = None,
+        filter_value: str = None,
+        **data,
+    ):
+        # Handle backward compatibility
+        if filter_type is not None and operator is None:
+            data["operator"] = filter_type
+        elif operator is not None:
+            data["operator"] = operator
+
+        if filter_value is not None and value is None:
+            data["value"] = filter_value
+        elif value is not None:
+            data["value"] = value
 
-    def __init__(self, field: str = None, filter_type: str = None, filter_value: str = None, **data):
         if field is not None:
-            data['field'] = field
-        if filter_type is not None:
-            data['filter_type'] = filter_type
-        if filter_value is not None:
-            data['filter_value'] = filter_value
+            data["field"] = field
+        if value2 is not None:
+            data["value2"] = value2
+
         super().__init__(**data)
 
+    @model_validator(mode="after")
+    def normalize_operator(self):
+        """Normalize the operator to FilterOperator enum."""
+        if isinstance(self.operator, str):
+            try:
+                self.operator = FilterOperator.from_symbol(self.operator)
+            except ValueError:
+                # Keep as string if conversion fails (for backward compat)
+                pass
+        return self
+
+    def get_operator(self) -> FilterOperator:
+        """Get the operator as FilterOperator enum."""
+        if isinstance(self.operator, FilterOperator):
+            return self.operator
+        return FilterOperator.from_symbol(self.operator)
+
+    def to_yaml_dict(self) -> BasicFilterYaml:
+        """Serialize for YAML output."""
+        result: BasicFilterYaml = {
+            "field": self.field,
+            "operator": self.operator.value if isinstance(self.operator, FilterOperator) else self.operator,
+            "value": self.value,
+        }
+        if self.value2:
+            result["value2"] = self.value2
+        return result
+
+    @classmethod
+    def from_yaml_dict(cls, data: dict) -> "BasicFilter":
+        """Load from YAML format."""
+        return cls(
+            field=data.get("field", ""),
+            operator=data.get("operator", FilterOperator.EQUALS),
+            value=data.get("value", ""),
+            value2=data.get("value2"),
+        )
+
 
 class FilterInput(BaseModel):
-    """Defines the settings for a filter operation, supporting basic or advanced (expression-based) modes."""
-    advanced_filter: Optional[str] = ''
-    basic_filter: Optional[BasicFilter] = None
-    filter_type: Optional[str] = 'basic'
+    """Defines the settings for a filter operation, supporting basic or advanced (expression-based) modes.
+
+    Attributes:
+        mode: The filter mode - "basic" or "advanced".
+        basic_filter: The basic filter configuration (used when mode="basic").
+        advanced_filter: The advanced filter expression string (used when mode="advanced").
+    """
+
+    mode: FilterModeLiteral = "basic"
+    basic_filter: BasicFilter | None = None
+    advanced_filter: str = ""
+
+    # Keep old field name for backward compatibility
+    filter_type: str | None = None
+
+    def __init__(
+        self,
+        mode: FilterModeLiteral = None,
+        basic_filter: BasicFilter = None,
+        advanced_filter: str = None,
+        # Backward compatibility
+        filter_type: str = None,
+        **data,
+    ):
+        # Handle backward compatibility: filter_type -> mode
+        if filter_type is not None and mode is None:
+            data["mode"] = filter_type
+        elif mode is not None:
+            data["mode"] = mode
 
-    def __init__(self, advanced_filter: str = None, basic_filter: BasicFilter = None,
-                 filter_type: str = None, **data):
         if advanced_filter is not None:
-            data['advanced_filter'] = advanced_filter
+            data["advanced_filter"] = advanced_filter
         if basic_filter is not None:
-            data['basic_filter'] = basic_filter
-        if filter_type is not None:
-            data['filter_type'] = filter_type
+            data["basic_filter"] = basic_filter
+
         super().__init__(**data)
 
+    @model_validator(mode="after")
+    def ensure_basic_filter(self):
+        """Ensure basic_filter exists when mode is basic."""
+        if self.mode == "basic" and self.basic_filter is None:
+            self.basic_filter = BasicFilter()
+        return self
+
+    def is_advanced(self) -> bool:
+        """Check if filter is in advanced mode."""
+        return self.mode == "advanced"
+
+    def to_yaml_dict(self) -> FilterInputYaml:
+        """Serialize for YAML output."""
+        result: FilterInputYaml = {"mode": self.mode}
+        if self.mode == "basic" and self.basic_filter:
+            result["basic_filter"] = self.basic_filter.to_yaml_dict()
+        elif self.mode == "advanced" and self.advanced_filter:
+            result["advanced_filter"] = self.advanced_filter
+        return result
+
+    @classmethod
+    def from_yaml_dict(cls, data: dict) -> "FilterInput":
+        """Load from YAML format."""
+        mode = data.get("mode", "basic")
+        basic_filter = None
+        if "basic_filter" in data:
+            basic_filter = BasicFilter.from_yaml_dict(data["basic_filter"])
+        return cls(
+            mode=mode,
+            basic_filter=basic_filter,
+            advanced_filter=data.get("advanced_filter", ""),
+        )
+
 
 class SelectInputs(BaseModel):
     """A container for a list of `SelectInput` objects (pure data, no logic)."""
-    renames: List[SelectInput] = Field(default_factory=list)
 
-    def __init__(self, renames: List[SelectInput] = None, **kwargs):
+    renames: list[SelectInput] = Field(default_factory=list)
+
+    def __init__(self, renames: list[SelectInput] = None, **kwargs):
         if renames is not None:
-            kwargs['renames'] = renames
+            kwargs["renames"] = renames
         else:
-            kwargs['renames'] = []
+            kwargs["renames"] = []
         super().__init__(**kwargs)
 
     def to_yaml_dict(self) -> JoinInputsYaml:
@@ -220,7 +437,7 @@ class SelectInputs(BaseModel):
         return cls(renames=[SelectInput.from_yaml_dict(item) for item in items])
 
     @classmethod
-    def create_from_list(cls, col_list: List[str]) -> "SelectInputs":
+    def create_from_list(cls, col_list: list[str]) -> "SelectInputs":
         """Creates a SelectInputs object from a simple list of column names."""
         return cls(renames=[SelectInput(old_name=c) for c in col_list])
 
@@ -229,31 +446,36 @@ class SelectInputs(BaseModel):
         """Creates a SelectInputs object from a Polars DataFrame's columns."""
         return cls(renames=[SelectInput(old_name=c) for c in df.columns])
 
+    def remove_select_input(self, old_key: str) -> None:
+        """Removes a SelectInput from the list based on its original name."""
+        self.renames = [rename for rename in self.renames if rename.old_name != old_key]
+
 
 class JoinInputs(SelectInputs):
     """Data model for join-specific select inputs (extends SelectInputs)."""
 
-    def __init__(self, renames: List[SelectInput] = None, **kwargs):
+    def __init__(self, renames: list[SelectInput] = None, **kwargs):
         if renames is not None:
-            kwargs['renames'] = renames
+            kwargs["renames"] = renames
         else:
-            kwargs['renames'] = []
+            kwargs["renames"] = []
         super().__init__(**kwargs)
 
 
 class JoinMap(BaseModel):
     """Defines a single mapping between a left and right column for a join key."""
-    left_col: Optional[str] = None
-    right_col: Optional[str] = None
+
+    left_col: str | None = None
+    right_col: str | None = None
 
     def __init__(self, left_col: str = None, right_col: str = None, **data):
         if left_col is not None:
-            data['left_col'] = left_col
+            data["left_col"] = left_col
         if right_col is not None:
-            data['right_col'] = right_col
+            data["right_col"] = right_col
         super().__init__(**data)
 
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def set_default_right_col(self):
         """If right_col is None, default it to left_col."""
         if self.right_col is None:
@@ -263,30 +485,31 @@ class JoinMap(BaseModel):
 
 class CrossJoinInput(BaseModel):
     """Data model for cross join operations."""
+
     left_select: JoinInputs
     right_select: JoinInputs
 
-    @model_validator(mode='before')
+    @model_validator(mode="before")
     @classmethod
     def parse_inputs(cls, data: Any) -> Any:
         """Parse flexible input formats before validation."""
         if isinstance(data, dict):
             # Parse join_mapping
-            if 'join_mapping' in data:
-                data['join_mapping'] = cls._parse_join_mapping(data['join_mapping'])
+            if "join_mapping" in data:
+                data["join_mapping"] = cls._parse_join_mapping(data["join_mapping"])
 
             # Parse left_select
-            if 'left_select' in data:
-                data['left_select'] = cls._parse_select(data['left_select'])
+            if "left_select" in data:
+                data["left_select"] = cls._parse_select(data["left_select"])
 
             # Parse right_select
-            if 'right_select' in data:
-                data['right_select'] = cls._parse_select(data['right_select'])
+            if "right_select" in data:
+                data["right_select"] = cls._parse_select(data["right_select"])
 
         return data
 
     @staticmethod
-    def _parse_join_mapping(join_mapping: Any) -> List[JoinMap]:
+    def _parse_join_mapping(join_mapping: Any) -> list[JoinMap]:
         """Parse various join_mapping formats."""
         # Already a list of JoinMaps
         if isinstance(join_mapping, list):
@@ -336,22 +559,24 @@ class CrossJoinInput(BaseModel):
 
         # Dict with 'select' (new YAML) or 'renames' (internal) key
         if isinstance(select, dict):
-            if 'select' in select:
-                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select['select']])
-            if 'renames' in select:
+            if "select" in select:
+                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select["select"]])
+            if "renames" in select:
                 return JoinInputs(**select)
 
         raise ValueError(f"Invalid select format: {type(select)}")
 
-    def __init__(self,
-                 left_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 right_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 **data):
+    def __init__(
+        self,
+        left_select: JoinInputs | list[SelectInput] | list[str] = None,
+        right_select: JoinInputs | list[SelectInput] | list[str] = None,
+        **data,
+    ):
         """Custom init for backward compatibility with positional arguments."""
         if left_select is not None:
-            data['left_select'] = left_select
+            data["left_select"] = left_select
         if right_select is not None:
-            data['right_select'] = right_select
+            data["right_select"] = right_select
         super().__init__(**data)
 
     def to_yaml_dict(self) -> CrossJoinInputYaml:
@@ -361,35 +586,43 @@ class CrossJoinInput(BaseModel):
             "right_select": self.right_select.to_yaml_dict(),
         }
 
+    def add_new_select_column(self, select_input: SelectInput, side: str) -> None:
+        """Adds a new column to the selection for either the left or right side."""
+        target_input = self.right_select if side == "right" else self.left_select
+        if select_input.new_name is None:
+            select_input.new_name = select_input.old_name
+        target_input.renames.append(select_input)
+
 
 class JoinInput(BaseModel):
     """Data model for standard SQL-style join operations."""
-    join_mapping: List[JoinMap]
+
+    join_mapping: list[JoinMap]
     left_select: JoinInputs
     right_select: JoinInputs
-    how: JoinStrategy = 'inner'
+    how: JoinStrategy = "inner"
 
-    @model_validator(mode='before')
+    @model_validator(mode="before")
     @classmethod
     def parse_inputs(cls, data: Any) -> Any:
         """Parse flexible input formats before validation."""
         if isinstance(data, dict):
             # Parse join_mapping
-            if 'join_mapping' in data:
-                data['join_mapping'] = cls._parse_join_mapping(data['join_mapping'])
+            if "join_mapping" in data:
+                data["join_mapping"] = cls._parse_join_mapping(data["join_mapping"])
 
             # Parse left_select
-            if 'left_select' in data:
-                data['left_select'] = cls._parse_select(data['left_select'])
+            if "left_select" in data:
+                data["left_select"] = cls._parse_select(data["left_select"])
 
             # Parse right_select
-            if 'right_select' in data:
-                data['right_select'] = cls._parse_select(data['right_select'])
+            if "right_select" in data:
+                data["right_select"] = cls._parse_select(data["right_select"])
 
         return data
 
     @staticmethod
-    def _parse_join_mapping(join_mapping: Any) -> List[JoinMap]:
+    def _parse_join_mapping(join_mapping: Any) -> list[JoinMap]:
         """Parse various join_mapping formats."""
         # Already a list of JoinMaps
         if isinstance(join_mapping, list):
@@ -439,28 +672,30 @@ class JoinInput(BaseModel):
 
         # Dict with 'select' (new YAML) or 'renames' (internal) key
         if isinstance(select, dict):
-            if 'select' in select:
-                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select['select']])
-            if 'renames' in select:
+            if "select" in select:
+                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select["select"]])
+            if "renames" in select:
                 return JoinInputs(**select)
 
         raise ValueError(f"Invalid select format: {type(select)}")
 
-    def __init__(self,
-                 join_mapping: Union[List[JoinMap], JoinMap, Tuple[str, str], str, List[Tuple], List[str]] = None,
-                 left_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 right_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 how: JoinStrategy = 'inner',
-                 **data):
+    def __init__(
+        self,
+        join_mapping: list[JoinMap] | JoinMap | tuple[str, str] | str | list[tuple] | list[str] = None,
+        left_select: JoinInputs | list[SelectInput] | list[str] = None,
+        right_select: JoinInputs | list[SelectInput] | list[str] = None,
+        how: JoinStrategy = "inner",
+        **data,
+    ):
         """Custom init for backward compatibility with positional arguments."""
         if join_mapping is not None:
-            data['join_mapping'] = join_mapping
+            data["join_mapping"] = join_mapping
         if left_select is not None:
-            data['left_select'] = left_select
+            data["left_select"] = left_select
         if right_select is not None:
-            data['right_select'] = right_select
+            data["right_select"] = right_select
         if how is not None:
-            data['how'] = how
+            data["how"] = how
 
         super().__init__(**data)
 
@@ -473,24 +708,34 @@ class JoinInput(BaseModel):
             "how": self.how,
         }
 
+    def add_new_select_column(self, select_input: SelectInput, side: str) -> None:
+        """Adds a new column to the selection for either the left or right side."""
+        target_input = self.right_select if side == "right" else self.left_select
+        if select_input.new_name is None:
+            select_input.new_name = select_input.old_name
+        target_input.renames.append(select_input)
+
 
 class FuzzyMatchInput(BaseModel):
     """Data model for fuzzy matching join operations."""
-    join_mapping: List[FuzzyMapping]
+
+    join_mapping: list[FuzzyMapping]
     left_select: JoinInputs
     right_select: JoinInputs
-    how: JoinStrategy = 'inner'
+    how: JoinStrategy = "inner"
     aggregate_output: bool = False
 
-    def __init__(self,
-                 left_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 right_select: Union[JoinInputs, List[SelectInput], List[str]] = None,
-                 **data):
+    def __init__(
+        self,
+        left_select: JoinInputs | list[SelectInput] | list[str] = None,
+        right_select: JoinInputs | list[SelectInput] | list[str] = None,
+        **data,
+    ):
         """Custom init for backward compatibility with positional arguments."""
         if left_select is not None:
-            data['left_select'] = left_select
+            data["left_select"] = left_select
         if right_select is not None:
-            data['right_select'] = right_select
+            data["right_select"] = right_select
 
         super().__init__(**data)
 
@@ -504,6 +749,13 @@ class FuzzyMatchInput(BaseModel):
             "aggregate_output": self.aggregate_output,
         }
 
+    def add_new_select_column(self, select_input: SelectInput, side: str) -> None:
+        """Adds a new column to the selection for either the left or right side."""
+        target_input = self.right_select if side == "right" else self.left_select
+        if select_input.new_name is None:
+            select_input.new_name = select_input.old_name
+        target_input.renames.append(select_input)
+
     @staticmethod
     def _parse_select(select: Any) -> JoinInputs:
         """Parse various select input formats."""
@@ -522,25 +774,25 @@ class FuzzyMatchInput(BaseModel):
 
         # Dict with 'select' (new YAML) or 'renames' (internal) key
         if isinstance(select, dict):
-            if 'select' in select:
-                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select['select']])
-            if 'renames' in select:
+            if "select" in select:
+                return JoinInputs(renames=[SelectInput.from_yaml_dict(s) for s in select["select"]])
+            if "renames" in select:
                 return JoinInputs(**select)
 
         raise ValueError(f"Invalid select format: {type(select)}")
 
-    @model_validator(mode='before')
+    @model_validator(mode="before")
     @classmethod
     def parse_inputs(cls, data: Any) -> Any:
         """Parse flexible input formats before validation."""
         if isinstance(data, dict):
             # Parse left_select
-            if 'left_select' in data:
-                data['left_select'] = cls._parse_select(data['left_select'])
+            if "left_select" in data:
+                data["left_select"] = cls._parse_select(data["left_select"])
 
             # Parse right_select
-            if 'right_select' in data:
-                data['right_select'] = cls._parse_select(data['right_select'])
+            if "right_select" in data:
+                data["right_select"] = cls._parse_select(data["right_select"])
 
         return data
 
@@ -574,26 +826,27 @@ class AggColl(BaseModel):
         output_type='float'
     )
     """
+
     old_name: str
     agg: str
-    new_name: Optional[str] = None
-    output_type: Optional[str] = None
+    new_name: str | None = None
+    output_type: str | None = None
 
-    def __init__(self, old_name: str, agg: str, new_name: Optional[str] = None, output_type: Optional[str] = None):
-        data = {'old_name': old_name, 'agg': agg}
+    def __init__(self, old_name: str, agg: str, new_name: str | None = None, output_type: str | None = None):
+        data = {"old_name": old_name, "agg": agg}
         if new_name is not None:
-            data['new_name'] = new_name
+            data["new_name"] = new_name
         if output_type is not None:
-            data['output_type'] = output_type
+            data["output_type"] = output_type
 
         super().__init__(**data)
 
-    @model_validator(mode='after')
+    @model_validator(mode="after")
     def set_defaults(self):
         """Set default new_name and output_type based on agg function."""
         # Set new_name
         if self.new_name is None:
-            if self.agg != 'groupby':
+            if self.agg != "groupby":
                 self.new_name = self.old_name + "_" + self.agg
             else:
                 self.new_name = self.old_name
@@ -610,9 +863,9 @@ class AggColl(BaseModel):
     @property
     def agg_func(self):
         """Returns the corresponding Polars aggregation function from the `agg` string."""
-        if self.agg == 'groupby':
+        if self.agg == "groupby":
             return self.agg
-        elif self.agg == 'concat':
+        elif self.agg == "concat":
             return string_concat
         else:
             return getattr(pl, self.agg) if isinstance(self.agg, str) else self.agg
@@ -636,33 +889,36 @@ class GroupByInput(BaseModel):
                   AggColl(old_name='col1', agg='sum'), AggColl(old_name='col2', agg='mean')]
     )
     """
-    agg_cols: List[AggColl]
 
-    def __init__(self, agg_cols: List[AggColl]):
+    agg_cols: list[AggColl]
+
+    def __init__(self, agg_cols: list[AggColl]):
         """Backwards compatibility implementation"""
         super().__init__(agg_cols=agg_cols)
 
 
 class PivotInput(BaseModel):
     """Defines the settings for a pivot (long-to-wide) operation."""
-    index_columns: List[str]
+
+    index_columns: list[str]
     pivot_column: str
     value_col: str
-    aggregations: List[str]
+    aggregations: list[str]
 
     @property
-    def grouped_columns(self) -> List[str]:
+    def grouped_columns(self) -> list[str]:
         """Returns the list of columns to be used for the initial grouping stage of the pivot."""
         return self.index_columns + [self.pivot_column]
 
     def get_group_by_input(self) -> GroupByInput:
         """Constructs the `GroupByInput` needed for the pre-aggregation step of the pivot."""
-        group_by_cols = [AggColl(old_name=c, agg='groupby') for c in self.grouped_columns]
-        agg_cols = [AggColl(old_name=self.value_col, agg=aggregation, new_name=aggregation)
-                    for aggregation in self.aggregations]
+        group_by_cols = [AggColl(old_name=c, agg="groupby") for c in self.grouped_columns]
+        agg_cols = [
+            AggColl(old_name=self.value_col, agg=aggregation, new_name=aggregation) for aggregation in self.aggregations
+        ]
         return GroupByInput(agg_cols=group_by_cols + agg_cols)
 
-    def get_index_columns(self) -> List[pl.col]:
+    def get_index_columns(self) -> list[pl.col]:
         """Returns the index columns as Polars column expressions."""
         return [pl.col(c) for c in self.index_columns]
 
@@ -672,50 +928,54 @@ class PivotInput(BaseModel):
 
     def get_values_expr(self) -> pl.Expr:
         """Creates the struct expression used to gather the values for pivoting."""
-        return pl.struct([pl.col(c) for c in self.aggregations]).alias('vals')
+        return pl.struct([pl.col(c) for c in self.aggregations]).alias("vals")
 
 
 class SortByInput(BaseModel):
     """Defines a single sort condition on a column, including the direction."""
+
     column: str
-    how: Optional[str] = 'asc'
+    how: str | None = "asc"
 
 
 class RecordIdInput(BaseModel):
     """Defines settings for adding a record ID (row number) column to the data."""
-    output_column_name: str = 'record_id'
+
+    output_column_name: str = "record_id"
     offset: int = 1
-    group_by: Optional[bool] = False
-    group_by_columns: Optional[List[str]] = Field(default_factory=list)
+    group_by: bool | None = False
+    group_by_columns: list[str] | None = Field(default_factory=list)
 
 
 class TextToRowsInput(BaseModel):
     """Defines settings for splitting a text column into multiple rows based on a delimiter."""
+
     column_to_split: str
-    output_column_name: Optional[str] = None
-    split_by_fixed_value: Optional[bool] = True
-    split_fixed_value: Optional[str] = ','
-    split_by_column: Optional[str] = None
+    output_column_name: str | None = None
+    split_by_fixed_value: bool | None = True
+    split_fixed_value: str | None = ","
+    split_by_column: str | None = None
 
 
 class UnpivotInput(BaseModel):
     """Defines settings for an unpivot (wide-to-long) operation."""
+
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    index_columns: List[str] = Field(default_factory=list)
-    value_columns: List[str] = Field(default_factory=list)
-    data_type_selector: Optional[Literal['float', 'all', 'date', 'numeric', 'string']] = None
-    data_type_selector_mode: Literal['data_type', 'column'] = 'column'
+    index_columns: list[str] = Field(default_factory=list)
+    value_columns: list[str] = Field(default_factory=list)
+    data_type_selector: Literal["float", "all", "date", "numeric", "string"] | None = None
+    data_type_selector_mode: Literal["data_type", "column"] = "column"
 
     @property
-    def data_type_selector_expr(self) -> Optional[Callable]:
+    def data_type_selector_expr(self) -> Callable | None:
         """Returns a Polars selector function based on the `data_type_selector` string."""
-        if self.data_type_selector_mode == 'data_type':
+        if self.data_type_selector_mode == "data_type":
             if self.data_type_selector is not None:
                 try:
                     return getattr(selectors, self.data_type_selector)
-                except Exception as e:
-                    print(f'Could not find the selector: {self.data_type_selector}')
+                except Exception:
+                    print(f"Could not find the selector: {self.data_type_selector}")
                     return selectors.all
             return selectors.all
         return None
@@ -723,24 +983,28 @@ class UnpivotInput(BaseModel):
 
 class UnionInput(BaseModel):
     """Defines settings for a union (concatenation) operation."""
-    mode: Literal['selective', 'relaxed'] = 'relaxed'
+
+    mode: Literal["selective", "relaxed"] = "relaxed"
 
 
 class UniqueInput(BaseModel):
     """Defines settings for a uniqueness operation, specifying columns and which row to keep."""
-    columns: Optional[List[str]] = None
+
+    columns: list[str] | None = None
     strategy: Literal["first", "last", "any", "none"] = "any"
 
 
 class GraphSolverInput(BaseModel):
     """Defines settings for a graph-solving operation (e.g., finding connected components)."""
+
     col_from: str
     col_to: str
-    output_column_name: Optional[str] = 'graph_group'
+    output_column_name: str | None = "graph_group"
 
 
 class PolarsCodeInput(BaseModel):
     """A simple container for a string of user-provided Polars code to be executed."""
+
     polars_code: str
 
 
@@ -752,42 +1016,39 @@ class SelectInputsManager:
 
     # === Query Methods (read-only) ===
 
-    def get_old_cols(self) -> Set[str]:
+    def get_old_cols(self) -> set[str]:
         """Returns a set of original column names to be kept in the selection."""
         return set(v.old_name for v in self.select_inputs.renames if v.keep)
 
-    def get_new_cols(self) -> Set[str]:
+    def get_new_cols(self) -> set[str]:
         """Returns a set of new (renamed) column names to be kept in the selection."""
         return set(v.new_name for v in self.select_inputs.renames if v.keep)
 
     def get_rename_table(self) -> dict[str, str]:
         """Generates a dictionary for use in Polars' `.rename()` method."""
-        return {v.old_name: v.new_name for v in self.select_inputs.renames
-                if v.is_available and (v.keep or v.join_key)}
+        return {v.old_name: v.new_name for v in self.select_inputs.renames if v.is_available and (v.keep or v.join_key)}
 
-    def get_select_cols(self, include_join_key: bool = True) -> List[str]:
+    def get_select_cols(self, include_join_key: bool = True) -> list[str]:
         """Gets a list of original column names to select from the source DataFrame."""
-        return [v.old_name for v in self.select_inputs.renames
-                if v.keep or (v.join_key and include_join_key)]
+        return [v.old_name for v in self.select_inputs.renames if v.keep or (v.join_key and include_join_key)]
 
     def has_drop_cols(self) -> bool:
         """Checks if any column is marked to be dropped from the selection."""
         return any(not v.keep for v in self.select_inputs.renames)
 
-    def get_drop_columns(self) -> List[SelectInput]:
+    def get_drop_columns(self) -> list[SelectInput]:
         """Returns a list of SelectInput objects that are marked to be dropped."""
         return [v for v in self.select_inputs.renames if not v.keep and v.is_available]
 
-    def get_non_jk_drop_columns(self) -> List[SelectInput]:
+    def get_non_jk_drop_columns(self) -> list[SelectInput]:
         """Returns drop columns that are not join keys."""
-        return [v for v in self.select_inputs.renames
-                if not v.keep and v.is_available and not v.join_key]
+        return [v for v in self.select_inputs.renames if not v.keep and v.is_available and not v.join_key]
 
-    def find_by_old_name(self, old_name: str) -> Optional[SelectInput]:
+    def find_by_old_name(self, old_name: str) -> SelectInput | None:
         """Find SelectInput by original column name."""
         return next((v for v in self.select_inputs.renames if v.old_name == old_name), None)
 
-    def find_by_new_name(self, new_name: str) -> Optional[SelectInput]:
+    def find_by_new_name(self, new_name: str) -> SelectInput | None:
         """Find SelectInput by new column name."""
         return next((v for v in self.select_inputs.renames if v.new_name == new_name), None)
 
@@ -799,10 +1060,7 @@ class SelectInputsManager:
 
     def remove_select_input(self, old_key: str) -> None:
         """Removes a SelectInput from the list based on its original name."""
-        self.select_inputs.renames = [
-            rename for rename in self.select_inputs.renames
-            if rename.old_name != old_key
-        ]
+        self.select_inputs.renames = [rename for rename in self.select_inputs.renames if rename.old_name != old_key]
 
     def unselect_field(self, old_key: str) -> None:
         """Marks a field to be dropped from the final selection by setting `keep` to False."""
@@ -813,12 +1071,12 @@ class SelectInputsManager:
     # === Backward Compatibility Properties ===
 
     @property
-    def old_cols(self) -> Set[str]:
+    def old_cols(self) -> set[str]:
         """Backward compatibility: Returns set of old column names."""
         return self.get_old_cols()
 
     @property
-    def new_cols(self) -> Set[str]:
+    def new_cols(self) -> set[str]:
         """Backward compatibility: Returns set of new column names."""
         return self.get_new_cols()
 
@@ -828,25 +1086,25 @@ class SelectInputsManager:
         return self.get_rename_table()
 
     @property
-    def drop_columns(self) -> List[SelectInput]:
+    def drop_columns(self) -> list[SelectInput]:
         """Backward compatibility: Returns list of columns to drop."""
         return self.get_drop_columns()
 
     @property
-    def non_jk_drop_columns(self) -> List[SelectInput]:
+    def non_jk_drop_columns(self) -> list[SelectInput]:
         """Backward compatibility: Returns non-join-key columns to drop."""
         return self.get_non_jk_drop_columns()
 
     @property
-    def renames(self) -> List[SelectInput]:
+    def renames(self) -> list[SelectInput]:
         """Backward compatibility: Direct access to renames list."""
         return self.select_inputs.renames
 
-    def get_select_input_on_old_name(self, old_name: str) -> Optional[SelectInput]:
+    def get_select_input_on_old_name(self, old_name: str) -> SelectInput | None:
         """Backward compatibility alias: Find SelectInput by original column name."""
         return self.find_by_old_name(old_name)
 
-    def get_select_input_on_new_name(self, new_name: str) -> Optional[SelectInput]:
+    def get_select_input_on_new_name(self, new_name: str) -> SelectInput | None:
         """Backward compatibility alias: Find SelectInput by new column name."""
         return self.find_by_new_name(new_name)
 
@@ -865,7 +1123,7 @@ class JoinInputsManager(SelectInputsManager):
 
     # === Query Methods ===
 
-    def get_join_key_selects(self) -> List[SelectInput]:
+    def get_join_key_selects(self) -> list[SelectInput]:
         """Returns only the `SelectInput` objects that are marked as join keys."""
         return [v for v in self.join_inputs.renames if v.join_key]
 
@@ -879,13 +1137,13 @@ class JoinInputsManager(SelectInputsManager):
         ]
         return JoinKeyRenameResponse(side, join_key_list)
 
-    def get_join_key_rename_mapping(self, side: SideLit) -> Dict[str, str]:
+    def get_join_key_rename_mapping(self, side: SideLit) -> dict[str, str]:
         """Returns a dictionary mapping original join key names to their temporary names."""
         join_key_response = self.get_join_key_renames(side)
         return {jkr.original_name: jkr.temp_name for jkr in join_key_response.join_key_renames}
 
     @property
-    def join_key_selects(self) -> List[SelectInput]:
+    def join_key_selects(self) -> list[SelectInput]:
         """Backward compatibility: Returns join key SelectInputs."""
         return self.get_join_key_selects()
 
@@ -895,10 +1153,10 @@ class JoinSelectManagerMixin:
 
     left_manager: JoinInputsManager
     right_manager: JoinInputsManager
-    input: Union[CrossJoinInput, JoinInput, FuzzyMatchInput]
+    input: CrossJoinInput | JoinInput | FuzzyMatchInput
 
     @staticmethod
-    def parse_select(select: Union[List[SelectInput], List[str], List[Dict], Dict]) -> JoinInputs:
+    def parse_select(select: list[SelectInput] | list[str] | list[dict] | dict) -> JoinInputs:
         """Parses various input formats into a standardized `JoinInputs` object."""
         if not select:
             return JoinInputs(renames=[])
@@ -908,7 +1166,7 @@ class JoinSelectManagerMixin:
         elif all(isinstance(c, dict) for c in select):
             return JoinInputs(renames=[SelectInput(**c) for c in select])
         elif isinstance(select, dict):
-            renames = select.get('renames')
+            renames = select.get("renames")
             if renames:
                 return JoinInputs(renames=[SelectInput(**c) for c in renames])
             return JoinInputs(renames=[])
@@ -917,7 +1175,7 @@ class JoinSelectManagerMixin:
 
         raise ValueError(f"Unable to parse select input: {type(select)}")
 
-    def get_overlapping_columns(self) -> Set[str]:
+    def get_overlapping_columns(self) -> set[str]:
         """Finds column names that would conflict after the join."""
         return self.left_manager.get_new_cols() & self.right_manager.get_new_cols()
 
@@ -929,16 +1187,14 @@ class JoinSelectManagerMixin:
 
         new_name = old_col_name
         while new_name in current_names:
-            new_name = f'{side}_{new_name}'
+            new_name = f"{side}_{new_name}"
         return new_name
 
     def add_new_select_column(self, select_input: SelectInput, side: str) -> None:
         """Adds a new column to the selection for either the left or right side."""
-        target_input = self.input.right_select if side == 'right' else self.input.left_select
+        target_input = self.input.right_select if side == "right" else self.input.left_select
 
-        select_input.new_name = self.auto_generate_new_col_name(
-            select_input.old_name, side=side
-        )
+        select_input.new_name = self.auto_generate_new_col_name(select_input.old_name, side=side)
 
         target_input.renames.append(select_input)
 
@@ -952,19 +1208,17 @@ class CrossJoinInputManager(JoinSelectManagerMixin):
         self.right_manager = JoinInputsManager(self.input.right_select)
 
     @classmethod
-    def create(cls, left_select: Union[List[SelectInput], List[str]],
-               right_select: Union[List[SelectInput], List[str]]) -> "CrossJoinInputManager":
+    def create(
+        cls, left_select: list[SelectInput] | list[str], right_select: list[SelectInput] | list[str]
+    ) -> "CrossJoinInputManager":
         """Factory method to create CrossJoinInput from various input formats."""
         left_inputs = cls.parse_select(left_select)
         right_inputs = cls.parse_select(right_select)
 
-        cross_join = CrossJoinInput(
-            left_select=left_inputs,
-            right_select=right_inputs
-        )
+        cross_join = CrossJoinInput(left_select=left_inputs, right_select=right_inputs)
         return cls(cross_join)
 
-    def get_overlapping_records(self) -> Set[str]:
+    def get_overlapping_records(self) -> set[str]:
         """Finds column names that would conflict after the join."""
         return self.get_overlapping_columns()
 
@@ -976,11 +1230,11 @@ class CrossJoinInputManager(JoinSelectManagerMixin):
             for right_col in self.input.right_select.renames:
                 if right_col.new_name in overlapping_records:
                     if rename_mode == "prefix":
-                        right_col.new_name = 'right_' + right_col.new_name
+                        right_col.new_name = "right_" + right_col.new_name
                     elif rename_mode == "suffix":
-                        right_col.new_name = right_col.new_name + '_right'
+                        right_col.new_name = right_col.new_name + "_right"
                     else:
-                        raise ValueError(f'Unknown rename_mode: {rename_mode}')
+                        raise ValueError(f"Unknown rename_mode: {rename_mode}")
             overlapping_records = self.get_overlapping_records()
 
     # === Backward Compatibility Properties ===
@@ -996,7 +1250,7 @@ class CrossJoinInputManager(JoinSelectManagerMixin):
         return self.right_manager
 
     @property
-    def overlapping_records(self) -> Set[str]:
+    def overlapping_records(self) -> set[str]:
         """Backward compatibility: Returns overlapping column names."""
         return self.get_overlapping_records()
 
@@ -1011,7 +1265,7 @@ class CrossJoinInputManager(JoinSelectManagerMixin):
         """
         return CrossJoinInput(
             left_select=JoinInputs(renames=self.input.left_select.renames.copy()),
-            right_select=JoinInputs(renames=self.input.right_select.renames.copy())
+            right_select=JoinInputs(renames=self.input.right_select.renames.copy()),
         )
 
 
@@ -1025,18 +1279,16 @@ class JoinInputManager(JoinSelectManagerMixin):
         self.set_join_keys()
 
     @classmethod
-    def create(cls, join_mapping: Union[List[JoinMap], Tuple[str, str], str],
-               left_select: Union[List[SelectInput], List[str]],
-               right_select: Union[List[SelectInput], List[str]],
-               how: JoinStrategy = 'inner') -> "JoinInputManager":
+    def create(
+        cls,
+        join_mapping: list[JoinMap] | tuple[str, str] | str,
+        left_select: list[SelectInput] | list[str],
+        right_select: list[SelectInput] | list[str],
+        how: JoinStrategy = "inner",
+    ) -> "JoinInputManager":
         """Factory method to create JoinInput from various input formats."""
         # Use JoinInput's own create method for parsing
-        join_input = JoinInput(
-            join_mapping=join_mapping,
-            left_select=left_select,
-            right_select=right_select,
-            how=how
-        )
+        join_input = JoinInput(join_mapping=join_mapping, left_select=left_select, right_select=right_select, how=how)
 
         manager = cls(join_input)
         manager.set_join_keys()
@@ -1053,31 +1305,31 @@ class JoinInputManager(JoinSelectManagerMixin):
         for select_input in self.input.right_select.renames:
             select_input.join_key = select_input.old_name in right_join_keys
 
-    def _get_left_join_keys_set(self) -> Set[str]:
+    def _get_left_join_keys_set(self) -> set[str]:
         """Internal: Returns a set of the left-side join key column names."""
         return {jm.left_col for jm in self.input.join_mapping}
 
-    def _get_right_join_keys_set(self) -> Set[str]:
+    def _get_right_join_keys_set(self) -> set[str]:
         """Internal: Returns a set of the right-side join key column names."""
         return {jm.right_col for jm in self.input.join_mapping}
 
-    def get_left_join_keys(self) -> Set[str]:
+    def get_left_join_keys(self) -> set[str]:
         """Returns a set of the left-side join key column names."""
         return self._get_left_join_keys_set()
 
-    def get_right_join_keys(self) -> Set[str]:
+    def get_right_join_keys(self) -> set[str]:
         """Returns a set of the right-side join key column names."""
         return self._get_right_join_keys_set()
 
-    def get_left_join_keys_list(self) -> List[str]:
+    def get_left_join_keys_list(self) -> list[str]:
         """Returns an ordered list of the left-side join key column names."""
         return [jm.left_col for jm in self.used_join_mapping]
 
-    def get_right_join_keys_list(self) -> List[str]:
+    def get_right_join_keys_list(self) -> list[str]:
         """Returns an ordered list of the right-side join key column names."""
         return [jm.right_col for jm in self.used_join_mapping]
 
-    def get_overlapping_records(self) -> Set[str]:
+    def get_overlapping_records(self) -> set[str]:
         """Finds column names that would conflict after the join."""
         return self.get_overlapping_columns()
 
@@ -1089,7 +1341,7 @@ class JoinInputManager(JoinSelectManagerMixin):
         while len(overlapping_records) > 0:
             for right_col in self.input.right_select.renames:
                 if right_col.new_name in overlapping_records:
-                    right_col.new_name = right_col.new_name + '_right'
+                    right_col.new_name = right_col.new_name + "_right"
             overlapping_records = self.get_overlapping_records()
 
     def get_join_key_renames(self, filter_drop: bool = False) -> FullJoinKeyResponse:
@@ -1098,9 +1350,9 @@ class JoinInputManager(JoinSelectManagerMixin):
         right_renames = self.right_manager.get_join_key_renames(side="right", filter_drop=filter_drop)
         return FullJoinKeyResponse(left_renames, right_renames)
 
-    def get_names_for_table_rename(self) -> List[JoinMap]:
+    def get_names_for_table_rename(self) -> list[JoinMap]:
         """Gets join mapping with renamed columns applied."""
-        new_mappings: List[JoinMap] = []
+        new_mappings: list[JoinMap] = []
         left_rename_table = self.left_manager.get_rename_table()
         right_rename_table = self.right_manager.get_rename_table()
 
@@ -1111,9 +1363,9 @@ class JoinInputManager(JoinSelectManagerMixin):
 
         return new_mappings
 
-    def get_used_join_mapping(self) -> List[JoinMap]:
+    def get_used_join_mapping(self) -> list[JoinMap]:
         """Returns the final join mapping after applying all renames and transformations."""
-        new_mappings: List[JoinMap] = []
+        new_mappings: list[JoinMap] = []
         left_rename_table = self.left_manager.get_rename_table()
         right_rename_table = self.right_manager.get_rename_table()
         left_join_rename_mapping = self.left_manager.get_join_key_rename_mapping("left")
@@ -1142,7 +1394,7 @@ class JoinInputManager(JoinSelectManagerMixin):
             join_mapping=self.input.join_mapping,
             left_select=JoinInputs(renames=self.input.left_select.renames.copy()),
             right_select=JoinInputs(renames=self.input.right_select.renames.copy()),
-            how=self.input.how
+            how=self.input.how,
         )
 
     @property
@@ -1169,17 +1421,17 @@ class JoinInputManager(JoinSelectManagerMixin):
         return self.input.how
 
     @property
-    def join_mapping(self) -> List[JoinMap]:
+    def join_mapping(self) -> list[JoinMap]:
         """Backward compatibility: Access join mapping."""
         return self.input.join_mapping
 
     @property
-    def overlapping_records(self) -> Set[str]:
+    def overlapping_records(self) -> set[str]:
         """Backward compatibility: Returns overlapping column names."""
         return self.get_overlapping_records()
 
     @property
-    def used_join_mapping(self) -> List[JoinMap]:
+    def used_join_mapping(self) -> list[JoinMap]:
         """Backward compatibility: Returns used join mapping.
 
         This property is critical - it's used by left_join_keys and right_join_keys.
@@ -1187,7 +1439,7 @@ class JoinInputManager(JoinSelectManagerMixin):
         return self.get_used_join_mapping()
 
     @property
-    def left_join_keys(self) -> List[str]:
+    def left_join_keys(self) -> list[str]:
         """Backward compatibility: Returns left join keys list.
 
         IMPORTANT: Uses the used_join_mapping PROPERTY (not method).
@@ -1195,7 +1447,7 @@ class JoinInputManager(JoinSelectManagerMixin):
         return [jm.left_col for jm in self.used_join_mapping]
 
     @property
-    def right_join_keys(self) -> List[str]:
+    def right_join_keys(self) -> list[str]:
         """Backward compatibility: Returns right join keys list.
 
         IMPORTANT: Uses the used_join_mapping PROPERTY (not method).
@@ -1203,12 +1455,12 @@ class JoinInputManager(JoinSelectManagerMixin):
         return [jm.right_col for jm in self.used_join_mapping]
 
     @property
-    def _left_join_keys(self) -> Set[str]:
+    def _left_join_keys(self) -> set[str]:
         """Backward compatibility: Private property for left join key set."""
         return self._get_left_join_keys_set()
 
     @property
-    def _right_join_keys(self) -> Set[str]:
+    def _right_join_keys(self) -> set[str]:
         """Backward compatibility: Private property for right join key set."""
         return self._get_right_join_keys_set()
 
@@ -1218,20 +1470,26 @@ class FuzzyMatchInputManager(JoinInputManager):
 
     def __init__(self, fuzzy_input: FuzzyMatchInput):
         self.fuzzy_input = deepcopy(fuzzy_input)
-        super().__init__(JoinInput(
-            join_mapping=[JoinMap(left_col=fm.left_col, right_col=fm.right_col)
-                          for fm in self.fuzzy_input.join_mapping],
-            left_select=self.fuzzy_input.left_select,
-            right_select=self.fuzzy_input.right_select,
-            how=self.fuzzy_input.how
-        ))
+        super().__init__(
+            JoinInput(
+                join_mapping=[
+                    JoinMap(left_col=fm.left_col, right_col=fm.right_col) for fm in self.fuzzy_input.join_mapping
+                ],
+                left_select=self.fuzzy_input.left_select,
+                right_select=self.fuzzy_input.right_select,
+                how=self.fuzzy_input.how,
+            )
+        )
 
     @classmethod
-    def create(cls, join_mapping: Union[List[FuzzyMapping], Tuple[str, str], str],
-               left_select: Union[List[SelectInput], List[str]],
-               right_select: Union[List[SelectInput], List[str]],
-               aggregate_output: bool = False,
-               how: JoinStrategy = 'inner') -> "FuzzyMatchInputManager":
+    def create(
+        cls,
+        join_mapping: list[FuzzyMapping] | tuple[str, str] | str,
+        left_select: list[SelectInput] | list[str],
+        right_select: list[SelectInput] | list[str],
+        aggregate_output: bool = False,
+        how: JoinStrategy = "inner",
+    ) -> "FuzzyMatchInputManager":
         """Factory method to create FuzzyMatchInput from various input formats."""
         parsed_mapping = cls.parse_fuzz_mapping(join_mapping)
         left_inputs = cls.parse_select(left_select)
@@ -1242,7 +1500,7 @@ class FuzzyMatchInputManager(JoinInputManager):
             left_select=left_inputs,
             right_select=right_inputs,
             how=how,
-            aggregate_output=aggregate_output
+            aggregate_output=aggregate_output,
         )
 
         manager = cls(fuzzy_input)
@@ -1252,20 +1510,17 @@ class FuzzyMatchInputManager(JoinInputManager):
 
         for jm in parsed_mapping:
             if jm.right_col not in right_old_names:
-                manager.right_manager.append(
-                    SelectInput(old_name=jm.right_col, keep=False, join_key=True)
-                )
+                manager.right_manager.append(SelectInput(old_name=jm.right_col, keep=False, join_key=True))
             if jm.left_col not in left_old_names:
-                manager.left_manager.append(
-                    SelectInput(old_name=jm.left_col, keep=False, join_key=True)
-                )
+                manager.left_manager.append(SelectInput(old_name=jm.left_col, keep=False, join_key=True))
 
         manager.set_join_keys()
         return manager
 
     @staticmethod
-    def parse_fuzz_mapping(fuzz_mapping: Union[List[FuzzyMapping], Tuple[str, str],
-                                               str, FuzzyMapping, List[Dict]]) -> List[FuzzyMapping]:
+    def parse_fuzz_mapping(
+        fuzz_mapping: list[FuzzyMapping] | tuple[str, str] | str | FuzzyMapping | list[dict],
+    ) -> list[FuzzyMapping]:
         """Parses various input formats into a list of FuzzyMapping objects."""
         if isinstance(fuzz_mapping, (tuple, list)):
             if len(fuzz_mapping) == 0:
@@ -1290,9 +1545,9 @@ class FuzzyMatchInputManager(JoinInputManager):
         elif isinstance(fuzz_mapping, FuzzyMapping):
             return [fuzz_mapping]
 
-        raise ValueError(f'No valid fuzzy mapping as input: {type(fuzz_mapping)}')
+        raise ValueError(f"No valid fuzzy mapping as input: {type(fuzz_mapping)}")
 
-    def get_fuzzy_maps(self) -> List[FuzzyMapping]:
+    def get_fuzzy_maps(self) -> list[FuzzyMapping]:
         """Returns the final fuzzy mappings after applying all column renames."""
         new_mappings = []
         left_rename_table = self.left_manager.get_rename_table()
@@ -1315,12 +1570,12 @@ class FuzzyMatchInputManager(JoinInputManager):
     # === Backward Compatibility Properties ===
 
     @property
-    def fuzzy_maps(self) -> List[FuzzyMapping]:
+    def fuzzy_maps(self) -> list[FuzzyMapping]:
         """Backward compatibility: Returns fuzzy mappings."""
         return self.get_fuzzy_maps()
 
     @property
-    def join_mapping(self) -> List[FuzzyMapping]:
+    def join_mapping(self) -> list[FuzzyMapping]:
         """Backward compatibility: Access fuzzy join mapping."""
         return self.get_fuzzy_maps()
 
@@ -1343,5 +1598,5 @@ class FuzzyMatchInputManager(JoinInputManager):
             left_select=JoinInputs(renames=self.input.left_select.renames.copy()),
             right_select=JoinInputs(renames=self.input.right_select.renames.copy()),
             how=self.fuzzy_input.how,
-            aggregate_output=self.fuzzy_input.aggregate_output
-        )
+            aggregate_output=self.fuzzy_input.aggregate_output,
+        )