Cargo.toml

[package]
name = "polars"
version = { workspace = true }
authors = { workspace = true }
edition = { workspace = true }
homepage = { workspace = true }
keywords = ["dataframe", "query-engine", "arrow"]
license = { workspace = true }
readme = "../../README.md"
repository = { workspace = true }
description = "DataFrame library based on Apache Arrow"

[dependencies]
arrow = { workspace = true }
polars-core = { workspace = true, features = ["algorithm_group_by"] }
polars-error = { workspace = true }
polars-io = { workspace = true, optional = true }
polars-lazy = { workspace = true, optional = true }
polars-ops = { workspace = true, optional = true }
polars-parquet = { workspace = true }
polars-plan = { workspace = true, optional = true }
polars-sql = { workspace = true, optional = true }
polars-time = { workspace = true, optional = true }
polars-utils = { workspace = true }

[dev-dependencies]
ahash = { workspace = true }
apache-avro = { version = "0.16", features = ["snappy"] }
avro-schema = { workspace = true, features = ["async"] }
either = { workspace = true }
ethnum = "1"
futures = { workspace = true }
# used to run formal property testing
proptest = { version = "1", default_features = false, features = ["std"] }
rand = { workspace = true }
# used to test async readers
tokio = { workspace = true, features = ["macros", "rt", "fs", "io-util"] }
tokio-util = { workspace = true, features = ["compat"] }

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

# enable js feature for getrandom to work in wasm
[target.'cfg(target_family = "wasm")'.dependencies]
getrandom = { version = "0.2", features = ["js"] }

[features]
sql = ["polars-sql"]
rows = ["polars-core/rows"]
simd = ["polars-core/simd", "polars-io/simd", "polars-ops?/simd"]
avx512 = ["polars-core/avx512"]
nightly = ["polars-core/nightly", "polars-ops?/nightly", "simd", "polars-lazy?/nightly", "polars-sql?/nightly"]
docs = ["polars-core/docs"]
temporal = ["polars-core/temporal", "polars-lazy?/temporal", "polars-io/temporal", "polars-time"]
random = ["polars-core/random", "polars-lazy?/random", "polars-ops/random"]
default = [
  "docs",
  "zip_with",
  "csv",
  "temporal",
  "fmt",
  "dtype-slim",
]
ndarray = ["polars-core/ndarray"]
# serde support for dataframes and series
serde = ["polars-core/serde"]
serde-lazy = [
  "polars-core/serde-lazy",
  "polars-lazy?/serde",
  "polars-time?/serde",
  "polars-io?/serde",
  "polars-ops?/serde",
]
parquet = ["polars-io", "polars-lazy?/parquet", "polars-io/parquet", "polars-sql?/parquet"]
async = ["polars-lazy?/async"]
cloud = ["polars-lazy?/cloud", "polars-io/cloud"]
cloud_write = ["cloud", "polars-lazy?/cloud_write"]
aws = ["async", "cloud", "polars-io/aws"]
http = ["async", "cloud", "polars-io/http"]
azure = ["async", "cloud", "polars-io/azure"]
gcp = ["async", "cloud", "polars-io/gcp"]
lazy = ["polars-core/lazy", "polars-lazy"]
# commented out until UB is fixed
# parallel = ["polars-core/parallel"]

# extra utilities for StringChunked
strings = ["polars-core/strings", "polars-lazy?/strings", "polars-ops/strings"]

# support for ObjectChunked<T> (downcastable Series of any type)
object = ["polars-core/object", "polars-lazy?/object", "polars-io/object"]

# support for arrows json parsing
json = ["polars-io", "polars-io/json", "polars-lazy?/json", "polars-sql?/json", "dtype-struct"]

# support for arrows ipc file parsing
ipc = ["polars-io", "polars-io/ipc", "polars-lazy?/ipc", "polars-sql?/ipc"]

# support for arrows streaming ipc file parsing
ipc_streaming = ["polars-io", "polars-io/ipc_streaming", "polars-lazy?/ipc"]

# support for apache avro file parsing
avro = ["polars-io", "polars-io/avro"]

# support for arrows csv file parsing
csv = ["polars-io", "polars-io/csv", "polars-lazy?/csv", "polars-sql?/csv"]

# slower builds
performant = [
  "polars-core/performant",
  "chunked_ids",
  "dtype-u8",
  "dtype-u16",
  "dtype-struct",
  "cse",
  "polars-ops/performant",
  "streaming",
  "fused",
]

# Dataframe formatting.
fmt = ["polars-core/fmt"]
fmt_no_tty = ["polars-core/fmt_no_tty"]

# extra operations
abs = ["polars-ops/abs", "polars-lazy?/abs"]
approx_unique = ["polars-lazy?/approx_unique", "polars-ops/approx_unique"]
arg_where = ["polars-lazy?/arg_where"]
array_any_all = ["polars-lazy?/array_any_all", "dtype-array"]
asof_join = ["polars-lazy?/asof_join", "polars-ops/asof_join"]
bigidx = ["polars-core/bigidx", "polars-lazy?/bigidx", "polars-ops/big_idx"]
binary_encoding = ["polars-ops/binary_encoding", "polars-lazy?/binary_encoding", "polars-sql?/binary_encoding"]
business = ["polars-lazy?/business", "polars-ops/business"]
checked_arithmetic = ["polars-core/checked_arithmetic"]
chunked_ids = ["polars-ops?/chunked_ids"]
coalesce = ["polars-lazy?/coalesce"]
concat_str = ["polars-lazy?/concat_str"]
cov = ["polars-lazy/cov"]
cross_join = ["polars-lazy?/cross_join", "polars-ops/cross_join"]
cse = ["polars-lazy?/cse"]
cum_agg = ["polars-ops/cum_agg", "polars-lazy?/cum_agg"]
cumulative_eval = ["polars-lazy?/cumulative_eval"]
cutqcut = ["polars-lazy?/cutqcut"]
dataframe_arithmetic = ["polars-core/dataframe_arithmetic"]
date_offset = ["polars-lazy?/date_offset"]
decompress = ["polars-io/decompress"]
decompress-fast = ["polars-io/decompress-fast"]
describe = ["polars-core/describe"]
diagonal_concat = ["polars-core/diagonal_concat", "polars-lazy?/diagonal_concat", "polars-sql?/diagonal_concat"]
diff = ["polars-ops/diff", "polars-lazy?/diff"]
dot_diagram = ["polars-lazy?/dot_diagram"]
dot_product = ["polars-core/dot_product"]
dynamic_group_by = ["polars-core/dynamic_group_by", "polars-lazy?/dynamic_group_by"]
ewma = ["polars-ops/ewma", "polars-lazy?/ewma"]
extract_groups = ["polars-lazy?/extract_groups"]
extract_jsonpath = [
  "polars-core/strings",
  "polars-ops/extract_jsonpath",
  "polars-ops/strings",
  "polars-lazy?/extract_jsonpath",
]
find_many = ["polars-plan/find_many"]
fused = ["polars-ops/fused", "polars-lazy?/fused"]
interpolate = ["polars-ops/interpolate", "polars-lazy?/interpolate"]
is_between = ["polars-lazy?/is_between", "polars-ops/is_between"]
is_first_distinct = ["polars-lazy?/is_first_distinct", "polars-ops/is_first_distinct"]
is_in = ["polars-lazy?/is_in"]
is_last_distinct = ["polars-lazy?/is_last_distinct", "polars-ops/is_last_distinct"]
is_unique = ["polars-lazy?/is_unique", "polars-ops/is_unique"]
regex = ["polars-lazy?/regex"]
list_any_all = ["polars-lazy?/list_any_all"]
list_count = ["polars-ops/list_count", "polars-lazy?/list_count"]
array_count = ["polars-ops/array_count", "polars-lazy?/array_count", "dtype-array"]
list_drop_nulls = ["polars-lazy?/list_drop_nulls"]
list_eval = ["polars-lazy?/list_eval", "polars-sql?/list_eval"]
list_gather = ["polars-ops/list_gather", "polars-lazy?/list_gather"]
list_sample = ["polars-lazy?/list_sample"]
list_sets = ["polars-lazy?/list_sets"]
list_to_struct = ["polars-ops/list_to_struct", "polars-lazy?/list_to_struct"]
array_to_struct = ["polars-ops/array_to_struct", "polars-lazy?/array_to_struct"]
log = ["polars-ops/log", "polars-lazy?/log"]
merge_sorted = ["polars-lazy?/merge_sorted"]
meta = ["polars-lazy?/meta"]
mode = ["polars-ops/mode", "polars-lazy?/mode"]
moment = ["polars-ops/moment", "polars-lazy?/moment"]
partition_by = ["polars-core/partition_by"]
pct_change = ["polars-ops/pct_change", "polars-lazy?/pct_change"]
peaks = ["polars-lazy/peaks"]
pivot = ["polars-lazy?/pivot"]
product = ["polars-core/product"]
propagate_nans = ["polars-lazy?/propagate_nans"]
range = ["polars-lazy?/range"]
rank = ["polars-lazy?/rank", "polars-ops/rank"]
reinterpret = ["polars-core/reinterpret", "polars-lazy?/reinterpret", "polars-ops/reinterpret"]
repeat_by = ["polars-ops/repeat_by", "polars-lazy?/repeat_by"]
replace = ["polars-ops/replace", "polars-lazy?/replace"]
rle = ["polars-lazy?/rle"]
rolling_window = ["polars-core/rolling_window", "polars-lazy?/rolling_window", "polars-time/rolling_window"]
round_series = ["polars-ops/round_series", "polars-lazy?/round_series"]
row_hash = ["polars-core/row_hash", "polars-lazy?/row_hash"]
search_sorted = ["polars-lazy?/search_sorted"]
semi_anti_join = ["polars-lazy?/semi_anti_join", "polars-ops/semi_anti_join", "polars-sql?/semi_anti_join"]
sign = ["polars-lazy?/sign"]
streaming = ["polars-lazy?/streaming"]
string_encoding = ["polars-ops/string_encoding", "polars-lazy?/string_encoding", "polars-core/strings"]
string_pad = ["polars-lazy?/string_pad", "polars-ops/string_pad"]
string_reverse = ["polars-lazy?/string_reverse", "polars-ops/string_reverse"]
string_to_integer = ["polars-lazy?/string_to_integer", "polars-ops/string_to_integer"]
take_opt_iter = ["polars-core/take_opt_iter"]
timezones = ["polars-core/timezones", "polars-lazy?/timezones", "polars-io/timezones", "polars-sql?/timezones"]
to_dummies = ["polars-ops/to_dummies"]
top_k = ["polars-lazy?/top_k"]
trigonometry = ["polars-lazy?/trigonometry"]
true_div = ["polars-lazy?/true_div"]
unique_counts = ["polars-ops/unique_counts", "polars-lazy?/unique_counts"]
zip_with = ["polars-core/zip_with"]

test = [
  "lazy",
  "rolling_window",
  "rank",
  "round_series",
  "csv",
  "dtype-categorical",
  "cum_agg",
  "fmt",
  "diff",
  "abs",
  "parquet",
  "ipc",
  "ipc_streaming",
  "json",
]

# all opt-in datatypes
dtype-full = [
  "dtype-date",
  "dtype-datetime",
  "dtype-duration",
  "dtype-time",
  "dtype-array",
  "dtype-i8",
  "dtype-i16",
  "dtype-decimal",
  "dtype-u8",
  "dtype-u16",
  "dtype-categorical",
  "dtype-struct",
]

# sensible minimal set of opt-in datatypes
dtype-slim = [
  "dtype-date",
  "dtype-datetime",
  "dtype-duration",
]

# opt-in datatypes for Series
dtype-date = [
  "polars-core/dtype-date",
  "polars-io/dtype-date",
  "polars-lazy?/dtype-date",
  "polars-time?/dtype-date",
  "polars-ops/dtype-date",
]
dtype-datetime = [
  "polars-core/dtype-datetime",
  "polars-io/dtype-datetime",
  "polars-lazy?/dtype-datetime",
  "polars-time?/dtype-datetime",
  "polars-ops/dtype-datetime",
]
dtype-duration = [
  "polars-core/dtype-duration",
  "polars-lazy?/dtype-duration",
  "polars-time?/dtype-duration",
  "polars-ops/dtype-duration",
]
dtype-time = [
  "polars-core/dtype-time",
  "polars-io/dtype-time",
  "polars-lazy?/dtype-time",
  "polars-time?/dtype-time",
  "polars-ops/dtype-time",
]
dtype-array = [
  "polars-core/dtype-array",
  "polars-lazy?/dtype-array",
  "polars-ops/dtype-array",
]
dtype-i8 = [
  "polars-core/dtype-i8",
  "polars-io/dtype-i8",
  "polars-lazy?/dtype-i8",
  "polars-ops/dtype-i8",
]
dtype-i16 = [
  "polars-core/dtype-i16",
  "polars-io/dtype-i16",
  "polars-lazy?/dtype-i16",
  "polars-ops/dtype-i16",
]
dtype-decimal = [
  "polars-core/dtype-decimal",
  "polars-io/dtype-decimal",
  "polars-lazy?/dtype-decimal",
  "polars-sql?/dtype-decimal",
  "polars-ops/dtype-decimal",
]
dtype-u8 = [
  "polars-core/dtype-u8",
  "polars-io/dtype-u8",
  "polars-lazy?/dtype-u8",
  "polars-ops/dtype-u8",
]
dtype-u16 = [
  "polars-core/dtype-u16",
  "polars-io/dtype-u16",
  "polars-lazy?/dtype-u16",
  "polars-ops/dtype-u16",
]
dtype-categorical = [
  "polars-core/dtype-categorical",
  "polars-io/dtype-categorical",
  "polars-lazy?/dtype-categorical",
  "polars-ops/dtype-categorical",
]
dtype-struct = [
  "polars-core/dtype-struct",
  "polars-io/dtype-struct",
  "polars-lazy?/dtype-struct",
  "polars-ops/dtype-struct",
]
hist = ["polars-ops/hist", "polars-lazy/hist"]

docs-selection = [
  "csv",
  "json",
  "parquet",
  "ipc",
  "ipc_streaming",
  "dtype-full",
  "is_in",
  "rows",
  "docs",
  "strings",
  "object",
  "lazy",
  "temporal",
  "random",
  "zip_with",
  "round_series",
  "checked_arithmetic",
  "ndarray",
  "repeat_by",
  "is_between",
  "is_first_distinct",
  "is_last_distinct",
  "asof_join",
  "cross_join",
  "concat_str",
  "string_reverse",
  "string_to_integer",
  "decompress",
  "mode",
  "take_opt_iter",
  "cum_agg",
  "rolling_window",
  "interpolate",
  "diff",
  "rank",
  "range",
  "diagonal_concat",
  "abs",
  "dot_diagram",
  "string_encoding",
  "product",
  "to_dummies",
  "describe",
  "list_eval",
  "cumulative_eval",
  "timezones",
  "arg_where",
  "propagate_nans",
  "coalesce",
  "dynamic_group_by",
  "extract_groups",
  "replace",
]

bench = [
  "lazy",
]

[package.metadata.docs.rs]
# all-features = true
features = ["docs-selection"]
# defines the configuration attribute `docsrs`
rustdoc-args = ["--cfg", "docsrs"]