Cargo.toml

[package]
name = "polars-plan"
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"

[lib]
doctest = false

[dependencies]
libloading = { version = "0.8.0", optional = true }
polars-compute = { workspace = true }
polars-core = { workspace = true, features = ["lazy", "zip_with", "random"] }
polars-error = { workspace = true }
polars-ffi = { workspace = true, optional = true }
polars-io = { workspace = true, features = ["lazy", "csv"] }
polars-json = { workspace = true, optional = true }
polars-ops = { workspace = true, features = [] }
polars-parquet = { workspace = true, optional = true }
polars-time = { workspace = true, optional = true }
polars-utils = { workspace = true }

arrow = { workspace = true }
bitflags = { workspace = true }
bytemuck = { workspace = true }
bytes = { workspace = true, features = ["serde"] }
chrono = { workspace = true, optional = true }
chrono-tz = { workspace = true, optional = true }
either = { workspace = true }
futures = { workspace = true, optional = true }
hashbrown = { workspace = true }
memmap = { workspace = true }
num-traits = { workspace = true }
percent-encoding = { workspace = true }
pyo3 = { workspace = true, optional = true }
rayon = { workspace = true }
recursive = { workspace = true }
regex = { workspace = true, optional = true }
schemars = { workspace = true, features = ["either"], optional = true }
serde = { workspace = true, features = ["rc"], optional = true }
serde_json = { workspace = true, optional = true }
sha2 = { workspace = true, optional = true }
strum_macros = { workspace = true }

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

[features]
# debugging utility
debugging = []
python = ["dep:pyo3", "polars-utils/python", "polars-ffi", "polars-core/object", "serde"]
serde = [
  "dep:serde",
  "polars-core/serde-lazy",
  "polars-core/serde",
  "polars-time/serde",
  "polars-io/serde",
  "polars-ops/serde",
  "polars-utils/serde",
  "polars-compute/serde",
  "either/serde",
]
parquet = ["polars-io/parquet", "polars-parquet"]
async = ["polars-io/async", "futures"]
cloud = ["async", "polars-io/cloud"]
ipc = ["polars-io/ipc"]
json = ["polars-io/json", "polars-json"]
csv = ["polars-io/csv"]
temporal = [
  "chrono",
  "polars-core/temporal",
  "polars-core/dtype-date",
  "polars-core/dtype-datetime",
  "polars-core/dtype-time",
  "polars-core/dtype-i8",
  "polars-core/dtype-i16",
]
# debugging purposes
fmt = ["polars-core/fmt"]
strings = ["polars-core/strings", "polars-ops/strings"]
future = []
dtype-u8 = ["polars-core/dtype-u8"]
dtype-u16 = ["polars-core/dtype-u16"]
dtype-i8 = ["polars-core/dtype-i8"]
dtype-i128 = ["polars-core/dtype-i128"]
dtype-i16 = ["polars-core/dtype-i16"]
dtype-decimal = ["polars-core/dtype-decimal", "polars-ops/dtype-decimal", "dtype-i128"]
dtype-date = ["polars-time/dtype-date", "temporal"]
dtype-datetime = ["polars-time/dtype-datetime", "temporal"]
dtype-duration = ["polars-core/dtype-duration", "polars-time/dtype-duration", "temporal", "polars-ops/dtype-duration"]
dtype-time = ["polars-time/dtype-time", "temporal"]
dtype-array = ["polars-core/dtype-array", "polars-ops/dtype-array"]
dtype-categorical = ["polars-core/dtype-categorical"]
dtype-struct = ["polars-core/dtype-struct"]
object = ["polars-core/object", "polars-ops/object"]
list_filter = ["polars-ops/list_filter"]
list_gather = ["polars-ops/list_gather"]
list_count = ["polars-ops/list_count"]
array_count = ["polars-ops/array_count", "dtype-array"]
trigonometry = []
sign = []
timezones = ["chrono-tz", "polars-time/timezones", "polars-core/timezones", "regex"]
binary_encoding = ["polars-ops/binary_encoding"]
string_encoding = ["polars-ops/string_encoding"]
true_div = []
nightly = ["polars-utils/nightly", "polars-ops/nightly"]
extract_jsonpath = ["polars-ops/extract_jsonpath"]
dsl-schema = [
  "dep:schemars",
  "dep:sha2",
  "dep:serde_json",
  "serde_json/preserve_order",
  "serde",
  "arrow/dsl-schema",
  "polars-core/dsl-schema",
  "polars-time/dsl-schema",
  "polars-io/dsl-schema",
  "polars-ops/dsl-schema",
  "polars-utils/dsl-schema",
  "polars-compute/dsl-schema",
]

# operations
bitwise = ["polars-core/bitwise", "polars-ops/bitwise"]
approx_unique = ["polars-ops/approx_unique", "polars-core/approx_unique"]
is_in = ["polars-ops/is_in"]
repeat_by = ["polars-ops/repeat_by"]
round_series = ["polars-ops/round_series"]
is_first_distinct = ["polars-core/is_first_distinct", "polars-ops/is_first_distinct"]
is_last_distinct = ["polars-core/is_last_distinct", "polars-ops/is_last_distinct"]
is_unique = ["polars-ops/is_unique"]
is_between = ["polars-ops/is_between"]
is_close = ["polars-ops/is_close"]
cross_join = ["polars-ops/cross_join"]
asof_join = ["polars-time", "polars-ops/asof_join"]
iejoin = ["polars-ops/iejoin"]
concat_str = []
business = ["polars-ops/business"]
range = []
mode = ["polars-ops/mode"]
cum_agg = ["polars-ops/cum_agg"]
interpolate = ["polars-ops/interpolate"]
interpolate_by = ["polars-ops/interpolate_by"]
rolling_window = [
  "polars-core/rolling_window",
  "polars-time/rolling_window",
  "polars-ops/rolling_window",
]
rolling_window_by = [
  "polars-core/rolling_window_by",
  "polars-time/rolling_window_by",
  "polars-ops/rolling_window_by",
]
rank = ["polars-ops/rank"]
diff = ["polars-ops/diff"]
pct_change = ["polars-ops/pct_change"]
moment = ["polars-ops/moment"]
abs = ["polars-ops/abs"]
random = ["polars-core/random"]
dynamic_group_by = ["polars-core/dynamic_group_by", "dtype-date", "dtype-datetime"]
ewma = ["polars-ops/ewma"]
ewma_by = ["polars-ops/ewma_by"]
dot_diagram = []
unique_counts = ["polars-ops/unique_counts"]
log = ["polars-ops/log"]
chunked_ids = []
list_to_struct = ["polars-ops/list_to_struct"]
array_to_struct = ["polars-ops/array_to_struct"]
row_hash = ["polars-core/row_hash", "polars-ops/hash"]
reinterpret = ["polars-core/reinterpret", "polars-ops/reinterpret"]
string_pad = ["polars-ops/string_pad"]
string_normalize = ["polars-ops/string_normalize"]
string_reverse = ["polars-ops/string_reverse"]
string_to_integer = ["polars-ops/string_to_integer"]
arg_where = []
index_of = ["polars-ops/index_of"]
search_sorted = ["polars-ops/search_sorted"]
merge_sorted = ["polars-ops/merge_sorted"]
meta = []
pivot = ["polars-core/rows", "polars-ops/pivot"]
top_k = ["polars-ops/top_k"]
semi_anti_join = ["polars-ops/semi_anti_join"]
cse = []
propagate_nans = ["polars-ops/propagate_nans"]
coalesce = []
fused = ["polars-ops/fused"]
array_any_all = ["polars-ops/array_any_all", "dtype-array"]
list_sets = ["polars-ops/list_sets"]
list_any_all = ["polars-ops/list_any_all"]
list_drop_nulls = ["polars-ops/list_drop_nulls"]
list_sample = ["polars-ops/list_sample"]
cutqcut = ["polars-ops/cutqcut"]
rle = ["polars-ops/rle"]
extract_groups = ["regex", "dtype-struct", "polars-ops/extract_groups"]
ffi_plugin = ["libloading", "polars-ffi"]
hive_partitions = []
peaks = ["polars-ops/peaks"]
cov = ["polars-ops/cov"]
hist = ["polars-ops/hist"]
replace = ["polars-ops/replace"]
find_many = ["polars-ops/find_many"]
month_start = ["polars-time/month_start"]
month_end = ["polars-time/month_end"]
offset_by = ["polars-time/offset_by"]
allow_unused = ["polars-io/allow_unused", "polars-ops/allow_unused", "polars-time?/allow_unused"]

bigidx = ["polars-core/bigidx", "polars-utils/bigidx"]
polars_cloud_client = ["serde"]
polars_cloud_server = ["serde"]
ir_serde = ["serde", "polars-utils/ir_serde"]

[package.metadata.docs.rs]
features = [
  "bitwise",
  "temporal",
  "serde",
  "rolling_window",
  "rolling_window_by",
  "timezones",
  "dtype-date",
  "extract_groups",
  "dtype-datetime",
  "asof_join",
  "dtype-duration",
  "is_first_distinct",
  "pivot",
  "dtype-array",
  "is_last_distinct",
  "dtype-time",
  "array_any_all",
  "month_start",
  "month_end",
  "offset_by",
  "parquet",
  "strings",
  "row_hash",
  "json",
  "python",
  "cloud",
  "string_to_integer",
  "list_any_all",
  "pct_change",
  "list_gather",
  "list_filter",
  "dtype-i16",
  "round_series",
  "cutqcut",
  "async",
  "ewma",
  "ewma_by",
  "random",
  "chunked_ids",
  "repeat_by",
  "is_in",
  "log",
  "string_reverse",
  "list_sets",
  "propagate_nans",
  "mode",
  "rank",
  "hist",
  "object",
  "approx_unique",
  "dtype-categorical",
  "merge_sorted",
  "bigidx",
  "cov",
  "list_sample",
  "dtype-i8",
  "fused",
  "binary_encoding",
  "list_drop_nulls",
  "fmt",
  "list_to_struct",
  "string_pad",
  "diff",
  "rle",
  "is_unique",
  "find_many",
  "string_encoding",
  "ipc",
  "index_of",
  "search_sorted",
  "unique_counts",
  "dtype-u8",
  "dtype-struct",
  "peaks",
  "abs",
  "interpolate",
  "interpolate_by",
  "list_count",
  "cum_agg",
  "top_k",
  "moment",
  "semi_anti_join",
  "replace",
  "dtype-u16",
  "regex",
  "dtype-decimal",
  "arg_where",
  "business",
  "range",
  "meta",
  "hive_partitions",
  "concat_str",
  "coalesce",
  "dot_diagram",
  "trigonometry",
  "true_div",
  "sign",
]
# defines the configuration attribute `docsrs`
rustdoc-args = ["--cfg", "docsrs"]

[lints]
workspace = true