Cargo.toml

[package]
name = "polars-lazy"
version = { workspace = true }
authors = { workspace = true }
edition = { workspace = true }
homepage = { workspace = true }
license = { workspace = true }
repository = { workspace = true }
description = "Lazy query engine for the Polars DataFrame library"

[dependencies]
arrow = { workspace = true }
chrono = { workspace = true }
futures = { workspace = true, optional = true }
polars-buffer = { workspace = true }
polars-compute = { workspace = true }
polars-core = { workspace = true, features = ["lazy", "zip_with", "random"] }
polars-expr = { workspace = true }
polars-io = { workspace = true, features = ["lazy"] }
polars-json = { workspace = true, optional = true }
polars-mem-engine = { workspace = true }
polars-ops = { workspace = true, features = ["chunked_ids"] }
polars-plan = { workspace = true }
polars-stream = { workspace = true, optional = true }
polars-time = { workspace = true, optional = true }
polars-utils = { workspace = true }

bitflags = { workspace = true }
either = { workspace = true }
memchr = { workspace = true }
pyo3 = { workspace = true, optional = true }
rayon = { workspace = true }
tokio = { workspace = true, optional = true }

[dev-dependencies]
bytes = { workspace = true }
serde_json = { workspace = true }

[build-dependencies]
version_check = { workspace = true }

[features]
catalog = ["polars-io/catalog"]
nightly = ["polars-core/nightly", "polars-expr/nightly"]
new_streaming = ["polars-stream"]
parquet = [
  "polars-io/parquet",
  "polars-plan/parquet",
  "polars-expr/parquet",
  "polars-mem-engine/parquet",
  "polars-stream?/parquet",
]
async = [
  "polars-io/cloud",
  "polars-mem-engine/async",
]
cloud = [
  "async",
  "polars-plan/cloud",
  "tokio",
  "futures",
  "polars-mem-engine/cloud",
  "polars-stream?/cloud",
]
ipc = ["polars-io/ipc", "polars-plan/ipc", "polars-mem-engine/ipc", "polars-stream?/ipc"]
json = [
  "polars-io/json",
  "polars-expr/json",
  "polars-json",
  "polars-mem-engine/json",
  "polars-stream?/json",
]
csv = ["polars-io/csv", "polars-plan/csv", "polars-mem-engine/csv", "polars-stream?/csv"]
scan_lines = ["polars-stream?/scan_lines"]
temporal = [
  "dtype-datetime",
  "dtype-date",
  "dtype-time",
  "dtype-i8",
  "dtype-i16",
  "dtype-duration",
  "polars-plan/temporal",
  "polars-expr/temporal",
]
# debugging purposes
fmt = ["polars-core/fmt", "polars-plan/fmt"]
strings = ["polars-expr/strings", "polars-stream?/strings"]
future = []

dtype-full = [
  "dtype-array",
  "dtype-categorical",
  "dtype-date",
  "dtype-datetime",
  "dtype-decimal",
  "dtype-duration",
  "dtype-extension",
  "dtype-i16",
  "dtype-i128",
  "dtype-i8",
  "dtype-struct",
  "dtype-time",
  "dtype-u16",
  "dtype-u128",
  "dtype-u8",
  "dtype-f16",
]
dtype-array = [
  "polars-plan/dtype-array",
  "polars-stream?/dtype-array",
  "polars-ops/dtype-array",
  "polars-expr/dtype-array",
]
dtype-categorical = [
  "polars-plan/dtype-categorical",
  "polars-stream?/dtype-categorical",
  "polars-expr/dtype-categorical",
  "polars-mem-engine/dtype-categorical",
]
dtype-date = [
  "polars-plan/dtype-date",
  "polars-stream?/dtype-date",
  "polars-time/dtype-date",
  "temporal",
  "polars-expr/dtype-date",
  "polars-mem-engine/dtype-date",
]
dtype-datetime = [
  "polars-plan/dtype-datetime",
  "polars-stream?/dtype-datetime",
  "polars-time/dtype-datetime",
  "temporal",
  "polars-expr/dtype-datetime",
  "polars-mem-engine/dtype-datetime",
]
dtype-decimal = [
  "polars-plan/dtype-decimal",
  "polars-expr/dtype-decimal",
  "polars-stream?/dtype-decimal",
  "polars-mem-engine/dtype-decimal",
]
dtype-duration = [
  "polars-plan/dtype-duration",
  "polars-stream?/dtype-duration",
  "polars-time/dtype-duration",
  "temporal",
  "polars-expr/dtype-duration",
  "polars-mem-engine/dtype-duration",
]
dtype-extension = [
  "polars-plan/dtype-extension",
  "polars-stream?/dtype-extension",
  "polars-expr/dtype-extension",
]
dtype-i16 = [
  "polars-plan/dtype-i16",
  "polars-expr/dtype-i16",
  "polars-mem-engine/dtype-i16",
  "polars-stream?/dtype-i16",
]
dtype-i128 = [
  "polars-plan/dtype-i128",
  "polars-stream?/dtype-i128",
  "polars-expr/dtype-i128",
  "polars-stream?/dtype-i128",
]
dtype-i8 = ["polars-plan/dtype-i8", "polars-expr/dtype-i8", "polars-mem-engine/dtype-i8", "polars-stream?/dtype-i8"]
dtype-struct = [
  "polars-plan/dtype-struct",
  "polars-ops/dtype-struct",
  "polars-expr/dtype-struct",
  "polars-mem-engine/dtype-struct",
]
dtype-time = [
  "polars-plan/dtype-time",
  "polars-stream?/dtype-time",
  "polars-time/dtype-time",
  "temporal",
  "polars-expr/dtype-time",
  "polars-mem-engine/dtype-time",
]
dtype-u128 = [
  "polars-plan/dtype-u128",
  "polars-ops/dtype-u128",
  "polars-expr/dtype-u128",
  "polars-stream?/dtype-u128",
]
dtype-u16 = [
  "polars-plan/dtype-u16",
  "polars-expr/dtype-u16",
  "polars-mem-engine/dtype-u16",
  "polars-stream?/dtype-u16",
]
dtype-u8 = ["polars-plan/dtype-u8", "polars-expr/dtype-u8", "polars-mem-engine/dtype-u8", "polars-stream?/dtype-u8"]
dtype-f16 = [
  "polars-plan/dtype-f16",
  "polars-expr/dtype-f16",
  "polars-mem-engine/dtype-f16",
  "polars-stream?/dtype-f16",
]

object = ["polars-plan/object", "polars-mem-engine/object", "polars-stream?/object"]
ffi_plugin = ["polars-expr/ffi_plugin"]
find_many = ["polars-expr/find_many"]
month_start = ["polars-expr/month_start"]
month_end = ["polars-expr/month_end"]
offset_by = ["polars-expr/offset_by"]
trigonometry = ["polars-expr/trigonometry"]
sign = ["polars-expr/sign"]
timezones = ["polars-expr/timezones"]
list_filter = ["polars-ops/list_filter", "polars-expr/list_filter"]
list_gather = ["polars-ops/list_gather", "polars-expr/list_gather"]
list_count = ["polars-ops/list_count", "polars-expr/list_count"]
array_count = ["polars-ops/array_count", "polars-expr/array_count", "dtype-array"]
true_div = ["polars-plan/true_div"]
extract_jsonpath = ["polars-expr/extract_jsonpath", "polars-ops/extract_jsonpath"]

# operations
bitwise = [
  "polars-plan/bitwise",
  "polars-expr/bitwise",
  "polars-core/bitwise",
  "polars-stream?/bitwise",
  "polars-ops/bitwise",
]
approx_unique = ["polars-plan/approx_unique", "polars-expr/approx_unique", "polars-stream?/approx_unique"]
is_in = ["polars-plan/is_in", "polars-ops/is_in", "polars-expr/is_in", "polars-stream?/is_in"]
repeat_by = ["polars-expr/repeat_by"]
round_series = ["polars-expr/round_series", "polars-ops/round_series"]
is_first_distinct = ["polars-expr/is_first_distinct"]
is_last_distinct = ["polars-expr/is_last_distinct"]
is_between = ["polars-expr/is_between"]
is_close = ["polars-expr/is_close"]
is_unique = ["polars-expr/is_unique"]
cross_join = ["polars-plan/cross_join", "polars-ops/cross_join"]
asof_join = [
  "polars-plan/asof_join",
  "polars-stream/asof_join",
  "polars-time",
  "polars-ops/asof_join",
  "polars-mem-engine/asof_join",
]
iejoin = ["polars-plan/iejoin"]
business = ["polars-expr/business"]
concat_str = ["polars-expr/concat_str"]
range = [
  "polars-expr/range",
  "polars-stream?/range",
]
mode = ["polars-expr/mode", "polars-stream?/mode"]
cum_agg = ["polars-expr/cum_agg", "polars-stream?/cum_agg"]
interpolate = ["polars-expr/interpolate"]
interpolate_by = ["polars-expr/interpolate_by"]
rolling_window = [
  "polars-expr/rolling_window",
]
rolling_window_by = [
  "polars-expr/rolling_window_by",
  "polars-time/rolling_window_by",
]
rank = ["polars-expr/rank"]
diff = ["polars-expr/diff", "polars-stream?/diff"]
pct_change = ["polars-expr/pct_change"]
moment = ["polars-expr/moment", "polars-ops/moment"]
abs = ["polars-expr/abs"]
random = ["polars-expr/random"]
dynamic_group_by = [
  "polars-plan/dynamic_group_by",
  "polars-time",
  "temporal",
  "polars-expr/dynamic_group_by",
  "polars-mem-engine/dynamic_group_by",
  "polars-stream?/dynamic_group_by",
]
ewma = ["polars-expr/ewma", "polars-stream?/ewma"]
ewma_by = ["polars-expr/ewma_by"]
dot_diagram = ["polars-plan/dot_diagram"]
diagonal_concat = []
unique_counts = ["polars-expr/unique_counts"]
log = ["polars-expr/log"]
list_eval = []
cumulative_eval = []
list_to_struct = ["polars-expr/list_to_struct"]
array_to_struct = ["polars-expr/array_to_struct"]
python = [
  "pyo3",
  "polars-plan/python",
  "polars-core/python",
  "polars-io/python",
  "polars-mem-engine/python",
  "polars-stream?/python",
]
row_hash = ["polars-expr/row_hash"]
reinterpret = ["polars-expr/reinterpret", "polars-ops/reinterpret"]
string_pad = ["polars-expr/string_pad"]
string_normalize = ["polars-expr/string_normalize"]
string_reverse = ["polars-expr/string_reverse"]
string_to_integer = ["polars-expr/string_to_integer"]
arg_where = ["polars-expr/arg_where"]
index_of = ["polars-expr/index_of"]
search_sorted = ["polars-expr/search_sorted"]
merge_sorted = ["polars-plan/merge_sorted", "polars-stream?/merge_sorted", "polars-mem-engine/merge_sorted"]
meta = ["polars-plan/meta"]
pivot = ["polars-core/rows", "polars-ops/pivot", "polars-plan/pivot"]
top_k = ["polars-expr/top_k", "polars-stream?/top_k"]
semi_anti_join = ["polars-plan/semi_anti_join", "polars-stream?/semi_anti_join"]
cse = ["polars-plan/cse"]
propagate_nans = ["polars-plan/propagate_nans", "polars-expr/propagate_nans"]
coalesce = ["polars-plan/coalesce"]
regex = ["polars-expr/regex"]
serde = [
  "polars-plan/serde",
  "arrow/serde",
  "polars-buffer/serde",
  "polars-core/serde-lazy",
  "polars-time?/serde",
  "polars-io/serde",
  "polars-ops/serde",
  "polars-utils/serde",
  "polars-compute/serde",
]
fused = ["polars-expr/fused", "polars-ops/fused"]
list_sets = ["polars-expr/list_sets", "polars-ops/list_sets"]
list_any_all = ["polars-ops/list_any_all", "polars-expr/list_any_all"]
array_any_all = ["polars-ops/array_any_all", "polars-expr/array_any_all", "dtype-array"]
list_drop_nulls = ["polars-ops/list_drop_nulls", "polars-expr/list_drop_nulls"]
list_sample = ["polars-ops/list_sample", "polars-expr/list_sample"]
cutqcut = ["polars-expr/cutqcut", "polars-ops/cutqcut"]
rle = ["polars-expr/rle", "polars-ops/rle"]
extract_groups = ["polars-expr/extract_groups"]
peaks = ["polars-expr/peaks"]
cov = ["polars-ops/cov", "polars-expr/cov"]
hist = ["polars-expr/hist"]
replace = ["polars-expr/replace", "polars-stream?/replace"]

binary_encoding = ["polars-expr/binary_encoding"]
string_encoding = ["polars-expr/string_encoding"]

bigidx = ["polars-plan/bigidx", "polars-stream/bigidx", "polars-utils/bigidx"]
polars_cloud_client = ["polars-plan/polars_cloud_client"]
polars_cloud_server = ["polars-plan/polars_cloud_server"]
allow_unused = [
  "polars-expr/allow_unused",
  "polars-mem-engine/allow_unused",
  "polars-time?/allow_unused",
  "polars-io/allow_unused",
  "polars-plan/allow_unused",
]

test = [
  "polars-plan/debugging",
  "rolling_window",
  "rank",
  "round_series",
  "csv",
  "dtype-categorical",
  "cum_agg",
  "regex",
  "polars-core/fmt",
  "diff",
  "abs",
  "parquet",
  "ipc",
  "dtype-date",
]

test_all = [
  "test",
  "strings",
  "regex",
  "ipc",
  "row_hash",
  "string_pad",
  "string_to_integer",
  "index_of",
  "search_sorted",
  "top_k",
  "pivot",
  "semi_anti_join",
  "cse",
  "dtype-struct",
  "peaks",
  "cov",
  "hist",
  "extract_groups",
  "rle",
  "cutqcut",
  "replace",
  "list_sample",
]

[package.metadata.docs.rs]
features = [
  "abs",
  "approx_unique",
  "arg_where",
  "asof_join",
  "async",
  "bigidx",
  "binary_encoding",
  "cloud",
  "coalesce",
  "concat_str",
  "cov",
  "cross_join",
  "cse",
  "csv",
  "cum_agg",
  "cumulative_eval",
  "cutqcut",
  "diagonal_concat",
  "diff",
  "dot_diagram",
  "dtype-full",
  "dynamic_group_by",
  "ewma",
  "extract_groups",
  "fmt",
  "fused",
  "futures",
  "hist",
  "index_of",
  "interpolate",
  "interpolate_by",
  "ipc",
  "is_first_distinct",
  "is_in",
  "is_last_distinct",
  "is_unique",
  "json",
  "list_any_all",
  "list_count",
  "list_drop_nulls",
  "list_eval",
  "list_filter",
  "list_gather",
  "list_sample",
  "list_sets",
  "list_to_struct",
  "log",
  "merge_sorted",
  "meta",
  "mode",
  "moment",
  "month_start",
  "month_end",
  "nightly",
  "object",
  "offset_by",
  "panic_on_schema",
  "parquet",
  "pct_change",
  "peaks",
  "pivot",
  "polars-json",
  "polars-time",
  "propagate_nans",
  "random",
  "range",
  "rank",
  "regex",
  "repeat_by",
  "replace",
  "rle",
  "rolling_window",
  "rolling_window_by",
  "round_series",
  "row_hash",
  "search_sorted",
  "semi_anti_join",
  "serde",
  "sign",
  "string_encoding",
  "string_normalize",
  "string_pad",
  "string_reverse",
  "string_to_integer",
  "strings",
  "temporal",
  "timezones",
  "tokio",
  "top_k",
  "trigonometry",
  "true_div",
  "unique_counts",
]
# defines the configuration attribute `docsrs`
rustdoc-args = ["--cfg", "docsrs"]

[lints]
workspace = true