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

flowfile_core/schemas/input_schema.py

@@ -1,15 +1,23 @@
-from typing import List, Optional, Literal, Iterator, Any
+from typing import List, Optional, Literal, Iterator, Any, Annotated
 from flowfile_core.schemas import transform_schema
 from pathlib import Path
 import os
 from flowfile_core.schemas.analysis_schemas import graphic_walker_schemas as gs_schemas
 from flowfile_core.schemas.cloud_storage_schemas import CloudStorageReadSettings, CloudStorageWriteSettings
-from flowfile_core.schemas.schemas import SecretRef
+from flowfile_core.schemas.yaml_types import (
+    OutputSettingsYaml, NodeSelectYaml, NodeJoinYaml,
+    NodeCrossJoinYaml, NodeFuzzyMatchYaml, NodeOutputYaml
+)
 from flowfile_core.utils.utils import ensure_similarity_dicts, standardize_col_dtype
-from pydantic import BaseModel, Field, model_validator, SecretStr, ConfigDict
+from pydantic import (BaseModel, Field, model_validator, field_validator,
+                      SecretStr, ConfigDict, StringConstraints, ValidationInfo)
 import polars as pl
 
 
+SecretRef = Annotated[str, StringConstraints(min_length=1, max_length=100),
+                      Field(description="An ID referencing an encrypted secret.")]
+
+
 OutputConnectionClass = Literal['output-0', 'output-1', 'output-2', 'output-3', 'output-4',
                                 'output-5', 'output-6', 'output-7', 'output-8', 'output-9']
 
@@ -43,57 +51,19 @@ class MinimalFieldInfo(BaseModel):
     data_type: str = "String"
 
 
-class ReceivedTableBase(BaseModel):
-    """Base model for defining a table received from an external source."""
-    id: Optional[int] = None
-    name: Optional[str]
-    path: str  # This can be an absolute or relative path
-    directory: Optional[str] = None
-    analysis_file_available: bool = False
-    status: Optional[str] = None
-    file_type: Optional[str] = None
-    fields: List[MinimalFieldInfo] = Field(default_factory=list)
-    abs_file_path: Optional[str] = None
-
-    @classmethod
-    def create_from_path(cls, path: str):
-        """Creates an instance from a file path string."""
-        filename = Path(path).name
-        return cls(name=filename, path=path)
-
-    @property
-    def file_path(self) -> str:
-        """Constructs the full file path from the directory and name."""
-        if not self.name in self.path:
-            return os.path.join(self.path, self.name)
-        else:
-            return self.path
-
-    def set_absolute_filepath(self):
-        """Resolves the path to an absolute file path."""
-        base_path = Path(self.path).expanduser()
-        if not base_path.is_absolute():
-            base_path = Path.cwd() / base_path
-        if self.name and self.name not in base_path.name:
-            base_path = base_path / self.name
-        self.abs_file_path = str(base_path.resolve())
-
-    @model_validator(mode='after')
-    def populate_abs_file_path(self):
-        """Ensures the absolute file path is populated after validation."""
-        if not self.abs_file_path:
-            self.set_absolute_filepath()
-        return self
+class InputTableBase(BaseModel):
+    """Base settings for input file operations."""
+    file_type: str  # Will be overridden with Literal in subclasses
 
 
-class ReceivedCsvTable(ReceivedTableBase):
+class InputCsvTable(InputTableBase):
     """Defines settings for reading a CSV file."""
-    file_type: str = 'csv'
+    file_type: Literal['csv'] = 'csv'
     reference: str = ''
     starting_from_line: int = 0
     delimiter: str = ','
     has_headers: bool = True
-    encoding: Optional[str] = 'utf-8'
+    encoding: str = 'utf-8'
     parquet_ref: Optional[str] = None
     row_delimiter: str = '\n'
     quote_char: str = '"'
@@ -102,18 +72,19 @@ class ReceivedCsvTable(ReceivedTableBase):
     ignore_errors: bool = False
 
 
-class ReceivedJsonTable(ReceivedCsvTable):
-    """Defines settings for reading a JSON file (inherits from CSV settings)."""
-    pass
+class InputJsonTable(InputCsvTable):
+    """Defines settings for reading a JSON file."""
+    file_type: Literal['json'] = 'json'
 
 
-class ReceivedParquetTable(ReceivedTableBase):
+class InputParquetTable(InputTableBase):
     """Defines settings for reading a Parquet file."""
-    file_type: str = 'parquet'
+    file_type: Literal['parquet'] = 'parquet'
 
 
-class ReceivedExcelTable(ReceivedTableBase):
+class InputExcelTable(InputTableBase):
     """Defines settings for reading an Excel file."""
+    file_type: Literal['excel'] = 'excel'
     sheet_name: Optional[str] = None
     start_row: int = 0
     start_column: int = 0
@@ -122,51 +93,185 @@ class ReceivedExcelTable(ReceivedTableBase):
     has_headers: bool = True
     type_inference: bool = False
 
+    @model_validator(mode='after')
     def validate_range_values(self):
         """Validates that the Excel cell range is logical."""
         for attribute in [self.start_row, self.start_column, self.end_row, self.end_column]:
             if not isinstance(attribute, int) or attribute < 0:
                 raise ValueError("Row and column indices must be non-negative integers")
         if (self.end_row > 0 and self.start_row > self.end_row) or \
-           (self.end_column > 0 and self.start_column > self.end_column):
+                (self.end_column > 0 and self.start_column > self.end_column):
             raise ValueError("Start row/column must not be greater than end row/column")
+        return self
+
+
+# Create the discriminated union (similar to OutputTableSettings)
+InputTableSettings = Annotated[
+    InputCsvTable | InputJsonTable | InputParquetTable | InputExcelTable,
+    Field(discriminator='file_type')
+]
+
+
+# Now create the main ReceivedTable model
+class ReceivedTable(BaseModel):
+    """Model for defining a table received from an external source."""
+    # Metadata fields
+    id: Optional[int] = None
+    name: Optional[str] = None
+    path: str  # This can be an absolute or relative path
+    directory: Optional[str] = None
+    analysis_file_available: bool = False
+    status: Optional[str] = None
+    fields: List[MinimalFieldInfo] = Field(default_factory=list)
+    abs_file_path: Optional[str] = None
+
+    file_type: Literal['csv', 'json', 'parquet', 'excel']
+
+    table_settings: InputTableSettings
+
+    @classmethod
+    def create_from_path(cls, path: str, file_type: Literal['csv', 'json', 'parquet', 'excel'] = 'csv'):
+        """Creates an instance from a file path string."""
+        filename = Path(path).name
+
+        # Create appropriate table_settings based on file_type
+        settings_map = {
+            'csv': InputCsvTable(),
+            'json': InputJsonTable(),
+            'parquet': InputParquetTable(),
+            'excel': InputExcelTable(),
+        }
+
+        return cls(
+            name=filename,
+            path=path,
+            file_type=file_type,
+            table_settings=settings_map.get(file_type, InputCsvTable())
+        )
+
+    @property
+    def file_path(self) -> str:
+        """Constructs the full file path from the directory and name."""
+        if self.name and self.name not in self.path:
+            return os.path.join(self.path, self.name)
+        else:
+            return self.path
+
+    def set_absolute_filepath(self):
+        """Resolves the path to an absolute file path."""
+        base_path = Path(self.path).expanduser()
+        if not base_path.is_absolute():
+            base_path = Path.cwd() / base_path
+        if self.name and self.name not in base_path.name:
+            base_path = base_path / self.name
+        self.abs_file_path = str(base_path.resolve())
+
+    @model_validator(mode='before')
+    @classmethod
+    def set_default_table_settings(cls, data):
+        """Create default table_settings based on file_type if not provided."""
+        if isinstance(data, dict):
+            if 'table_settings' not in data or data['table_settings'] is None:
+                data['table_settings'] = {}
 
+            if isinstance(data['table_settings'], dict) and 'file_type' not in data['table_settings']:
+                data['table_settings']['file_type'] = data.get('file_type', 'csv')
+        return data
 
-class ReceivedTable(ReceivedExcelTable, ReceivedCsvTable, ReceivedParquetTable):
-    """A comprehensive model that can represent any type of received table."""
-    ...
+    @model_validator(mode='after')
+    def populate_abs_file_path(self):
+        """Ensures the absolute file path is populated after validation."""
+        if not self.abs_file_path:
+            self.set_absolute_filepath()
+        return self
 
 
 class OutputCsvTable(BaseModel):
     """Defines settings for writing a CSV file."""
-    file_type: str = 'csv'
+    file_type: Literal['csv'] = 'csv'
     delimiter: str = ','
     encoding: str = 'utf-8'
 
 
 class OutputParquetTable(BaseModel):
     """Defines settings for writing a Parquet file."""
-    file_type: str = 'parquet'
+    file_type: Literal['parquet'] = 'parquet'
 
 
 class OutputExcelTable(BaseModel):
     """Defines settings for writing an Excel file."""
-    file_type: str = 'excel'
+    file_type: Literal['excel'] = 'excel'
     sheet_name: str = 'Sheet1'
 
 
+# Create a discriminated union
+OutputTableSettings = Annotated[
+    OutputCsvTable | OutputParquetTable | OutputExcelTable,
+    Field(discriminator='file_type')
+]
+
+
 class OutputSettings(BaseModel):
     """Defines the complete settings for an output node."""
     name: str
     directory: str
-    file_type: str
+    file_type: str  # This drives which table_settings to use
     fields: Optional[List[str]] = Field(default_factory=list)
     write_mode: str = 'overwrite'
-    output_csv_table: Optional[OutputCsvTable] = Field(default_factory=OutputCsvTable)
-    output_parquet_table: OutputParquetTable = Field(default_factory=OutputParquetTable)
-    output_excel_table: OutputExcelTable = Field(default_factory=OutputExcelTable)
+    table_settings: OutputTableSettings
     abs_file_path: Optional[str] = None
 
+    def to_yaml_dict(self) -> OutputSettingsYaml:
+        """Converts the output settings to a dictionary suitable for YAML serialization."""
+        result: OutputSettingsYaml = {
+            "name": self.name,
+            "directory": self.directory,
+            "file_type": self.file_type,
+            "write_mode": self.write_mode,
+        }
+        if self.abs_file_path:
+            result["abs_file_path"] = self.abs_file_path
+        if self.fields:
+            result["fields"] = self.fields
+        # Only include table_settings if it has non-default values beyond file_type
+        ts_dict = self.table_settings.model_dump(exclude={"file_type"})
+        if any(v for v in ts_dict.values()):  # Has meaningful settings
+            result["table_settings"] = ts_dict
+        return result
+
+    @property
+    def sheet_name(self) -> str | None:
+        if self.file_type == 'excel':
+            return self.table_settings.sheet_name
+
+    @property
+    def delimiter(self) -> str | None:
+        if self.file_type == 'csv':
+            return self.table_settings.delimiter
+
+    @field_validator('table_settings', mode='before')
+    @classmethod
+    def validate_table_settings(cls, v, info: ValidationInfo):
+        """Ensures table_settings matches the file_type."""
+        if v is None:
+            file_type = info.data.get('file_type', 'csv')
+            # Create default based on file_type
+            match file_type:
+                case 'csv':
+                    return OutputCsvTable()
+                case 'parquet':
+                    return OutputParquetTable()
+                case 'excel':
+                    return OutputExcelTable()
+                case _:
+                    return OutputCsvTable()
+
+        # If it's a dict, add file_type if missing
+        if isinstance(v, dict) and 'file_type' not in v:
+            v['file_type'] = info.data.get('file_type', 'csv')
+
+        return v
+
     def set_absolute_filepath(self):
         """Resolves the output directory and name into an absolute path."""
         base_path = Path(self.directory)
@@ -205,7 +310,7 @@ class NodeSingleInput(NodeBase):
 
 class NodeMultiInput(NodeBase):
     """A base model for any node that takes multiple data inputs."""
-    depending_on_ids: Optional[List[int]] = [-1]
+    depending_on_ids: Optional[List[int]] = Field(default_factory=list)
 
 
 class NodeSelect(NodeSingleInput):
@@ -214,6 +319,15 @@ class NodeSelect(NodeSingleInput):
     select_input: List[transform_schema.SelectInput] = Field(default_factory=list)
     sorted_by: Optional[Literal['none', 'asc', 'desc']] = 'none'
 
+    def to_yaml_dict(self) -> NodeSelectYaml:
+        """Converts the select node settings to a dictionary for YAML serialization."""
+        return {
+            "cache_results": self.cache_results,
+            "keep_missing": self.keep_missing,
+            "select_input": [s.to_yaml_dict() for s in self.select_input],
+            "sorted_by": self.sorted_by,
+        }
+
 
 class NodeFilter(NodeSingleInput):
     """Settings for a node that filters rows based on a condition."""
@@ -249,6 +363,18 @@ class NodeJoin(NodeMultiInput):
     auto_keep_right: bool = True
     auto_keep_left: bool = True
 
+    def to_yaml_dict(self) -> NodeJoinYaml:
+        """Converts the join node settings to a dictionary for YAML serialization."""
+        return {
+            "cache_results": self.cache_results,
+            "auto_generate_selection": self.auto_generate_selection,
+            "verify_integrity": self.verify_integrity,
+            "join_input": self.join_input.to_yaml_dict(),
+            "auto_keep_all": self.auto_keep_all,
+            "auto_keep_right": self.auto_keep_right,
+            "auto_keep_left": self.auto_keep_left,
+        }
+
 
 class NodeCrossJoin(NodeMultiInput):
     """Settings for a node that performs a cross join."""
@@ -259,11 +385,35 @@ class NodeCrossJoin(NodeMultiInput):
     auto_keep_right: bool = True
     auto_keep_left: bool = True
 
+    def to_yaml_dict(self) -> NodeCrossJoinYaml:
+        """Converts the cross join node settings to a dictionary for YAML serialization."""
+        return {
+            "cache_results": self.cache_results,
+            "auto_generate_selection": self.auto_generate_selection,
+            "verify_integrity": self.verify_integrity,
+            "cross_join_input": self.cross_join_input.to_yaml_dict(),
+            "auto_keep_all": self.auto_keep_all,
+            "auto_keep_right": self.auto_keep_right,
+            "auto_keep_left": self.auto_keep_left,
+        }
+
 
 class NodeFuzzyMatch(NodeJoin):
     """Settings for a node that performs a fuzzy join based on string similarity."""
     join_input: transform_schema.FuzzyMatchInput
 
+    def to_yaml_dict(self) -> NodeFuzzyMatchYaml:
+        """Converts the fuzzy match node settings to a dictionary for YAML serialization."""
+        return {
+            "cache_results": self.cache_results,
+            "auto_generate_selection": self.auto_generate_selection,
+            "verify_integrity": self.verify_integrity,
+            "join_input": self.join_input.to_yaml_dict(),
+            "auto_keep_all": self.auto_keep_all,
+            "auto_keep_right": self.auto_keep_right,
+            "auto_keep_left": self.auto_keep_left,
+        }
+
 
 class NodeDatasource(NodeBase):
     """Base settings for a node that acts as a data source."""
@@ -465,6 +615,13 @@ class NodeOutput(NodeSingleInput):
     """Settings for a node that writes its input to a file."""
     output_settings: OutputSettings
 
+    def to_yaml_dict(self) -> NodeOutputYaml:
+        """Converts the output node settings to a dictionary for YAML serialization."""
+        return {
+            "cache_results": self.cache_results,
+            "output_settings": self.output_settings.to_yaml_dict(),
+        }
+
 
 class NodeOutputConnection(BaseModel):
     """Represents the output side of a connection between two nodes."""

flowfile_core/schemas/output_model.py

@@ -25,7 +25,7 @@ class RunInformation(BaseModel):
     nodes_completed: int = 0
     number_of_nodes: int = 0
     node_step_result: List[NodeResult]
-    run_type: Literal["fetch_one", "full_run"]
+    run_type: Literal["fetch_one", "full_run", "init"]
 
 
 class BaseItem(BaseModel):

flowfile_core/schemas/schemas.py

@@ -1,13 +1,48 @@
-from typing import Optional, List, Dict, Tuple, Any, Literal, Annotated
-from pydantic import BaseModel, field_validator, ConfigDict, Field, StringConstraints
+from typing import Optional, List, Dict, Tuple, Any, Literal, ClassVar
+from pydantic import BaseModel, field_validator, ConfigDict, Field, ValidationInfo, field_serializer
 from flowfile_core.flowfile.utils import create_unique_id
 from flowfile_core.configs.settings import OFFLOAD_TO_WORKER
+from flowfile_core.schemas import input_schema
 ExecutionModeLiteral = Literal['Development', 'Performance']
 ExecutionLocationsLiteral = Literal['local', 'remote']
 
 # Type literals for classifying nodes.
 NodeTypeLiteral = Literal['input', 'output', 'process']
 TransformTypeLiteral = Literal['narrow', 'wide', 'other']
+_custom_node_store_cache = None
+
+NODE_TYPE_TO_SETTINGS_CLASS = {
+    'manual_input': input_schema.NodeManualInput,
+    'filter': input_schema.NodeFilter,
+    'formula': input_schema.NodeFormula,
+    'select': input_schema.NodeSelect,
+    'sort': input_schema.NodeSort,
+    'record_id': input_schema.NodeRecordId,
+    'sample': input_schema.NodeSample,
+    'unique': input_schema.NodeUnique,
+    'group_by': input_schema.NodeGroupBy,
+    'pivot': input_schema.NodePivot,
+    'unpivot': input_schema.NodeUnpivot,
+    'text_to_rows': input_schema.NodeTextToRows,
+    'graph_solver': input_schema.NodeGraphSolver,
+    'polars_code': input_schema.NodePolarsCode,
+    'join': input_schema.NodeJoin,
+    'cross_join': input_schema.NodeCrossJoin,
+    'fuzzy_match': input_schema.NodeFuzzyMatch,
+    'record_count': input_schema.NodeRecordCount,
+    'explore_data': input_schema.NodeExploreData,
+    'union': input_schema.NodeUnion,
+    'output': input_schema.NodeOutput,
+    'read': input_schema.NodeRead,
+    'database_reader': input_schema.NodeDatabaseReader,
+    'database_writer': input_schema.NodeDatabaseWriter,
+    'cloud_storage_reader': input_schema.NodeCloudStorageReader,
+    'cloud_storage_writer': input_schema.NodeCloudStorageWriter,
+    'external_source': input_schema.NodeExternalSource,
+    'promise': input_schema.NodePromise,
+    'user_defined': input_schema.UserDefinedNode,
+}
+
 
 def get_global_execution_location() -> ExecutionLocationsLiteral:
     """
@@ -21,6 +56,25 @@ def get_global_execution_location() -> ExecutionLocationsLiteral:
     return "local"
 
 
+def _get_custom_node_store():
+    """Lazy load CUSTOM_NODE_STORE once and cache it."""
+    global _custom_node_store_cache
+    if _custom_node_store_cache is None:
+        from flowfile_core.configs.node_store import CUSTOM_NODE_STORE
+        _custom_node_store_cache = CUSTOM_NODE_STORE
+    return _custom_node_store_cache
+
+
+def get_settings_class_for_node_type(node_type: str):
+    """Get the settings class for a node type, supporting both standard and user-defined nodes."""
+    model_class = NODE_TYPE_TO_SETTINGS_CLASS.get(node_type)
+    if model_class is None:
+        if node_type in _get_custom_node_store():
+            return input_schema.UserDefinedNode
+        return None
+    return model_class
+
+
 def is_valid_execution_location_in_current_global_settings(execution_location: ExecutionLocationsLiteral) -> bool:
     return not (get_global_execution_location() == "local" and execution_location == "remote")
 
@@ -117,6 +171,60 @@ class RawLogInput(BaseModel):
     extra: Optional[dict] = None
 
 
+class FlowfileSettings(BaseModel):
+    """Settings for flowfile serialization (YAML/JSON).
+
+    Excludes runtime state fields like is_running, is_canceled, modified_on.
+    """
+    description: Optional[str] = None
+    execution_mode: ExecutionModeLiteral = 'Performance'
+    execution_location: ExecutionLocationsLiteral = 'local'
+    auto_save: bool = False
+    show_detailed_progress: bool = True
+
+
+class FlowfileNode(BaseModel):
+    """Node representation for flowfile serialization (YAML/JSON)."""
+    id: int
+    type: str
+    is_start_node: bool = False
+    description: Optional[str] = ''
+    x_position: Optional[int] = 0
+    y_position: Optional[int] = 0
+    left_input_id: Optional[int] = None
+    right_input_id: Optional[int] = None
+    input_ids: Optional[List[int]] = Field(default_factory=list)
+    outputs: Optional[List[int]] = Field(default_factory=list)
+    setting_input: Optional[Any] = None
+
+    _setting_input_exclude: ClassVar[set] = {
+        'flow_id', 'node_id', 'pos_x', 'pos_y', 'is_setup',
+        'description', 'user_id', 'is_flow_output', 'is_user_defined',
+        'depending_on_id', 'depending_on_ids'
+    }
+
+    @field_serializer('setting_input')
+    def serialize_setting_input(self, value, _info):
+        if value is None:
+            return None
+        if isinstance(value, input_schema.NodePromise):
+            return None
+        if hasattr(value, 'to_yaml_dict'):
+            return value.to_yaml_dict()
+        if hasattr(value, 'to_yaml_dict'):
+            return value.to_yaml_dict()
+        return value.model_dump(exclude=self._setting_input_exclude)
+
+
+class FlowfileData(BaseModel):
+    """Root model for flowfile serialization (YAML/JSON)."""
+    flowfile_version: str
+    flowfile_id: int
+    flowfile_name: str
+    flowfile_settings: FlowfileSettings
+    nodes: List[FlowfileNode]
+
+
 class NodeTemplate(BaseModel):
     """
     Defines the template for a node type, specifying its UI and functional characteristics.
@@ -151,48 +259,47 @@ class NodeTemplate(BaseModel):
 class NodeInformation(BaseModel):
     """
     Stores the state and configuration of a specific node instance within a flow.
-
-    Attributes:
-        id (Optional[int]): The unique ID of the node instance.
-        type (Optional[str]): The type of the node (e.g., 'join', 'filter').
-        is_setup (Optional[bool]): Whether the node has been configured.
-        description (Optional[str]): A user-provided description.
-        x_position (Optional[int]): The x-coordinate on the canvas.
-        y_position (Optional[int]): The y-coordinate on the canvas.
-        left_input_id (Optional[int]): The ID of the node connected to the left input.
-        right_input_id (Optional[int]): The ID of the node connected to the right input.
-        input_ids (Optional[List[int]]): A list of IDs for main input nodes.
-        outputs (Optional[List[int]]): A list of IDs for nodes this node outputs to.
-        setting_input (Optional[Any]): The specific settings for this node instance.
     """
     id: Optional[int] = None
     type: Optional[str] = None
     is_setup: Optional[bool] = None
+    is_start_node: bool = False
     description: Optional[str] = ''
     x_position: Optional[int] = 0
     y_position: Optional[int] = 0
     left_input_id: Optional[int] = None
     right_input_id: Optional[int] = None
-    input_ids: Optional[List[int]] = [-1]
-    outputs: Optional[List[int]] = [-1]
+    input_ids: Optional[List[int]] = Field(default_factory=list)
+    outputs: Optional[List[int]] = Field(default_factory=list)
     setting_input: Optional[Any] = None
 
     @property
     def data(self) -> Any:
-        """
-        Property to access the node's specific settings.
-        :return: The settings of the node.
-        """
         return self.setting_input
 
     @property
     def main_input_ids(self) -> Optional[List[int]]:
-        """
-        Property to access the main input node IDs.
-        :return: A list of main input node IDs.
-        """
         return self.input_ids
 
+    @field_validator('setting_input', mode='before')
+    @classmethod
+    def validate_setting_input(cls, v, info: ValidationInfo):
+        if v is None:
+            return None
+        if isinstance(v, BaseModel):
+            return v
+
+        node_type = info.data.get('type')
+        model_class = get_settings_class_for_node_type(node_type)
+
+        if model_class is None:
+            raise ValueError(f"Unknown node type: {node_type}")
+
+        if isinstance(v, model_class):
+            return v
+
+        return model_class.model_validate(v)
+
 
 class FlowInformation(BaseModel):
     """
@@ -223,6 +330,19 @@ class FlowInformation(BaseModel):
         return str(v) if v is not None else ''
 
 
+class NodeConnection(BaseModel):
+    """
+    Represents a connection between two nodes in the flow.
+
+    Attributes:
+        from_node_id (int): The ID of the source node.
+        to_node_id (int): The ID of the target node.
+    """
+    model_config = ConfigDict(frozen=True)
+    from_node_id: int
+    to_node_id: int
+
+
 class NodeInput(NodeTemplate):
     """
     Represents a node as it is received from the frontend, including position.
@@ -269,8 +389,6 @@ class VueFlowInput(BaseModel):
     node_inputs: List[NodeInput]
 
 
-
-
 class NodeDefault(BaseModel):
     """
     Defines default properties for a node type.
@@ -285,8 +403,3 @@ class NodeDefault(BaseModel):
     node_type: NodeTypeLiteral
     transform_type: TransformTypeLiteral
     has_default_settings: Optional[Any] = None
-
-
-# Define SecretRef here if not in a common location
-SecretRef = Annotated[str, StringConstraints(min_length=1, max_length=100),
-                      Field(description="An ID referencing an encrypted secret.")]