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

flowfile_core/flowfile/node_designer/ui_components.py

@@ -1,19 +1,40 @@
-# ui_components.py - Updated ColumnSelector
+from typing import Any, Literal, NamedTuple
 
-from typing import List, Optional, Any, Literal, Union, Type, Tuple, Dict
-
-from pydantic import Field, BaseModel, computed_field
+from pydantic import BaseModel, Field, SecretStr, computed_field
 
 from flowfile_core.flowfile.node_designer._type_registry import normalize_type_spec
+from flowfile_core.secret_manager.secret_manager import decrypt_secret, get_encrypted_secret
+
 # Public API import
 from flowfile_core.types import DataType, TypeSpec
 
 InputType = Literal["text", "number", "secret", "array", "date", "boolean"]
 
 
-def normalize_input_to_data_types(
-    v: Any
-) -> Union[Literal["ALL"], List[DataType]]:
+class ActionOption(NamedTuple):
+    """
+    A named tuple representing an action option with a value and display label.
+
+    Use this to define actions with custom labels in ColumnActionInput:
+        actions=[
+            ActionOption("sum", "Sum"),
+            ActionOption("avg", "Average"),
+            "count"  # plain strings also work
+        ]
+    """
+
+    value: str
+    """The internal value used in the data."""
+
+    label: str
+    """The display label shown in the UI."""
+
+
+# Type alias for action specifications - accepts strings or ActionOption tuples
+ActionSpec = str | ActionOption
+
+
+def normalize_input_to_data_types(v: Any) -> Literal["ALL"] | list[DataType]:
     """
     Normalizes a wide variety of inputs to either 'ALL' or a sorted list of DataType enums.
     This function is used as a Pydantic BeforeValidator.
@@ -46,9 +67,10 @@ class FlowfileInComponent(BaseModel):
     It's not meant to be used directly, but rather to be inherited by specific
     component classes.
     """
+
     component_type: str = Field(..., description="Type of the UI component")
     value: Any = None
-    label: Optional[str] = None
+    label: str | None = None
     input_type: InputType
 
     def set_value(self, value: Any):
@@ -83,6 +105,7 @@ class IncomingColumns:
                 options=IncomingColumns
             )
     """
+
     pass
 
 
@@ -94,25 +117,21 @@ class ColumnSelector(FlowfileInComponent):
     This is particularly useful when a node operation should only be applied
     to columns of a specific type (e.g., numeric, string, date).
     """
+
     component_type: Literal["ColumnSelector"] = "ColumnSelector"
     required: bool = False
     multiple: bool = False
     input_type: InputType = "text"
 
     # Normalized output: either "ALL" or list of DataType enums
-    data_type_filter_input: TypeSpec = Field(
-        default="ALL",
-        alias="data_types",
-        repr=False,
-        exclude=True
-    )
+    data_type_filter_input: TypeSpec = Field(default="ALL", alias="data_types", repr=False, exclude=True)
 
     class Config:
         arbitrary_types_allowed = True
 
     @computed_field
     @property
-    def data_types_filter(self) -> Union[Literal["ALL"], List[DataType]]:
+    def data_types_filter(self) -> Literal["ALL"] | list[DataType]:
         """
         A computed field that normalizes the `data_type_filter_input` into a
         standardized format for the frontend.
@@ -125,16 +144,17 @@ class ColumnSelector(FlowfileInComponent):
         correct format for the frontend.
         """
         data = super().model_dump(**kwargs)
-        if 'data_types_filter' in data and data['data_types_filter'] != "ALL":
-            data['data_types'] = sorted([dt.value for dt in data['data_types_filter']])
+        if "data_types_filter" in data and data["data_types_filter"] != "ALL":
+            data["data_types"] = sorted([dt.value for dt in data["data_types_filter"]])
         return data
 
 
 class TextInput(FlowfileInComponent):
     """A standard text input field for capturing string values."""
+
     component_type: Literal["TextInput"] = "TextInput"
-    default: Optional[str] = ""
-    placeholder: Optional[str] = ""
+    default: str | None = ""
+    placeholder: str | None = ""
     input_type: InputType = "text"
 
     def __init__(self, **data):
@@ -145,10 +165,11 @@ class TextInput(FlowfileInComponent):
 
 class NumericInput(FlowfileInComponent):
     """A numeric input field with optional minimum and maximum value validation."""
+
     component_type: Literal["NumericInput"] = "NumericInput"
-    default: Optional[float] = None
-    min_value: Optional[float] = None
-    max_value: Optional[float] = None
+    default: float | None = None
+    min_value: float | None = None
+    max_value: float | None = None
     input_type: InputType = "number"
 
     def __init__(self, **data):
@@ -157,11 +178,30 @@ class NumericInput(FlowfileInComponent):
             self.value = self.default
 
 
+class SliderInput(FlowfileInComponent):
+    """A slider input for selecting a numeric value within a range."""
+
+    component_type: Literal["SliderInput"] = "SliderInput"
+    default: float | None = None
+    min_value: float = 0
+    max_value: float = 100
+    step: float = 1
+    input_type: InputType = "number"
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if self.value is None and self.default is not None:
+            self.value = self.default
+        elif self.value is None:
+            self.value = self.min_value
+
+
 class ToggleSwitch(FlowfileInComponent):
     """A boolean toggle switch, typically used for enabling or disabling a feature."""
+
     component_type: Literal["ToggleSwitch"] = "ToggleSwitch"
     default: bool = False
-    description: Optional[str] = None
+    description: str | None = None
     input_type: InputType = "boolean"
 
     def __init__(self, **data):
@@ -182,9 +222,10 @@ class SingleSelect(FlowfileInComponent):
     dynamically populated from the input dataframe's columns by using the
     `IncomingColumns` marker.
     """
+
     component_type: Literal["SingleSelect"] = "SingleSelect"
-    options: Union[List[Union[str, Tuple[str, Any]]], Type[IncomingColumns]]
-    default: Optional[Any] = None
+    options: list[str | tuple[str, Any]] | type[IncomingColumns]
+    default: Any | None = None
     input_type: InputType = "text"
 
     def __init__(self, **data):
@@ -200,9 +241,10 @@ class MultiSelect(FlowfileInComponent):
     Like `SingleSelect`, the options can be static or dynamically populated
     from the input columns using the `IncomingColumns` marker.
     """
+
     component_type: Literal["MultiSelect"] = "MultiSelect"
-    options: Union[List[Union[str, Tuple[str, Any]]], Type[IncomingColumns]]
-    default: List[Any] = Field(default_factory=list)
+    options: list[str | tuple[str, Any]] | type[IncomingColumns]
+    default: list[Any] = Field(default_factory=list)
     input_type: InputType = "array"
 
     def __init__(self, **data):
@@ -226,12 +268,13 @@ class Section(BaseModel):
             my_text_input=TextInput(label="Enter a value")
         )
     """
-    title: Optional[str] = None
-    description: Optional[str] = None
+
+    title: str | None = None
+    description: str | None = None
     hidden: bool = False
 
     class Config:
-        extra = 'allow'
+        extra = "allow"
         arbitrary_types_allowed = True
 
     def __init__(self, **data):
@@ -240,7 +283,7 @@ class Section(BaseModel):
         """
         super().__init__(**data)
 
-    def __call__(self, **kwargs) -> 'Section':
+    def __call__(self, **kwargs) -> "Section":
         """
         Allows adding components to the section after initialization.
 
@@ -250,7 +293,7 @@ class Section(BaseModel):
             setattr(self, key, value)
         return self
 
-    def get_components(self) -> Dict[str, FlowfileInComponent]:
+    def get_components(self) -> dict[str, FlowfileInComponent]:
         """
         Get all FlowfileInComponent instances from the section.
 
@@ -263,15 +306,216 @@ class Section(BaseModel):
         components = {}
 
         # Get from extra fields
-        for key, value in getattr(self, '__pydantic_extra__', {}).items():
+        for key, value in getattr(self, "__pydantic_extra__", {}).items():
             if isinstance(value, FlowfileInComponent):
                 components[key] = value
 
         # Get from defined fields (excluding metadata)
         for field_name in self.model_fields:
-            if field_name not in {'title', 'description', 'hidden'}:
+            if field_name not in {"title", "description", "hidden"}:
                 value = getattr(self, field_name, None)
                 if isinstance(value, FlowfileInComponent):
                     components[field_name] = value
 
         return components
+
+
+class AvailableSecrets:
+    """
+    A marker class used in `SecretSelector` components.
+
+    When `options` is set to this class, the component will be dynamically
+    populated with the secret names available to the current user.
+    This allows users to select from available secrets at runtime.
+
+    Example:
+        class MyNodeSettings(NodeSettings):
+            api_key = SecretSelector(
+                label="Select an API Key",
+                options=AvailableSecrets
+            )
+    """
+
+    pass
+
+
+class SecretSelector(FlowfileInComponent):
+    component_type: Literal["SecretSelector"] = "SecretSelector"
+    options: type[AvailableSecrets] = AvailableSecrets
+    required: bool = False
+    description: str | None = None
+    input_type: InputType = "secret"
+    name_prefix: str | None = None
+
+    # Private fields for runtime context
+    _user_id: int | None = None
+    _accessed_secrets: set | None = None  # Reference to node's tracking set
+
+    def set_execution_context(self, user_id: int, accessed_secrets: set):
+        """Called by framework before process() runs."""
+        self._user_id = user_id
+        self._accessed_secrets = accessed_secrets
+
+    @property
+    def secret_value(self) -> SecretStr | None:
+        """
+        Get the decrypted secret value.
+
+        Can only be called during node execution (after context is set).
+        Returns None if no secret is selected.
+        """
+        if self.value is None:
+            return None
+
+        if self._user_id is None:
+            raise ValueError(
+                "Secret can only be accessed during node execution. "
+                "Ensure you're calling this from within the process() method."
+            )
+
+        encrypted = get_encrypted_secret(current_user_id=self._user_id, secret_name=self.value)
+
+        if encrypted is None:
+            raise ValueError(
+                f"Secret '{self.value}' not found for user. " f"Please ensure the secret exists in your secrets store."
+            )
+
+        decrypted = decrypt_secret(encrypted)
+
+        if self._accessed_secrets is not None:
+            self._accessed_secrets.add(decrypted.get_secret_value())
+        else:
+            self._accessed_secrets = {decrypted.get_secret_value()}
+        return decrypted
+
+    def model_dump(self, **kwargs) -> dict:
+        """
+        Overrides the default `model_dump` to signal to the frontend
+        that this needs dynamic population from available secrets.
+        """
+        data = super().model_dump(**kwargs)
+        # Signal to frontend that options should be fetched from /secrets endpoint
+        data["options"] = {"__type__": "AvailableSecrets"}
+        if self.name_prefix:
+            data["name_prefix"] = self.name_prefix
+        return data
+
+
+class ColumnActionInput(FlowfileInComponent):
+    """
+    A generic UI component for configuring column-based transformations.
+
+    This component allows users to select columns, choose an action/transformation,
+    and optionally rename the output. It can be configured for many use cases:
+    rolling windows, aggregations, string transformations, type conversions, etc.
+
+    The component displays:
+    - A list of available columns (filterable by data type)
+    - A table of configured operations with: Column, Action, Output Name
+    - Optional group by and order by selectors
+
+    Example - Rolling Window:
+        ColumnActionInput(
+            label="Rolling Calculations",
+            actions=["sum", "mean", "min", "max"],
+            output_name_template="{column}_rolling_{action}",
+            show_group_by=True,
+            show_order_by=True,
+            data_types="Numeric"
+        )
+
+    Example - String Transformations:
+        ColumnActionInput(
+            label="String Operations",
+            actions=["upper", "lower", "trim", "reverse"],
+            output_name_template="{column}_{action}",
+            data_types="String"
+        )
+
+    Example - Aggregations with ActionOption:
+        ColumnActionInput(
+            label="Aggregations",
+            actions=[
+                ActionOption("sum", "Sum"),
+                ActionOption("count", "Count"),
+                ActionOption("mean", "Average"),
+                "min",  # plain strings also work
+            ],
+            output_name_template="{column}_{action}",
+            show_group_by=True
+        )
+    """
+
+    component_type: Literal["ColumnActionInput"] = "ColumnActionInput"
+    input_type: InputType = "array"
+
+    # Configurable actions - list of action names or ActionOption tuples
+    actions: list[ActionSpec] = Field(default_factory=list)
+    """Actions available for selection. Can be strings or ActionOption(value, label) tuples."""
+
+    # Template for auto-generating output names
+    # Supports placeholders: {column}, {action}
+    output_name_template: str = "{column}_{action}"
+    """Template for generating default output names. Use {column} and {action} placeholders."""
+
+    # Optional grouping/ordering support
+    show_group_by: bool = False
+    """Whether to show the group by column selector."""
+
+    show_order_by: bool = False
+    """Whether to show the order by column selector."""
+
+    # Type filtering for column selection
+    data_type_filter_input: TypeSpec = Field(default="ALL", alias="data_types", repr=False, exclude=True)
+    """Filter columns by data type. Defaults to ALL."""
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        # Initialize value if not set
+        if self.value is None:
+            self.value = {
+                "rows": [],
+                "group_by_columns": [],
+                "order_by_column": None,
+            }
+
+    def set_value(self, value: Any):
+        """
+        Sets the value from frontend.
+        """
+        self.value = value
+        return self
+
+    @computed_field
+    @property
+    def data_types_filter(self) -> Literal["ALL"] | list[DataType]:
+        """
+        A computed field that normalizes the `data_type_filter_input` into a
+        standardized format for the frontend.
+        """
+        return normalize_input_to_data_types(self.data_type_filter_input)
+
+    def model_dump(self, **kwargs) -> dict:
+        """
+        Serializes the component for the frontend.
+        """
+        data = super().model_dump(**kwargs)
+        # Normalize actions to list of {value, label} objects for frontend
+        normalized_actions = []
+        for action in self.actions:
+            if isinstance(action, tuple):
+                normalized_actions.append({"value": action[0], "label": action[1]})
+            else:
+                normalized_actions.append({"value": action, "label": action})
+        data["actions"] = normalized_actions
+        data["output_name_template"] = self.output_name_template
+        data["show_group_by"] = self.show_group_by
+        data["show_order_by"] = self.show_order_by
+        if "data_types_filter" in data and data["data_types_filter"] != "ALL":
+            data["data_types"] = sorted([dt.value for dt in data["data_types_filter"]])
+        else:
+            data["data_types"] = "ALL"
+        return data

flowfile_core/flowfile/schema_callbacks.py

@@ -1,23 +1,17 @@
-
-from typing import List
-
-from polars import datatypes
 import polars as pl
-
 from pl_fuzzy_frame_match.output_column_name_utils import set_name_in_fuzzy_mappings
 from pl_fuzzy_frame_match.pre_process import rename_fuzzy_right_mapping
+from polars import datatypes
 
-from flowfile_core.flowfile.flow_data_engine.subprocess_operations.subprocess_operations import fetch_unique_values
 from flowfile_core.configs.flow_logger import main_logger
 from flowfile_core.flowfile.flow_data_engine.flow_file_column.main import FlowfileColumn, PlType
-from flowfile_core.schemas import transform_schema
-from flowfile_core.schemas import input_schema
-from flowfile_core.schemas.transform_schema import FuzzyMatchInputManager
+from flowfile_core.flowfile.flow_data_engine.subprocess_operations.subprocess_operations import fetch_unique_values
+from flowfile_core.schemas import input_schema, transform_schema
 
 
-def _ensure_all_columns_have_select(left_cols: List[str],
-                                    right_cols: List[str],
-                                    fuzzy_match_input: transform_schema.FuzzyMatchInputManager):
+def _ensure_all_columns_have_select(
+    left_cols: list[str], right_cols: list[str], fuzzy_match_input: transform_schema.FuzzyMatchInputManager
+):
     """
     Ensure that all columns in the left and right FlowDataEngines are included in the fuzzy match input's select
      statements.
@@ -33,13 +27,16 @@ def _ensure_all_columns_have_select(left_cols: List[str],
     left_cols_in_select = {c.old_name for c in fuzzy_match_input.left_select.renames}
 
     fuzzy_match_input.left_select.renames.extend(
-        [transform_schema.SelectInput(col) for col in left_cols if col not in left_cols_in_select])
+        [transform_schema.SelectInput(col) for col in left_cols if col not in left_cols_in_select]
+    )
     fuzzy_match_input.right_select.renames.extend(
         [transform_schema.SelectInput(col) for col in right_cols if col not in right_cols_in_select]
     )
 
 
-def _order_join_inputs_based_on_col_order(col_order: List[str], join_inputs: transform_schema.JoinInputsManager) -> None:
+def _order_join_inputs_based_on_col_order(
+    col_order: list[str], join_inputs: transform_schema.JoinInputsManager
+) -> None:
     """
     Ensure that the select columns in the fuzzy match input match the order of the incoming columns.
     This function modifies the join_inputs object in-place.
@@ -52,17 +49,23 @@ def _order_join_inputs_based_on_col_order(col_order: List[str], join_inputs: tra
     join_inputs.select_inputs.renames = ordered_renames
 
 
-def calculate_fuzzy_match_schema(fm_input: transform_schema.FuzzyMatchInputManager,
-                                 left_schema: List[FlowfileColumn],
-                                 right_schema: List[FlowfileColumn]):
-    _ensure_all_columns_have_select(left_cols=[col.column_name for col in left_schema],
-                                    right_cols=[col.column_name for col in right_schema],
-                                    fuzzy_match_input=fm_input)
+def calculate_fuzzy_match_schema(
+    fm_input: transform_schema.FuzzyMatchInputManager,
+    left_schema: list[FlowfileColumn],
+    right_schema: list[FlowfileColumn],
+):
+    _ensure_all_columns_have_select(
+        left_cols=[col.column_name for col in left_schema],
+        right_cols=[col.column_name for col in right_schema],
+        fuzzy_match_input=fm_input,
+    )
 
-    _order_join_inputs_based_on_col_order(col_order=[col.column_name for col in left_schema],
-                                          join_inputs=fm_input.left_select)
-    _order_join_inputs_based_on_col_order(col_order=[col.column_name for col in right_schema],
-                                          join_inputs=fm_input.right_select)
+    _order_join_inputs_based_on_col_order(
+        col_order=[col.column_name for col in left_schema], join_inputs=fm_input.left_select
+    )
+    _order_join_inputs_based_on_col_order(
+        col_order=[col.column_name for col in right_schema], join_inputs=fm_input.right_select
+    )
     for column in fm_input.left_select.renames:
         if column.join_key:
             column.keep = True
@@ -78,20 +81,27 @@ def calculate_fuzzy_match_schema(fm_input: transform_schema.FuzzyMatchInputManag
     for column in fm_input.left_select.renames:
         column_schema = left_schema_dict.get(column.old_name)
         if column_schema and (column.keep or column.join_key):
-            output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
-                                                           example_values=column_schema.example_values))
+            output_schema.append(
+                FlowfileColumn.from_input(
+                    column.new_name, column_schema.data_type, example_values=column_schema.example_values
+                )
+            )
     for column in fm_input.right_select.renames:
         column_schema = right_schema_dict.get(column.old_name)
         if column_schema and (column.keep or column.join_key):
-            output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
-                                                           example_values=column_schema.example_values))
+            output_schema.append(
+                FlowfileColumn.from_input(
+                    column.new_name, column_schema.data_type, example_values=column_schema.example_values
+                )
+            )
     set_name_in_fuzzy_mappings(new_join_mapping)
-    output_schema.extend([FlowfileColumn.from_input(fuzzy_mapping.output_column_name, 'Float64')
-                          for fuzzy_mapping in new_join_mapping])
+    output_schema.extend(
+        [FlowfileColumn.from_input(fuzzy_mapping.output_column_name, "Float64") for fuzzy_mapping in new_join_mapping]
+    )
     return output_schema
 
 
-def get_schema_of_column(node_input_schema: List[FlowfileColumn], col_name: str) -> FlowfileColumn|None:
+def get_schema_of_column(node_input_schema: list[FlowfileColumn], col_name: str) -> FlowfileColumn | None:
     for s in node_input_schema:
         if s.name == col_name:
             return s
@@ -99,44 +109,54 @@ def get_schema_of_column(node_input_schema: List[FlowfileColumn], col_name: str)
 
 class InvalidSetup(ValueError):
     """Error raised when pivot column has too many unique values."""
+
     pass
 
 
 def get_output_data_type_pivot(schema: FlowfileColumn, agg_type: str) -> datatypes:
-    if agg_type in ('count', 'n_unique'):
+    if agg_type in ("count", "n_unique"):
         output_type = datatypes.Float64  # count is always float
-    elif schema.generic_datatype() == 'numeric':
+    elif schema.generic_datatype() == "numeric":
         output_type = datatypes.Float64
-    elif schema.generic_datatype() == 'string':
+    elif schema.generic_datatype() == "string":
         output_type = datatypes.Utf8
-    elif schema.generic_datatype() == 'date':
+    elif schema.generic_datatype() == "date":
         output_type = datatypes.Datetime
     else:
         output_type = datatypes.Utf8
     return output_type
 
 
-def pre_calculate_pivot_schema(node_input_schema: List[FlowfileColumn],
-                               pivot_input: transform_schema.PivotInput,
-                               output_fields: List[input_schema.MinimalFieldInfo] = None,
-                               input_lf: pl.LazyFrame = None) -> List[FlowfileColumn]:
-    index_columns_schema = [get_schema_of_column(node_input_schema, index_col) for index_col in
-                            pivot_input.index_columns]
+def pre_calculate_pivot_schema(
+    node_input_schema: list[FlowfileColumn],
+    pivot_input: transform_schema.PivotInput,
+    output_fields: list[input_schema.MinimalFieldInfo] = None,
+    input_lf: pl.LazyFrame = None,
+) -> list[FlowfileColumn]:
+    index_columns_schema = [
+        get_schema_of_column(node_input_schema, index_col) for index_col in pivot_input.index_columns
+    ]
     val_column_schema = get_schema_of_column(node_input_schema, pivot_input.value_col)
     if output_fields is not None and len(output_fields) > 0:
-        return index_columns_schema+[FlowfileColumn(PlType(column_name=output_field.name,
-                                                           pl_datatype=output_field.data_type)) for output_field in
-                                     output_fields]
+        return index_columns_schema + [
+            FlowfileColumn(PlType(column_name=output_field.name, pl_datatype=output_field.data_type))
+            for output_field in output_fields
+        ]
 
     else:
         max_unique_vals = 200
-        unique_vals = fetch_unique_values(input_lf.select(pivot_input.pivot_column)
-                                          .unique()
-                                          .sort(pivot_input.pivot_column)
-                                          .limit(max_unique_vals).cast(pl.String))
+        unique_vals = fetch_unique_values(
+            input_lf.select(pivot_input.pivot_column)
+            .unique()
+            .sort(pivot_input.pivot_column)
+            .limit(max_unique_vals)
+            .cast(pl.String)
+        )
         if len(unique_vals) >= max_unique_vals:
-            main_logger.warning('Pivot column has too many unique values. Please consider using a different column.'
-                                f' Max unique values: {max_unique_vals}')
+            main_logger.warning(
+                "Pivot column has too many unique values. Please consider using a different column."
+                f" Max unique values: {max_unique_vals}"
+            )
         pl_output_fields = []
         for val in unique_vals:
             if len(pivot_input.aggregations) == 1:
@@ -145,5 +165,5 @@ def pre_calculate_pivot_schema(node_input_schema: List[FlowfileColumn],
             else:
                 for agg in pivot_input.aggregations:
                     output_type = get_output_data_type_pivot(val_column_schema, agg)
-                    pl_output_fields.append(PlType(column_name=f'{val}_{agg}', pl_datatype=output_type))
+                    pl_output_fields.append(PlType(column_name=f"{val}_{agg}", pl_datatype=output_type))
         return index_columns_schema + [FlowfileColumn(pl_output_field) for pl_output_field in pl_output_fields]

flowfile_core/flowfile/setting_generator/__init__.py

@@ -1,2 +1 @@
-
 from flowfile_core.flowfile.setting_generator.settings import setting_generator, setting_updator

flowfile_core/flowfile/setting_generator/setting_generator.py

@@ -1,5 +1,6 @@
+from collections.abc import Callable
+
 from flowfile_core.configs import logger
-from typing import Callable
 
 
 class SettingGenerator:
@@ -13,10 +14,10 @@ class SettingGenerator:
         setattr(self, f.__name__, f)
 
     def get_setting_generator(self, node_type: str) -> Callable:
-        logger.info('getting setting generator for ' + node_type)
+        logger.info("getting setting generator for " + node_type)
 
         if node_type in self.setting_generator_set:
-            logger.info('setting generator found')
+            logger.info("setting generator found")
             return getattr(self, node_type)
         else:
             return lambda x: x
@@ -33,9 +34,9 @@ class SettingUpdator:
         setattr(self, f.__name__, f)
 
     def get_setting_updator(self, node_type: str) -> Callable:
-        logger.info('getting setting updator for ' + node_type)
+        logger.info("getting setting updator for " + node_type)
         if node_type in self.setting_updator_set:
-            logger.info('setting updator found')
+            logger.info("setting updator found")
             return getattr(self, node_type)
         else:
             return lambda x: x