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

flowfile_frame/flow_frame.py

@@ -4,7 +4,7 @@ import inspect
 import os
 import re
 from collections.abc import Iterable, Iterator, Mapping
-from typing import Any, Literal, Optional, Union, get_args, get_origin
+from typing import Any, Literal, Union, get_args, get_origin
 
 import polars as pl
 from pl_fuzzy_frame_match import FuzzyMapping
@@ -239,7 +239,7 @@ class FlowFrame:
         node_id: int | None = None,
         parent_node_id: int | None = None,
         **kwargs,  # Accept and ignore any other kwargs for API compatibility
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Unified constructor for FlowFrame.
 
@@ -384,7 +384,7 @@ class FlowFrame:
         multithreaded: bool = True,
         maintain_order: bool = False,
         description: str | None = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Sort the dataframe by the given columns.
         """
@@ -469,7 +469,7 @@ class FlowFrame:
                 unique_raw_definitions = list(dict.fromkeys(collected_raw_definitions))  # Order-preserving unique
                 definitions_section = "\n\n".join(unique_raw_definitions)
                 final_code_for_node = (
-                    definitions_section + "\\#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
+                    definitions_section + "\n#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
                 )
             else:
                 final_code_for_node = polars_operation_code
@@ -615,7 +615,7 @@ class FlowFrame:
         coalesce: bool = None,
         maintain_order: Literal[None, "left", "right", "left_right", "right_left"] = None,
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Add a join operation to the Logical Plan.
 
@@ -714,7 +714,7 @@ class FlowFrame:
             and suffix == "_right"
         )
 
-    def _ensure_same_graph(self, other: "FlowFrame") -> None:
+    def _ensure_same_graph(self, other: FlowFrame) -> None:
         """Ensure both FlowFrames are in the same graph, combining if necessary."""
         if self.flow_graph.flow_id != other.flow_graph.flow_id:
             combined_graph, node_mappings = combine_flow_graphs_with_mapping(self.flow_graph, other.flow_graph)
@@ -754,7 +754,7 @@ class FlowFrame:
 
     def _execute_polars_code_join(
         self,
-        other: "FlowFrame",
+        other: FlowFrame,
         new_node_id: int,
         on: list[str | Column] | str | Column,
         left_on: list[str | Column] | str | Column,
@@ -768,7 +768,7 @@ class FlowFrame:
         coalesce: bool,
         maintain_order: Literal[None, "left", "right", "left_right", "right_left"],
         description: str,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """Execute join using Polars code approach."""
         # Build the code arguments
         code_kwargs = self._build_polars_join_kwargs(
@@ -843,12 +843,12 @@ class FlowFrame:
 
     def _execute_native_join(
         self,
-        other: "FlowFrame",
+        other: FlowFrame,
         new_node_id: int,
         join_mappings: list | None,
         how: str,
         description: str,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """Execute join using native FlowFile join nodes."""
         # Create select inputs for both frames
 
@@ -896,9 +896,9 @@ class FlowFrame:
     def _add_cross_join_node(
         self,
         new_node_id: int,
-        join_input: "transform_schema.CrossJoinInput",
+        join_input: transform_schema.CrossJoinInput,
         description: str,
-        other: "FlowFrame",
+        other: FlowFrame,
     ) -> None:
         """Add a cross join node to the graph."""
         cross_join_settings = input_schema.NodeCrossJoin(
@@ -916,9 +916,9 @@ class FlowFrame:
     def _add_regular_join_node(
         self,
         new_node_id: int,
-        join_input: "transform_schema.JoinInput",
+        join_input: transform_schema.JoinInput,
         description: str,
-        other: "FlowFrame",
+        other: FlowFrame,
     ) -> None:
         """Add a regular join node to the graph."""
         join_settings = input_schema.NodeJoin(
@@ -935,7 +935,7 @@ class FlowFrame:
         )
         self.flow_graph.add_join(join_settings)
 
-    def _add_number_of_records(self, new_node_id: int, description: str = None) -> "FlowFrame":
+    def _add_number_of_records(self, new_node_id: int, description: str = None) -> FlowFrame:
         node_number_of_records = input_schema.NodeRecordCount(
             flow_id=self.flow_graph.flow_id,
             node_id=new_node_id,
@@ -948,7 +948,7 @@ class FlowFrame:
         self.flow_graph.add_record_count(node_number_of_records)
         return self._create_child_frame(new_node_id)
 
-    def rename(self, mapping: Mapping[str, str], *, strict: bool = True, description: str = None) -> "FlowFrame":
+    def rename(self, mapping: Mapping[str, str], *, strict: bool = True, description: str = None) -> FlowFrame:
         """Rename columns based on a mapping or function."""
         return self.select(
             [col(old_name).alias(new_name) for old_name, new_name in mapping.items()],
@@ -958,7 +958,7 @@ class FlowFrame:
 
     def select(
         self, *columns: str | Expr | Selector, description: str | None = None, _keep_missing: bool = False
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Select columns from the frame.
         """
@@ -1041,7 +1041,7 @@ class FlowFrame:
                 unique_raw_definitions = list(dict.fromkeys(collected_raw_definitions))
                 definitions_section = "\n\n".join(unique_raw_definitions)
                 final_code_for_node = (
-                    definitions_section + "\\#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
+                    definitions_section + "\n#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
                 )
             else:
                 final_code_for_node = polars_operation_code
@@ -1068,7 +1068,7 @@ class FlowFrame:
         flowfile_formula: str | None = None,
         description: str | None = None,
         **constraints: Any,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Filter rows based on a predicate.
         """
@@ -1125,7 +1125,7 @@ class FlowFrame:
                 unique_raw_definitions = list(dict.fromkeys(collected_raw_definitions))  # Order-preserving unique
                 definitions_section = "\n\n".join(unique_raw_definitions)
                 final_code_for_node = (
-                    definitions_section + "\\#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
+                    definitions_section + "\n#─────SPLIT─────\n\n" + f"output_df = {polars_operation_code}"
                 )
             else:
                 final_code_for_node = polars_operation_code
@@ -1184,7 +1184,7 @@ class FlowFrame:
         description: str = None,
         convert_to_absolute_path: bool = True,
         **kwargs: Any,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Write the data to a Parquet file. Creates a standard Output node if only
         'path' and standard options are provided. Falls back to a Polars Code node
@@ -1275,7 +1275,7 @@ class FlowFrame:
         description: str = None,
         convert_to_absolute_path: bool = True,
         **kwargs: Any,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         new_node_id = generate_node_id()
         is_path_input = isinstance(file, (str, os.PathLike))
         if isinstance(file, os.PathLike):
@@ -1346,7 +1346,7 @@ class FlowFrame:
         connection_name: str | None = None,
         compression: Literal["snappy", "gzip", "brotli", "lz4", "zstd"] = "snappy",
         description: str | None = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Write the data frame to cloud storage in Parquet format.
 
@@ -1380,7 +1380,7 @@ class FlowFrame:
         delimiter: str = ";",
         encoding: CsvEncoding = "utf8",
         description: str | None = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Write the data frame to cloud storage in CSV format.
 
@@ -1415,7 +1415,7 @@ class FlowFrame:
         connection_name: str | None = None,
         write_mode: Literal["overwrite", "append"] = "overwrite",
         description: str | None = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Write the data frame to cloud storage in Delta Lake format.
 
@@ -1445,7 +1445,7 @@ class FlowFrame:
         path: str,
         connection_name: str | None = None,
         description: str | None = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Write the data frame to cloud storage in JSON format.
 
@@ -1523,7 +1523,7 @@ class FlowFrame:
             return self.data.collect(*args, **kwargs)
         return self.data
 
-    def _with_flowfile_formula(self, flowfile_formula: str, output_column_name, description: str = None) -> "FlowFrame":
+    def _with_flowfile_formula(self, flowfile_formula: str, output_column_name, description: str = None) -> FlowFrame:
         new_node_id = generate_node_id()
         function_settings = input_schema.NodeFormula(
             flow_id=self.flow_graph.flow_id,
@@ -1552,7 +1552,7 @@ class FlowFrame:
     def limit(self, n: int, description: str = None):
         return self.head(n, description)
 
-    def cache(self) -> "FlowFrame":
+    def cache(self) -> FlowFrame:
         setting_input = self.get_node_settings().setting_input
         setting_input.cache_results = True
         self.data.cache()
@@ -1572,7 +1572,7 @@ class FlowFrame:
         sort_columns: bool = False,
         separator: str = "_",
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Pivot a DataFrame from long to wide format.
 
@@ -1694,7 +1694,7 @@ class FlowFrame:
         variable_name: str = "variable",
         value_name: str = "value",
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Unpivot a DataFrame from wide to long format.
 
@@ -1795,12 +1795,12 @@ class FlowFrame:
 
     def concat(
         self,
-        other: "FlowFrame" | list["FlowFrame"],
+        other: FlowFrame | list[FlowFrame],
         how: str = "vertical",
         rechunk: bool = False,
         parallel: bool = True,
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Combine multiple FlowFrames into a single FlowFrame.
 
@@ -1913,7 +1913,7 @@ class FlowFrame:
 
     def _detect_cum_count_record_id(
         self, expr: Any, new_node_id: int, description: str | None = None
-    ) -> tuple[bool, Optional["FlowFrame"]]:
+    ) -> tuple[bool, FlowFrame | None]:
         """
         Detect if the expression is a cum_count operation and use record_id if possible.
 
@@ -2032,7 +2032,7 @@ class FlowFrame:
         output_column_names: list[str] | None = None,
         description: str | None = None,
         **named_exprs: Expr | Any,  # Allow Any for implicit lit conversion
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Add or replace columns in the DataFrame.
         """
@@ -2110,7 +2110,7 @@ class FlowFrame:
         else:
             raise ValueError("Either exprs/named_exprs or flowfile_formulas with output_column_names must be provided")
 
-    def with_row_index(self, name: str = "index", offset: int = 0, description: str = None) -> "FlowFrame":
+    def with_row_index(self, name: str = "index", offset: int = 0, description: str = None) -> FlowFrame:
         """
         Add a row index as the first column in the DataFrame.
 
@@ -2166,7 +2166,7 @@ class FlowFrame:
         columns: str | Column | Iterable[str | Column],
         *more_columns: str | Column,
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Explode the dataframe to long format by exploding the given columns.
 
@@ -2219,10 +2219,10 @@ class FlowFrame:
 
     def fuzzy_match(
         self,
-        other: "FlowFrame",
+        other: FlowFrame,
         fuzzy_mappings: list[FuzzyMapping],
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         self._ensure_same_graph(other)
 
         # Step 3: Generate new node ID
@@ -2253,7 +2253,7 @@ class FlowFrame:
         delimiter: str = None,
         split_by_column: str = None,
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Split text in a column into multiple rows.
 
@@ -2314,12 +2314,12 @@ class FlowFrame:
 
     def unique(
         self,
-        subset: Union[str, "Expr", list[Union[str, "Expr"]]] = None,
+        subset: str | Expr | list[str | Expr] = None,
         *,
         keep: Literal["first", "last", "any", "none"] = "any",
         maintain_order: bool = False,
         description: str = None,
-    ) -> "FlowFrame":
+    ) -> FlowFrame:
         """
         Drop duplicate rows from this dataframe.
 

flowfile_frame/lazy.py

@@ -8,7 +8,7 @@ import polars as pl
 from flowfile_core.flowfile.flow_graph import FlowGraph
 from flowfile_frame.expr import Expr
 from flowfile_frame.flow_frame import FlowFrame, can_be_expr, generate_node_id
-from flowfile_frame.utils import _get_function_source
+from flowfile_frame.callable_utils import resolve_callable
 
 
 def _determine_return_type(func_signature: inspect.Signature) -> Literal["FlowFrame", "Expr"]:
@@ -146,17 +146,8 @@ def _process_callable_arg(arg: Any) -> tuple[str, Any, bool, str | None]:
     Returns:
         Tuple of (repr_string, processed_arg, convertible_to_code, function_source)
     """
-    function_source = None
-    if hasattr(arg, "__name__") and arg.__name__ != "<lambda>":
-        # Try to get function source
-        try:
-            function_source, _ = _get_function_source(arg)
-        except:
-            pass
-        return arg.__name__, arg, True, function_source
-    else:
-        # For lambdas or callables without a proper name
-        return repr(arg), arg, False, None
+    resolved = resolve_callable(arg)
+    return resolved.name, arg, resolved.resolved, resolved.source
 
 
 def _process_argument(arg: Any, can_be_expr: bool) -> tuple[str, Any, bool, str | None]:

flowfile_frame/lazy_methods.py

@@ -1,14 +1,10 @@
 from collections.abc import Callable
 from functools import wraps
-from typing import TypeVar
 
 import polars as pl
 
+from flowfile_frame.callable_utils import process_callable_args
 from flowfile_frame.config import logger
-from flowfile_frame.utils import _get_function_source
-
-T = TypeVar("T")
-FlowFrameT = TypeVar("FlowFrameT", bound="FlowFrame")
 
 PASSTHROUGH_METHODS = {
     "collect",
@@ -114,68 +110,13 @@ def create_lazyframe_method_wrapper(method_name: str, original_method: Callable)
             logger.debug("Warning, could not create a good node")
             return self.__class__(getattr(self.data, method_name)(arg.expr for arg in args), flow_graph=self.flow_graph)
 
-        # Collect function sources and build representations
-        function_sources = []
-        args_representations = []
-        kwargs_representations = []
-
-        # Process positional arguments
-        for arg in args:
-            if callable(arg) and not isinstance(arg, type):
-                # Try to get function source
-                try:
-                    source, is_module_level = _get_function_source(arg)
-                    if source and hasattr(arg, "__name__") and arg.__name__ != "<lambda>":
-                        function_sources.append(source)
-                        # Use the function name in the representation
-                        args_representations.append(arg.__name__)
-                    else:
-                        # Fallback to repr if we can't get the source
-                        args_representations.append(repr(arg))
-                except:
-                    args_representations.append(repr(arg))
-            else:
-                args_representations.append(repr(arg))
-        # Process keyword arguments
-        for key, value in kwargs.items():
-            if callable(value) and not isinstance(value, type):
-                # Try to get function source
-                try:
-                    source, is_module_level = _get_function_source(value)
-                    if source and hasattr(value, "__name__") and value.__name__ != "<lambda>":
-                        function_sources.append(source)
-                        kwargs_representations.append(f"{key}={value.__name__}")
-                    else:
-                        kwargs_representations.append(f"{key}={repr(value)}")
-                except:
-                    kwargs_representations.append(f"{key}={repr(value)}")
-            else:
-                kwargs_representations.append(f"{key}={repr(value)}")
-
-        # Build parameter string
-        args_str = ", ".join(args_representations)
-        kwargs_str = ", ".join(kwargs_representations)
-
-        if args_str and kwargs_str:
-            params_str = f"{args_str}, {kwargs_str}"
-        elif args_str:
-            params_str = args_str
-        elif kwargs_str:
-            params_str = kwargs_str
-        else:
-            params_str = ""
+        processed = process_callable_args(args, kwargs)
 
         # Build the code
-        operation_code = f"input_df.{method_name}({params_str})"
-
-        if function_sources:
-            unique_sources = []
-            seen = set()
-            for source in function_sources:
-                if source not in seen:
-                    seen.add(source)
-                    unique_sources.append(source)
+        operation_code = f"input_df.{method_name}({processed.params_repr})"
 
+        if processed.function_sources:
+            unique_sources = list(dict.fromkeys(processed.function_sources))
             functions_section = "# Function definitions\n" + "\n\n".join(unique_sources)
             code = functions_section + "\n#─────SPLIT─────\n\noutput_df = " + operation_code
         else:

flowfile_frame/utils.py

@@ -1,5 +1,3 @@
-import inspect
-import textwrap
 import uuid
 from collections.abc import Iterable
 from typing import Any
@@ -9,6 +7,13 @@ import polars as pl
 from flowfile_core.flowfile.flow_graph import FlowGraph
 from flowfile_core.schemas import schemas
 
+# Re-export for backwards compatibility — canonical home is callable_utils
+from flowfile_frame.callable_utils import (  # noqa: F401
+    _extract_lambda_source,
+    _get_function_source,
+    _is_safely_representable,
+)
+
 
 def _is_iterable(obj: Any) -> bool:
     # Avoid treating strings as iterables in this context
@@ -43,35 +48,6 @@ def get_pl_expr_from_expr(expr: Any) -> pl.Expr:
     return expr.expr
 
 
-def _get_function_source(func):
-    """
-    Get the source code of a function if possible.
-
-    Returns:
-        tuple: (source_code, is_module_level)
-    """
-    try:
-        # Try to get the source code
-        source = inspect.getsource(func)
-
-        # Check if it's a lambda
-        if func.__name__ == "<lambda>":
-            # Extract just the lambda expression
-            # This is tricky as getsource returns the entire line
-            return None, False
-
-        # Check if it's a module-level function
-        is_module_level = func.__code__.co_flags & 0x10 == 0
-
-        # Dedent the source to remove any indentation
-        source = textwrap.dedent(source)
-
-        return source, is_module_level
-    except (OSError, TypeError):
-        # Can't get source (e.g., built-in function, C extension)
-        return None, False
-
-
 def ensure_inputs_as_iterable(inputs: Any | Iterable[Any]) -> list[Any]:
     """Convert inputs to list, treating strings as single items."""
     if inputs is None or (hasattr(inputs, "__len__") and len(inputs) == 0):
@@ -99,7 +75,12 @@ def create_flow_graph(flow_id: int = None) -> FlowGraph:
     """
     if flow_id is None:
         flow_id = _generate_id()
-    flow_settings = schemas.FlowSettings(flow_id=flow_id, name=f"Flow_{flow_id}", path=f"flow_{flow_id}")
+    flow_settings = schemas.FlowSettings(
+        flow_id=flow_id,
+        name=f"Flow_{flow_id}",
+        path=f"flow_{flow_id}",
+        track_history=False,  # Disable undo/redo history for flowfile_frame
+    )
     flow_graph = FlowGraph(flow_settings=flow_settings)
     flow_graph.flow_settings.execution_location = (
         "local"  # always create a local frame so that the run time does not attempt to use the flowfile_worker process

flowfile_worker/funcs.py

@@ -1,7 +1,6 @@
 import io
 import logging
 import os
-from base64 import encodebytes
 from collections.abc import Callable
 from logging import Logger
 from multiprocessing import Array, Queue, Value
@@ -56,7 +55,8 @@ def fuzzy_join_task(
     lf = pl.scan_ipc(file_path)
     number_of_records = collect_lazy_frame(lf.select(pl.len()))[0, 0]
     flowfile_logger.info(f"Number of records after fuzzy match: {number_of_records}")
-    queue.put(encodebytes(lf.serialize()))
+    # Put raw bytes in queue - encoding happens at the transport boundary
+    queue.put(lf.serialize())
 
 
 def process_and_cache(
@@ -126,7 +126,8 @@ def store(
     lf = pl.scan_ipc(file_path)
     number_of_records = collect_lazy_frame(lf.select(pl.len()))[0, 0]
     flowfile_logger.info(f"Number of records processed: {number_of_records}")
-    queue.put(encodebytes(lf.serialize()))
+    # Put raw bytes in queue - encoding happens at the transport boundary
+    queue.put(lf.serialize())
 
 
 def calculate_schema_logic(
@@ -432,4 +433,5 @@ def generic_task(
     lf = pl.scan_ipc(file_path)
     number_of_records = collect_lazy_frame(lf.select(pl.len()))[0, 0]
     flowfile_logger.info(f"Number of records processed: {number_of_records}")
-    queue.put(encodebytes(lf.serialize()))
+    # Put raw bytes in queue - encoding happens at the transport boundary
+    queue.put(lf.serialize())

flowfile_worker/main.py

@@ -8,6 +8,7 @@ from fastapi import FastAPI
 from flowfile_worker import mp_context
 from flowfile_worker.configs import FLOWFILE_CORE_URI, SERVICE_HOST, SERVICE_PORT, logger
 from flowfile_worker.routes import router
+from flowfile_worker.streaming import streaming_router
 from shared.storage_config import storage
 
 should_exit = False
@@ -40,6 +41,7 @@ async def shutdown_handler(app: FastAPI):
 
 app = FastAPI(lifespan=shutdown_handler)
 app.include_router(router)
+app.include_router(streaming_router)
 
 
 @app.post("/shutdown")

flowfile_worker/models.py

@@ -1,12 +1,28 @@
-from base64 import decodebytes
-from typing import Any, Literal
+from base64 import b64decode, b64encode
+from typing import Annotated, Any, Literal
 
 from pl_fuzzy_frame_match import FuzzyMapping
-from pydantic import BaseModel
+from pydantic import BaseModel, BeforeValidator, PlainSerializer
 
 from flowfile_worker.external_sources.s3_source.models import CloudStorageWriteSettings
 from flowfile_worker.external_sources.sql_source.models import DatabaseWriteSettings
 
+
+# Custom type for bytes that serializes to/from base64 string in JSON
+def _decode_bytes(v: Any) -> bytes:
+    if isinstance(v, bytes):
+        return v
+    if isinstance(v, str):
+        return b64decode(v)
+    raise ValueError(f"Expected bytes or base64 string, got {type(v)}")
+
+
+Base64Bytes = Annotated[
+    bytes,
+    BeforeValidator(_decode_bytes),
+    PlainSerializer(lambda x: b64encode(x).decode('ascii'), return_type=str),
+]
+
 OperationType = Literal[
     "store",
     "calculate_schema",
@@ -21,12 +37,13 @@ ResultType = Literal["polars", "other"]
 
 
 class PolarsOperation(BaseModel):
-    operation: bytes
+    operation: Base64Bytes  # Automatically encodes/decodes base64 for JSON
     flowfile_flow_id: int | None = 1
     flowfile_node_id: int | str | None = -1
 
     def polars_serializable_object(self):
-        return decodebytes(self.operation)
+        # Operation is raw bytes (auto-decoded from base64 if received as JSON)
+        return self.operation
 
 
 class PolarsScript(PolarsOperation):
@@ -40,7 +57,7 @@ class PolarsScriptSample(PolarsScript):
 
 
 class PolarsScriptWrite(BaseModel):
-    operation: bytes
+    operation: Base64Bytes  # Automatically encodes/decodes base64 for JSON
     data_type: str
     path: str
     write_mode: str
@@ -50,14 +67,16 @@ class PolarsScriptWrite(BaseModel):
     flowfile_node_id: int | str | None = -1
 
     def polars_serializable_object(self):
-        return decodebytes(self.operation)
+        # Operation is raw bytes (auto-decoded from base64 if received as JSON)
+        return self.operation
 
 
 class DatabaseScriptWrite(DatabaseWriteSettings):
-    operation: bytes
+    operation: Base64Bytes  # Automatically encodes/decodes base64 for JSON
 
     def polars_serializable_object(self):
-        return decodebytes(self.operation)
+        # Operation is raw bytes (auto-decoded from base64 if received as JSON)
+        return self.operation
 
     def get_database_write_settings(self) -> DatabaseWriteSettings:
         """
@@ -75,10 +94,11 @@ class DatabaseScriptWrite(DatabaseWriteSettings):
 
 
 class CloudStorageScriptWrite(CloudStorageWriteSettings):
-    operation: bytes
+    operation: Base64Bytes  # Automatically encodes/decodes base64 for JSON
 
     def polars_serializable_object(self):
-        return decodebytes(self.operation)
+        # Operation is raw bytes (auto-decoded from base64 if received as JSON)
+        return self.operation
 
     def get_cloud_storage_write_settings(self) -> CloudStorageWriteSettings:
         """