Flowfile 0.3.3__tar.gz → 0.3.3.1__tar.gz

{flowfile-0.3.3 → flowfile-0.3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Flowfile
-Version: 0.3.3
+Version: 0.3.3.1
 Summary: Project combining flowfile core (backend) and flowfile_worker (compute offloader) and flowfile_frame (api)
 Author: Edward van Eechoud
 Author-email: evaneechoud@gmail.com
@@ -23,10 +23,11 @@ Requires-Dist: methodtools (>=0.4.7,<0.5.0)
 Requires-Dist: openpyxl (>=3.1.2,<3.2.0)
 Requires-Dist: passlib (>=1.7.4,<1.8.0)
 Requires-Dist: pendulum (==2.1.2) ; python_version < "3.12"
-Requires-Dist: polars (>1.8.2,<=1.25.2)
+Requires-Dist: polars (>=1.8.2,<2.0.0) ; sys_platform != "win32"
+Requires-Dist: polars (>=1.8.2,<=1.25.2) ; sys_platform == "win32"
 Requires-Dist: polars-distance (>=0.4.3,<0.5.0)
 Requires-Dist: polars-ds (>=0.6.0)
-Requires-Dist: polars-expr-transformer (>0.4.7.0)
+Requires-Dist: polars-expr-transformer (>=0.4.9.0)
 Requires-Dist: polars-grouper (>=0.3.0,<0.4.0)
 Requires-Dist: polars_simed (>=0.3.4,<0.4.0)
 Requires-Dist: pyairbyte-flowfile (==0.20.2)

{flowfile-0.3.3 → flowfile-0.3.3.1}/flowfile/__init__.py

@@ -7,7 +7,7 @@ This package ties together the FlowFile ecosystem components:
 - flowfile_worker: Computation engine
 """
 
-__version__ = "0.3.1"
+__version__ = "0.3.3.1"
 
 import os
 import logging

{flowfile-0.3.3 → flowfile-0.3.3.1}/flowfile_frame/flowfile_frame/flow_frame.py

@@ -738,10 +738,9 @@ class FlowFrame:
         all_input_expr_objects: List[Expr] = []
         pure_polars_expr_strings_for_select: List[str] = []
         collected_raw_definitions: List[str] = []
-        selected_col_names_for_native: List[str] = []  # For native node
+        selected_col_names_for_native: List[transform_schema.SelectInput] = []  # For native node
 
         can_use_native_node = True
-
         if len(columns_iterable) == 1 and isinstance(columns_iterable[0], str) and columns_iterable[0] == '*':
             effective_columns_iterable = [col(c_name) for c_name in self.columns]
         else:
@@ -752,15 +751,14 @@ class FlowFrame:
 
             if isinstance(expr_input, str):
                 current_expr_obj = col(expr_input)
-                selected_col_names_for_native.append(expr_input)
+                selected_col_names_for_native.append(transform_schema.SelectInput(old_name=expr_input))
                 is_simple_col_for_native = True
-            elif isinstance(expr_input, Column) and not expr_input._select_input.is_altered:  # type: ignore
-                selected_col_names_for_native.append(expr_input.column_name)  # type: ignore
+            elif isinstance(expr_input, Column):
+                selected_col_names_for_native.append(expr_input.to_select_input())
                 is_simple_col_for_native = True
-            elif isinstance(expr_input, Selector):  # Selectors imply Polars code path
+            elif isinstance(expr_input, Selector):
                 can_use_native_node = False
-                # current_expr_obj = expr_input # Already an Expr-like via selector
-            elif not isinstance(expr_input, Expr):  # Includes Column
+            elif not isinstance(expr_input, Expr):
                 current_expr_obj = lit(expr_input)
 
             all_input_expr_objects.append(current_expr_obj)  # type: ignore
@@ -772,20 +770,19 @@ class FlowFrame:
                 collected_raw_definitions.append(raw_defs_str)
 
             if not is_simple_col_for_native and not isinstance(expr_input, Selector):
-                can_use_native_node = False  # Complex expressions require Polars code
+                can_use_native_node = False
         if collected_raw_definitions:  # Has to use Polars code if there are definitions
             can_use_native_node = False
         if can_use_native_node:
-            select_inputs_for_node = [transform_schema.SelectInput(old_name=name) for name in
-                                      selected_col_names_for_native]
             existing_cols = self.columns
+            selected_col_names = {select_col.old_name for select_col in selected_col_names_for_native}
             dropped_columns = [transform_schema.SelectInput(c, keep=False) for c in existing_cols if
-                               c not in selected_col_names_for_native]
-            select_inputs_for_node.extend(dropped_columns)
+                               c not in selected_col_names]
+            selected_col_names_for_native.extend(dropped_columns)
             select_settings = input_schema.NodeSelect(
                 flow_id=self.flow_graph.flow_id,
                 node_id=new_node_id,
-                select_input=select_inputs_for_node,
+                select_input=selected_col_names_for_native,
                 keep_missing=False,
                 pos_x=200,
                 pos_y=100,

{flowfile-0.3.3 → flowfile-0.3.3.1}/flowfile_frame/flowfile_frame/flow_frame.pyi

@@ -1,27 +1,43 @@
-# This file was auto-generated to provide type information for FlowFrame
-# DO NOT MODIFY THIS FILE MANUALLY
+# Standard library imports
 import collections
-import typing
 import inspect
-from typing import List, Dict, Optional, Union, ForwardRef
-import polars as pl
-from polars.lazyframe.frame import *
-from polars._typing import SchemaDict
-from polars.type_aliases import ColumnNameOrSelector, FillNullStrategy
+import os
+import sys
+import typing
+from io import IOBase
+from typing import List, Optional, ForwardRef
+from collections.abc import Awaitable
 
+# Third-party imports
+import polars as pl
+from polars._typing import * # Consider specifying needed imports
+from polars._utils.async_ import _GeventDataFrameResult
+from polars.dependencies import polars_cloud as pc
+from polars.io.cloud import CredentialProviderFunction
+from polars.lazyframe.frame import LazyGroupBy
+from polars.type_aliases import (Schema, IntoExpr, ClosedInterval, Label, StartBy, RollingInterpolationMethod, IpcCompression, CompatLevel, SyncOnCloseMethod, ExplainFormat, EngineType, SerializationFormat, AsofJoinStrategy)
+
+# Local application/library specific imports
 import flowfile_frame
-from flowfile_core.flowfile.flow_node.flow_node import FlowNode
 from flowfile_core.flowfile.FlowfileFlow import FlowGraph
+from flowfile_core.flowfile.flow_node.flow_node import FlowNode
 from flowfile_frame import group_frame
-from flowfile_frame.expr import Expr, Column
-from flowfile_frame.selectors import Selector
+from flowfile_frame.expr import Expr
+
+# Conditional imports
+if sys.version_info >= (3, 10):
+    pass  # from typing import ParamSpec, Concatenate (if needed)
+else:
+    from typing_extensions import Concatenate
 
 T = TypeVar('T')
+P = typing.ParamSpec('P')
+LazyFrameT = TypeVar('LazyFrameT', bound='LazyFrame')
 FlowFrameT = TypeVar('FlowFrameT', bound='FlowFrame')
-# Define NoneType to handle type hints with None
+Self = TypeVar('Self', bound='FlowFrame')
 NoneType = type(None)
 
-# Module-level functions
+# Module-level functions (example from your input)
 def can_be_expr(param: inspect.Parameter) -> bool: ...
 def generate_node_id() -> int: ...
 def get_method_name_from_code(code: str) -> str | None: ...
@@ -37,7 +53,7 @@ class FlowFrame:
     parent_node_id: Optional[int]
 
     # This special method determines how the object behaves in boolean contexts.
-    def __bool__(self, ) -> Any: ...
+    def __bool__(self) -> Any: ...
 
     # This special method enables the 'in' operator to work with FlowFrame objects.
     def __contains__(self, key) -> Any: ...
@@ -49,7 +65,7 @@ class FlowFrame:
     def __gt__(self, other: Any) -> typing.NoReturn: ...
 
     # Initialize the FlowFrame with data and graph references.
-    def __init__(self, data: Union[LazyFrame, Mapping, Sequence, ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: Union[Mapping, Sequence, NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: Union[Literal, NoneType]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None) -> Any: ...
+    def __init__(self, data: typing.Union[LazyFrame, collections.abc.Mapping[str, typing.Union[collections.abc.Sequence[object], collections.abc.Mapping[str, collections.abc.Sequence[object]], ForwardRef('Series')]], collections.abc.Sequence[typing.Any], ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: typing.Union[collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]], collections.abc.Sequence[typing.Union[str, tuple[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]]]], NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: typing.Optional[typing.Literal['col', 'row']]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None) -> None: ...
 
     def __le__(self, other: Any) -> typing.NoReturn: ...
 
@@ -58,16 +74,16 @@ class FlowFrame:
     def __ne__(self, other: object) -> typing.NoReturn: ...
 
     # Create a new FlowFrame instance.
-    def __new__(self, cls, data: Union[LazyFrame, Mapping, Sequence, ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: Union[Mapping, Sequence, NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: Union[Literal, NoneType]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None) -> Any: ...
+    def __new__(cls, data: typing.Union[LazyFrame, collections.abc.Mapping[str, typing.Union[collections.abc.Sequence[object], collections.abc.Mapping[str, collections.abc.Sequence[object]], ForwardRef('Series')]], collections.abc.Sequence[typing.Any], ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: typing.Union[collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]], collections.abc.Sequence[typing.Union[str, tuple[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]]]], NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: typing.Optional[typing.Literal['col', 'row']]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None) -> Self: ...
 
-    def __repr__(self, ) -> Any: ...
+    def __repr__(self) -> Any: ...
 
     # Helper method to add a connection between nodes
     def _add_connection(self, from_id, to_id, input_type: typing.Literal['main', 'left', 'right']='main') -> Any: ...
 
     def _add_number_of_records(self, new_node_id: int, description: str=None) -> 'FlowFrame': ...
 
-    def _add_polars_code(self, new_node_id: int, code: str, description: str=None, depending_on_ids: Union[List, NoneType]=None, convertable_to_code: bool=True, method_name: str=None, polars_expr: Union[Expr, List, NoneType]=None, group_expr: Union[Expr, List, NoneType]=None, kwargs_expr: Union[Dict, NoneType]=None, group_kwargs: Union[Dict, NoneType]=None) -> Any: ...
+    def _add_polars_code(self, new_node_id: int, code: str, depending_on_ids: typing.Optional[typing.List[str]]=None, convertable_to_code: bool=True, method_name: str=None, polars_expr: typing.Union[flowfile_frame.expr.Expr, typing.List[flowfile_frame.expr.Expr], NoneType]=None, group_expr: typing.Union[flowfile_frame.expr.Expr, typing.List[flowfile_frame.expr.Expr], NoneType]=None, kwargs_expr: typing.Optional[typing.Dict]=None, group_kwargs: typing.Optional[typing.Dict]=None, description: str=None) -> Any: ...
 
     def _comparison_error(self, operator: str) -> typing.NoReturn: ...
 
@@ -75,7 +91,7 @@ class FlowFrame:
     def _create_child_frame(self, new_node_id) -> 'FlowFrame': ...
 
     # Detect if the expression is a cum_count operation and use record_id if possible.
-    def _detect_cum_count_record_id(self, expr: Any, new_node_id: int, description: Union[str, NoneType]=None) -> 'FlowFrame': ...
+    def _detect_cum_count_record_id(self, expr: Any, new_node_id: int, description: typing.Optional[str]=None) -> 'FlowFrame': ...
 
     # Generates the `input_df.sort(...)` Polars code string using pure expression strings.
     def _generate_sort_polars_code(self, pure_sort_expr_strs: typing.List[str], descending_values: typing.List[bool], nulls_last_values: typing.List[bool], multithreaded: bool, maintain_order: bool) -> str: ...
@@ -83,21 +99,21 @@ class FlowFrame:
     def _with_flowfile_formula(self, flowfile_formula: str, output_column_name, description: str=None) -> 'FlowFrame': ...
 
     # Approximate count of unique values.
-    def approx_n_unique(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def approx_n_unique(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Return the `k` smallest rows.
-    def bottom_k(self, k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]=False, description: Optional[str] = None) -> 'FlowFrame': ...
+    def bottom_k(self, k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]=False, description: Optional[str] = None) -> LazyFrame: ...
 
     def cache(self, description: Optional[str] = None) -> 'FlowFrame': ...
 
     # Cast LazyFrame column(s) to the specified dtype(s).
-    def cast(self, dtypes: Mapping[ColumnNameOrSelector | PolarsDataType, PolarsDataType | PythonDataType] | PolarsDataType, strict: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def cast(self, dtypes: Mapping[ColumnNameOrSelector | PolarsDataType, PolarsDataType | PythonDataType] | PolarsDataType, strict: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Create an empty copy of the current LazyFrame, with zero to 'n' rows.
-    def clear(self, n: int=0, description: Optional[str] = None) -> 'FlowFrame': ...
+    def clear(self, n: int=0, description: Optional[str] = None) -> LazyFrame: ...
 
     # Create a copy of this LazyFrame.
-    def clone(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def clone(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Collect lazy data into memory.
     def collect(self, *args, **kwargs) -> Any: ...
@@ -106,55 +122,63 @@ class FlowFrame:
     def collect_async(self, gevent: bool=False, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, no_optimization: bool=False, slice_pushdown: bool=True, comm_subplan_elim: bool=True, comm_subexpr_elim: bool=True, cluster_with_columns: bool=True, collapse_joins: bool=True, engine: EngineType='auto', _check_order: bool=True) -> Awaitable[DataFrame] | _GeventDataFrameResult[DataFrame]: ...
 
     # Resolve the schema of this LazyFrame.
-    def collect_schema(self, ) -> Schema: ...
+    def collect_schema(self) -> Schema: ...
+
+    # Get the column names.
+    @property
+    def columns(self) -> typing.List[str]: ...
 
     # Combine multiple FlowFrames into a single FlowFrame.
-    def concat(self, other: Union[ForwardRef('FlowFrame'), List], how: str='vertical', rechunk: bool=False, parallel: bool=True, description: str=None) -> 'FlowFrame': ...
+    def concat(self, other: typing.Union[ForwardRef('FlowFrame'), typing.List[ForwardRef('FlowFrame')]], how: str='vertical', rechunk: bool=False, parallel: bool=True, description: str=None) -> 'FlowFrame': ...
 
     # Return the number of non-null elements for each column.
-    def count(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def count(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Simple naive implementation of creating the frame from any type. It converts the data to a polars frame,
-    def create_from_any_type(self, data: Union[Mapping, Sequence, ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: Union[Mapping, Sequence, NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: Union[Literal, NoneType]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def create_from_any_type(self, data: typing.Union[collections.abc.Mapping[str, typing.Union[collections.abc.Sequence[object], collections.abc.Mapping[str, collections.abc.Sequence[object]], ForwardRef('Series')]], collections.abc.Sequence[typing.Any], ForwardRef('np.ndarray[Any, Any]'), ForwardRef('pa.Table'), ForwardRef('pd.DataFrame'), ForwardRef('ArrowArrayExportable'), ForwardRef('ArrowStreamExportable')]=None, schema: typing.Union[collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]], collections.abc.Sequence[typing.Union[str, tuple[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType'), type[int], type[float], type[bool], type[str], type['date'], type['time'], type['datetime'], type['timedelta'], type[list[typing.Any]], type[tuple[typing.Any, ...]], type[bytes], type[object], type['Decimal'], type[None], NoneType]]]], NoneType]=None, schema_overrides: collections.abc.Mapping[str, typing.Union[ForwardRef('DataTypeClass'), ForwardRef('DataType')]] | None=None, strict: bool=True, orient: typing.Optional[typing.Literal['col', 'row']]=None, infer_schema_length: int | None=100, nan_to_null: bool=False, flow_graph=None, node_id=None, parent_node_id=None, description: Optional[str] = None) -> Any: ...
 
     # Creates a summary of statistics for a LazyFrame, returning a DataFrame.
     def describe(self, percentiles: Sequence[float] | float | None=(0.25, 0.5, 0.75), interpolation: RollingInterpolationMethod='nearest') -> DataFrame: ...
 
     # Read a logical plan from a file to construct a LazyFrame.
-    def deserialize(self, source: str | Path | IOBase, format: SerializationFormat='binary', description: Optional[str] = None) -> 'FlowFrame': ...
+    def deserialize(self, source: str | Path | IOBase, format: SerializationFormat='binary', description: Optional[str] = None) -> LazyFrame: ...
 
     # Remove columns from the DataFrame.
-    def drop(self, *columns, strict: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def drop(self, *columns, strict: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Drop all rows that contain one or more NaN values.
-    def drop_nans(self, subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None=None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def drop_nans(self, subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None=None, description: Optional[str] = None) -> LazyFrame: ...
 
     # Drop all rows that contain one or more null values.
-    def drop_nulls(self, subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None=None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def drop_nulls(self, subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None=None, description: Optional[str] = None) -> LazyFrame: ...
+
+    # Get the column data types.
+    @property
+    def dtypes(self) -> typing.List[pl.classes.DataType]: ...
 
     # Create a string representation of the query plan.
     def explain(self, format: ExplainFormat='plain', optimized: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, comm_subplan_elim: bool=True, comm_subexpr_elim: bool=True, cluster_with_columns: bool=True, collapse_joins: bool=True, streaming: bool=False, engine: EngineType='auto', tree_format: bool | None=None, _check_order: bool=True) -> str: ...
 
     # Explode the dataframe to long format by exploding the given columns.
-    def explode(self, columns: Union[str, Column, Iterable], *more_columns, description: str=None) -> 'FlowFrame': ...
+    def explode(self, columns: typing.Union[str, flowfile_frame.expr.Column, typing.Iterable[str | flowfile_frame.expr.Column]], *more_columns, description: str=None) -> 'FlowFrame': ...
 
     # Collect a small number of rows for debugging purposes.
     def fetch(self, n_rows: int=500, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, no_optimization: bool=False, slice_pushdown: bool=True, comm_subplan_elim: bool=True, comm_subexpr_elim: bool=True, cluster_with_columns: bool=True, collapse_joins: bool=True) -> DataFrame: ...
 
     # Fill floating point NaN values.
-    def fill_nan(self, value: int | float | Expr | None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def fill_nan(self, value: int | float | Expr | None, description: Optional[str] = None) -> LazyFrame: ...
 
     # Fill null values using the specified value or strategy.
-    def fill_null(self, value: Any | Expr | None=None, strategy: FillNullStrategy | None=None, limit: int | None=None, matches_supertype: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def fill_null(self, value: Any | Expr | None=None, strategy: FillNullStrategy | None=None, limit: int | None=None, matches_supertype: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Filter rows based on a predicate.
-    def filter(self, *predicates, flowfile_formula: Union[str, NoneType]=None, description: Union[str, NoneType]=None, **constraints) -> 'FlowFrame': ...
+    def filter(self, *predicates, flowfile_formula: typing.Optional[str]=None, description: typing.Optional[str]=None, **constraints) -> 'FlowFrame': ...
 
     # Get the first row of the DataFrame.
-    def first(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def first(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Take every nth row in the LazyFrame and return as a new LazyFrame.
-    def gather_every(self, n: int, offset: int=0, description: Optional[str] = None) -> 'FlowFrame': ...
+    def gather_every(self, n: int, offset: int=0, description: Optional[str] = None) -> LazyFrame: ...
 
     def get_node_settings(self, description: Optional[str] = None) -> FlowNode: ...
 
@@ -164,57 +188,57 @@ class FlowFrame:
     # Group based on a time value (or index value of type Int32, Int64).
     def group_by_dynamic(self, index_column: IntoExpr, every: str | timedelta, period: str | timedelta | None=None, offset: str | timedelta | None=None, include_boundaries: bool=False, closed: ClosedInterval='left', label: Label='left', group_by: IntoExpr | Iterable[IntoExpr] | None=None, start_by: StartBy='window', description: Optional[str] = None) -> LazyGroupBy: ...
 
-    def head(self, n: int, description: str=None) -> 'FlowFrame': ...
+    def head(self, n: int, description: str=None) -> Any: ...
 
     # Inspect a node in the computation graph.
-    def inspect(self, fmt: str='{}', description: Optional[str] = None) -> 'FlowFrame': ...
+    def inspect(self, fmt: str='{}', description: Optional[str] = None) -> LazyFrame: ...
 
     # Interpolate intermediate values. The interpolation method is linear.
-    def interpolate(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def interpolate(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Add a join operation to the Logical Plan.
-    def join(self, other, on: Union[List, str, Column]=None, how: str='inner', left_on: Union[List, str, Column]=None, right_on: Union[List, str, Column]=None, suffix: str='_right', validate: str=None, nulls_equal: bool=False, coalesce: bool=None, maintain_order: typing.Literal[None, 'left', 'right', 'left_right', 'right_left']=None, description: str=None) -> 'FlowFrame': ...
+    def join(self, other, on: typing.Union[typing.List[str | flowfile_frame.expr.Column], str, flowfile_frame.expr.Column]=None, how: str='inner', left_on: typing.Union[typing.List[str | flowfile_frame.expr.Column], str, flowfile_frame.expr.Column]=None, right_on: typing.Union[typing.List[str | flowfile_frame.expr.Column], str, flowfile_frame.expr.Column]=None, suffix: str='_right', validate: str=None, nulls_equal: bool=False, coalesce: bool=None, maintain_order: typing.Literal[None, 'left', 'right', 'left_right', 'right_left']=None, description: str=None) -> Any: ...
 
     # Perform an asof join.
-    def join_asof(self, other: LazyFrame, left_on: str | None | Expr=None, right_on: str | None | Expr=None, on: str | None | Expr=None, by_left: str | Sequence[str] | None=None, by_right: str | Sequence[str] | None=None, by: str | Sequence[str] | None=None, strategy: AsofJoinStrategy='backward', suffix: str='_right', tolerance: str | int | float | timedelta | None=None, allow_parallel: bool=True, force_parallel: bool=False, coalesce: bool=True, allow_exact_matches: bool=True, check_sortedness: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def join_asof(self, other: LazyFrame, left_on: str | None | Expr=None, right_on: str | None | Expr=None, on: str | None | Expr=None, by_left: str | Sequence[str] | None=None, by_right: str | Sequence[str] | None=None, by: str | Sequence[str] | None=None, strategy: AsofJoinStrategy='backward', suffix: str='_right', tolerance: str | int | float | timedelta | None=None, allow_parallel: bool=True, force_parallel: bool=False, coalesce: bool=True, allow_exact_matches: bool=True, check_sortedness: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Perform a join based on one or multiple (in)equality predicates.
-    def join_where(self, other: LazyFrame, *predicates, suffix: str='_right', description: Optional[str] = None) -> 'FlowFrame': ...
+    def join_where(self, other: LazyFrame, *predicates, suffix: str='_right', description: Optional[str] = None) -> LazyFrame: ...
 
     # Get the last row of the DataFrame.
-    def last(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def last(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Return lazy representation, i.e. itself.
-    def lazy(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def lazy(self, description: Optional[str] = None) -> LazyFrame: ...
 
-    def limit(self, n: int, description: str=None) -> 'FlowFrame': ...
+    def limit(self, n: int, description: str=None) -> Any: ...
 
     # Apply a custom function.
-    def map_batches(self, function: Callable[[DataFrame], DataFrame], predicate_pushdown: bool=True, projection_pushdown: bool=True, slice_pushdown: bool=True, no_optimizations: bool=False, schema: None | SchemaDict=None, validate_output_schema: bool=True, streamable: bool=False, description: Optional[str] = None) -> 'FlowFrame': ...
+    def map_batches(self, function: Callable[[DataFrame], DataFrame], predicate_pushdown: bool=True, projection_pushdown: bool=True, slice_pushdown: bool=True, no_optimizations: bool=False, schema: None | SchemaDict=None, validate_output_schema: bool=True, streamable: bool=False, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their maximum value.
-    def max(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def max(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their mean value.
-    def mean(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def mean(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their median value.
-    def median(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def median(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Unpivot a DataFrame from wide to long format.
-    def melt(self, id_vars: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None=None, value_vars: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None=None, variable_name: str | None=None, value_name: str | None=None, streamable: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def melt(self, id_vars: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None=None, value_vars: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None=None, variable_name: str | None=None, value_name: str | None=None, streamable: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Take two sorted DataFrames and merge them by the sorted key.
-    def merge_sorted(self, other: LazyFrame, key: str, description: Optional[str] = None) -> 'FlowFrame': ...
+    def merge_sorted(self, other: LazyFrame, key: str, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their minimum value.
-    def min(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def min(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame as the sum of their null value count.
-    def null_count(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def null_count(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Offers a structured way to apply a sequence of user-defined functions (UDFs).
-    def pipe(self, function: Callable[Concatenate[LazyFrame, P], T], *args, **kwargs) -> T: ...
+    def pipe(self, function: Callable[Concatenate[LazyFrame, P], T], *args, description: Optional[str] = None, **kwargs) -> T: ...
 
     # Pivot a DataFrame from long to wide format.
     def pivot(self, on: str | list[str], index: str | list[str] | None=None, values: str | list[str] | None=None, aggregate_function: str | None='first', maintain_order: bool=True, sort_columns: bool=False, separator: str='_', description: str=None) -> 'FlowFrame': ...
@@ -223,40 +247,44 @@ class FlowFrame:
     def profile(self, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, no_optimization: bool=False, slice_pushdown: bool=True, comm_subplan_elim: bool=True, comm_subexpr_elim: bool=True, cluster_with_columns: bool=True, collapse_joins: bool=True, show_plot: bool=False, truncate_nodes: int=0, figsize: tuple[int, int]=(18, 8), engine: EngineType='auto', _check_order: bool=True, **_kwargs) -> tuple[DataFrame, DataFrame]: ...
 
     # Aggregate the columns in the LazyFrame to their quantile value.
-    def quantile(self, quantile: float | Expr, interpolation: RollingInterpolationMethod='nearest', description: Optional[str] = None) -> 'FlowFrame': ...
+    def quantile(self, quantile: float | Expr, interpolation: RollingInterpolationMethod='nearest', description: Optional[str] = None) -> LazyFrame: ...
 
     # Run a query remotely on Polars Cloud.
-    def remote(self, context: pc.ComputeContext | None=None, plan_type: pc._typing.PlanTypePreference='dot', description: Optional[str] = None) -> 'FlowFrame': ...
+    def remote(self, context: pc.ComputeContext | None=None, plan_type: pc._typing.PlanTypePreference='dot', description: Optional[str] = None) -> pc.LazyFrameExt: ...
 
     # Remove rows, dropping those that match the given predicate expression(s).
-    def remove(self, *predicates, **constraints) -> 'FlowFrame': ...
+    def remove(self, *predicates, description: Optional[str] = None, **constraints) -> LazyFrame: ...
 
     # Rename column names.
-    def rename(self, mapping: dict[str, str] | Callable[[str], str], strict: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def rename(self, mapping: dict[str, str] | Callable[[str], str], strict: bool=True, description: Optional[str] = None) -> LazyFrame: ...
 
     # Reverse the DataFrame.
-    def reverse(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def reverse(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Create rolling groups based on a temporal or integer column.
     def rolling(self, index_column: IntoExpr, period: str | timedelta, offset: str | timedelta | None=None, closed: ClosedInterval='right', group_by: IntoExpr | Iterable[IntoExpr] | None=None, description: Optional[str] = None) -> LazyGroupBy: ...
 
     # Save the graph
-    def save_graph(self, file_path: str, auto_arrange: bool=True, description: Optional[str] = None) -> 'FlowFrame': ...
+    def save_graph(self, file_path: str, auto_arrange: bool=True, description: Optional[str] = None) -> Any: ...
+
+    # Get an ordered mapping of column names to their data type.
+    @property
+    def schema(self) -> pl.Schema: ...
 
     # Select columns from the frame.
-    def select(self, *columns, description: Union[str, NoneType]=None) -> 'FlowFrame': ...
+    def select(self, *columns, description: typing.Optional[str]=None) -> 'FlowFrame': ...
 
     # Select columns from this LazyFrame.
-    def select_seq(self, *exprs, **named_exprs) -> 'FlowFrame': ...
+    def select_seq(self, *exprs, description: Optional[str] = None, **named_exprs) -> LazyFrame: ...
 
     # Serialize the logical plan of this LazyFrame to a file or string in JSON format.
     def serialize(self, file: IOBase | str | Path | None=None, format: SerializationFormat='binary', description: Optional[str] = None) -> bytes | str | None: ...
 
     # Flag a column as sorted.
-    def set_sorted(self, column: str, descending: bool=False, description: Optional[str] = None) -> 'FlowFrame': ...
+    def set_sorted(self, column: str, descending: bool=False, description: Optional[str] = None) -> LazyFrame: ...
 
     # Shift values by the given number of indices.
-    def shift(self, n: int | IntoExprColumn=1, fill_value: IntoExpr | None=None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def shift(self, n: int | IntoExprColumn=1, fill_value: IntoExpr | None=None, description: Optional[str] = None) -> LazyFrame: ...
 
     # Show a plot of the query plan.
     def show_graph(self, optimized: bool=True, show: bool=True, output_path: str | Path | None=None, raw_output: bool=False, figsize: tuple[float, float]=(16.0, 12.0), type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, comm_subplan_elim: bool=True, comm_subexpr_elim: bool=True, cluster_with_columns: bool=True, collapse_joins: bool=True, streaming: bool=False, engine: EngineType='auto', _check_order: bool=True) -> str | None: ...
@@ -265,72 +293,76 @@ class FlowFrame:
     def sink_csv(self, file: str, *args, separator: str=',', encoding: str='utf-8', description: str=None) -> 'FlowFrame': ...
 
     # Evaluate the query in streaming mode and write to an IPC file.
-    def sink_ipc(self, path: str | Path, compression: IpcCompression | None='zstd', compat_level: CompatLevel | None=None, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> 'FlowFrame': ...
+    def sink_ipc(self, path: str | Path, compression: IpcCompression | None='zstd', compat_level: CompatLevel | None=None, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> LazyFrame | None: ...
 
     # Evaluate the query in streaming mode and write to an NDJSON file.
-    def sink_ndjson(self, path: str | Path, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> 'FlowFrame': ...
+    def sink_ndjson(self, path: str | Path, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> LazyFrame | None: ...
 
     # Evaluate the query in streaming mode and write to a Parquet file.
-    def sink_parquet(self, path: str | Path, compression: str='zstd', compression_level: int | None=None, statistics: bool | str | dict[str, bool]=True, row_group_size: int | None=None, data_page_size: int | None=None, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> 'FlowFrame': ...
+    def sink_parquet(self, path: str | Path, compression: str='zstd', compression_level: int | None=None, statistics: bool | str | dict[str, bool]=True, row_group_size: int | None=None, data_page_size: int | None=None, maintain_order: bool=True, type_coercion: bool=True, _type_check: bool=True, predicate_pushdown: bool=True, projection_pushdown: bool=True, simplify_expression: bool=True, slice_pushdown: bool=True, collapse_joins: bool=True, no_optimization: bool=False, storage_options: dict[str, Any] | None=None, credential_provider: CredentialProviderFunction | Literal['auto'] | None='auto', retries: int=2, sync_on_close: SyncOnCloseMethod | None=None, mkdir: bool=False, lazy: bool=False, engine: EngineType='auto', description: Optional[str] = None) -> LazyFrame | None: ...
 
     # Get a slice of this DataFrame.
-    def slice(self, offset: int, length: int | None=None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def slice(self, offset: int, length: int | None=None, description: Optional[str] = None) -> LazyFrame: ...
 
     # Sort the dataframe by the given columns.
-    def sort(self, by: Union[List, Expr, str], *more_by, descending: Union[bool, List]=False, nulls_last: Union[bool, List]=False, multithreaded: bool=True, maintain_order: bool=False, description: Union[str, NoneType]=None) -> 'FlowFrame': ...
+    def sort(self, by: typing.Union[typing.List[typing.Union[flowfile_frame.expr.Expr, str]], flowfile_frame.expr.Expr, str], *more_by, descending: typing.Union[bool, typing.List[bool]]=False, nulls_last: typing.Union[bool, typing.List[bool]]=False, multithreaded: bool=True, maintain_order: bool=False, description: typing.Optional[str]=None) -> 'FlowFrame': ...
 
     # Execute a SQL query against the LazyFrame.
-    def sql(self, query: str, table_name: str='self', description: Optional[str] = None) -> 'FlowFrame': ...
+    def sql(self, query: str, table_name: str='self', description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their standard deviation value.
-    def std(self, ddof: int=1, description: Optional[str] = None) -> 'FlowFrame': ...
+    def std(self, ddof: int=1, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their sum value.
-    def sum(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def sum(self, description: Optional[str] = None) -> LazyFrame: ...
 
     # Get the last `n` rows.
-    def tail(self, n: int=5, description: Optional[str] = None) -> 'FlowFrame': ...
+    def tail(self, n: int=5, description: Optional[str] = None) -> LazyFrame: ...
 
     # Split text in a column into multiple rows.
     def text_to_rows(self, column: str | flowfile_frame.expr.Column, output_column: str=None, delimiter: str=None, split_by_column: str=None, description: str=None) -> 'FlowFrame': ...
 
     # Get the underlying ETL graph.
-    def to_graph(self, description: Optional[str] = None) -> 'FlowFrame': ...
+    def to_graph(self, description: Optional[str] = None) -> Any: ...
 
     # Return the `k` largest rows.
-    def top_k(self, k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]=False, description: Optional[str] = None) -> 'FlowFrame': ...
+    def top_k(self, k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]=False, description: Optional[str] = None) -> LazyFrame: ...
 
     # Drop duplicate rows from this dataframe.
-    def unique(self, subset: Union[str, ForwardRef('Expr'), List]=None, keep: typing.Literal['first', 'last', 'any', 'none']='any', maintain_order: bool=False, description: str=None) -> 'FlowFrame': ...
+    def unique(self, subset: typing.Union[str, ForwardRef('Expr'), typing.List[typing.Union[ForwardRef('Expr'), str]]]=None, keep: typing.Literal['first', 'last', 'any', 'none']='any', maintain_order: bool=False, description: str=None) -> 'FlowFrame': ...
 
     # Decompose struct columns into separate columns for each of their fields.
-    def unnest(self, columns: ColumnNameOrSelector | Collection[ColumnNameOrSelector], *more_columns, description: Optional[str] = None) -> 'FlowFrame': ...
+    def unnest(self, columns: ColumnNameOrSelector | Collection[ColumnNameOrSelector], *more_columns, description: Optional[str] = None) -> LazyFrame: ...
 
     # Unpivot a DataFrame from wide to long format.
     def unpivot(self, on: list[str | flowfile_frame.selectors.Selector] | str | None | flowfile_frame.selectors.Selector=None, index: list[str] | str | None=None, variable_name: str='variable', value_name: str='value', description: str=None) -> 'FlowFrame': ...
 
     # Update the values in this `LazyFrame` with the values in `other`.
-    def update(self, other: LazyFrame, on: str | Sequence[str] | None=None, how: Literal['left', 'inner', 'full']='left', left_on: str | Sequence[str] | None=None, right_on: str | Sequence[str] | None=None, include_nulls: bool=False, description: Optional[str] = None) -> 'FlowFrame': ...
+    def update(self, other: LazyFrame, on: str | Sequence[str] | None=None, how: Literal['left', 'inner', 'full']='left', left_on: str | Sequence[str] | None=None, right_on: str | Sequence[str] | None=None, include_nulls: bool=False, description: Optional[str] = None) -> LazyFrame: ...
 
     # Aggregate the columns in the LazyFrame to their variance value.
-    def var(self, ddof: int=1, description: Optional[str] = None) -> 'FlowFrame': ...
+    def var(self, ddof: int=1, description: Optional[str] = None) -> LazyFrame: ...
+
+    # Get the number of columns.
+    @property
+    def width(self) -> int: ...
 
     # Add or replace columns in the DataFrame.
-    def with_columns(self, exprs: Union[Expr, List[Union[Expr, None]]] = None, *, flowfile_formulas: Optional[List[str]] = None, output_column_names: Optional[List[str]] = None, description: Optional[str] = None) -> 'FlowFrame': ...
+    def with_columns(self, *exprs: Union[Expr, Iterable[Expr], Any], flowfile_formulas: Optional[List[str]] = None, output_column_names: Optional[List[str]] = None, description: Optional[str] = None, **named_exprs: Union[Expr, Any]) -> 'FlowFrame': ...
 
     # Add columns to this LazyFrame.
-    def with_columns_seq(self, *exprs, **named_exprs) -> 'FlowFrame': ...
+    def with_columns_seq(self, *exprs, description: Optional[str] = None, **named_exprs) -> LazyFrame: ...
 
     # Add an external context to the computation graph.
-    def with_context(self, other: Self | list[Self], description: Optional[str] = None) -> 'FlowFrame': ...
+    def with_context(self, other: Self | list[Self], description: Optional[str] = None) -> LazyFrame: ...
 
     # Add a column at index 0 that counts the rows.
-    def with_row_count(self, name: str='row_nr', offset: int=0, description: Optional[str] = None) -> 'FlowFrame': ...
+    def with_row_count(self, name: str='row_nr', offset: int=0, description: Optional[str] = None) -> LazyFrame: ...
 
     # Add a row index as the first column in the DataFrame.
     def with_row_index(self, name: str='index', offset: int=0, description: str=None) -> 'FlowFrame': ...
 
-    def write_csv(self, file: str | os.PathLike, separator: str=',', encoding: str='utf-8', description: str=None, convert_to_absolute_path: bool=True, **kwargs) -> 'FlowFrame': ...
+    def write_csv(self, file: str | os.PathLike, separator: str=',', encoding: str='utf-8', convert_to_absolute_path: bool=True, description: str=None, **kwargs) -> 'FlowFrame': ...
 
     # Write the data to a Parquet file. Creates a standard Output node if only
-    def write_parquet(self, path: str | os.PathLike, description: str=None, convert_to_absolute_path: bool=True, **kwargs) -> 'FlowFrame': ...
+    def write_parquet(self, path: str | os.PathLike, convert_to_absolute_path: bool=True, description: str=None, **kwargs) -> 'FlowFrame': ...

{flowfile-0.3.3 → flowfile-0.3.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Flowfile"
-version = "0.3.3"
+version = "0.3.3.1"
 description = "Project combining flowfile core (backend) and flowfile_worker (compute offloader) and flowfile_frame (api)"
 readme = "readme-pypi.md"
 authors = ["Edward van Eechoud <evaneechoud@gmail.com>"]
@@ -27,7 +27,10 @@ databases = "~0.9.0"
 passlib = "~1.7.4"
 pyarrow = "^18.0.0"
 python-multipart = "~0.0.12"
-polars = ">1.8.2,<=1.25.2"
+polars = [
+    { version = ">=1.8.2, <=1.25.2", markers = "sys_platform == 'win32'" }, # For Windows, max version 1.25.2 due to failing issues in greater versions
+    { version = ">=1.8.2, <2.0.0", markers = "sys_platform != 'win32'" }
+]
 methodtools = "~0.4.7"
 faker = "~23.1.0"
 XlsxWriter = "~3.2.0"
@@ -35,7 +38,7 @@ loky = "~3.4.1"
 fastexcel = "~0.12.0"
 openpyxl = "~3.1.2"
 polars-distance = "~0.4.3"
-polars-expr-transformer = ">0.4.7.0"
+polars-expr-transformer = ">=0.4.9.0"
 polars-grouper = "~0.3.0"
 polars-ds = ">=0.6.0"
 pyairbyte-flowfile = "0.20.2"