{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-polars","slug":"pypi-polars","name":"polars","type":"repo","url":"https://pypi.org/project/polars/","page_url":"https://unfragile.ai/pypi-polars","categories":["data-analysis"],"tags":["dataframe","arrow","out-of-core"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-polars__cap_0","uri":"capability://data.processing.analysis.lazy.query.execution.with.automatic.optimization","name":"lazy query execution with automatic optimization","description":"Polars defers DataFrame operations into a logical query plan (IR) that is analyzed and optimized before physical execution. The optimizer performs predicate pushdown, column pruning, and redundant computation elimination by traversing the expression tree and rewriting it into an optimized physical plan. This is implemented via the polars-plan and polars-lazy crates, which build an expression DAG and apply cost-based transformations before handing off to the streaming or memory execution engine.","intents":["I want to write data transformations that automatically optimize for minimal memory and CPU usage","I need to understand what operations will be executed before they run","I want to chain multiple DataFrame operations without intermediate materialization"],"best_for":["Data engineers building ETL pipelines with large datasets","Analysts working with memory-constrained environments","Teams migrating from pandas to a more performant framework"],"limitations":["Lazy evaluation requires explicit .collect() call to materialize results, adding a mental model shift from eager pandas","Debugging lazy queries is harder because errors surface only at collect() time, not during expression building","Some operations (e.g., custom Python functions) force eager evaluation, breaking the optimization chain"],"requires":["Python 3.8+","Polars installed via pip or conda","Understanding of expression-based DSL (not SQL-like)"],"input_types":["LazyFrame (deferred computation graph)","Expressions (symbolic operations on columns)"],"output_types":["DataFrame (materialized result after collect())","Physical execution plan (internal representation)"],"categories":["data-processing-analysis","query-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_1","uri":"capability://data.processing.analysis.columnar.in.memory.storage.with.apache.arrow.format","name":"columnar in-memory storage with apache arrow format","description":"Polars stores data in columnar format using Apache Arrow's memory layout, where each column is a contiguous array of values. This is implemented via the polars-arrow crate, which wraps Arrow's data structures and provides SIMD-friendly access patterns. Columnar storage enables vectorized operations, better cache locality, and efficient compression compared to row-oriented formats. The ChunkedArray abstraction allows columns to be split into multiple Arrow arrays for flexibility in memory management.","intents":["I need to process large datasets efficiently with minimal memory footprint","I want operations to leverage SIMD and CPU cache for speed","I need to share data with other Arrow-compatible tools without copying"],"best_for":["Data scientists working with analytical workloads (aggregations, filtering, joins)","Teams using Arrow ecosystem tools (DuckDB, Apache Spark, Pandas with PyArrow backend)","Applications requiring zero-copy data sharing between languages"],"limitations":["Columnar format is slower for row-wise access patterns (e.g., iterating row-by-row)","Memory overhead for very wide tables with many small columns due to Arrow metadata per column","Compression is optional and not automatic; users must explicitly enable it"],"requires":["Python 3.8+","Polars compiled with Arrow support (default in PyPI builds)","Understanding of columnar vs row-oriented tradeoffs"],"input_types":["NumPy arrays","Python lists/dicts","Parquet/Arrow files","CSV data"],"output_types":["DataFrame (columnar Arrow-backed storage)","Series (single column as ChunkedArray)","Arrow Table (for interop)"],"categories":["data-processing-analysis","memory-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_10","uri":"capability://data.processing.analysis.sql.query.interface.with.full.sql.support","name":"sql query interface with full sql support","description":"Polars provides a SQL interface via the polars-sql crate, allowing users to write SQL queries that are executed against DataFrames. The SQL parser converts queries into Polars' expression-based IR, which is then optimized and executed using the same query engine as the expression API. This enables SQL users to leverage Polars' performance while maintaining familiarity with SQL syntax. The implementation supports standard SQL operations (SELECT, WHERE, JOIN, GROUP BY, etc.) and integrates with the lazy execution engine.","intents":["I want to use SQL syntax to query DataFrames without learning the expression DSL","I need to migrate SQL queries from a database to Polars for faster execution","I want to combine SQL and expression-based APIs in the same pipeline"],"best_for":["SQL developers transitioning to Polars","Teams migrating analytics from databases to Polars","Analysts preferring SQL syntax over expression-based APIs"],"limitations":["SQL support is not 100% complete; some advanced SQL features may not be implemented","Performance of SQL queries may be slightly lower than equivalent expression-based queries due to parsing overhead","Debugging SQL queries is harder because errors are reported in SQL terms rather than Polars expression terms"],"requires":["Python 3.8+","Polars installed with SQL support (polars[sql] extra)","Familiarity with SQL syntax"],"input_types":["SQL query string","DataFrames registered as tables"],"output_types":["DataFrame (query result)","LazyFrame (if using lazy evaluation)"],"categories":["data-processing-analysis","sql-interface"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_11","uri":"capability://data.processing.analysis.eager.dataframe.api.for.immediate.execution","name":"eager dataframe api for immediate execution","description":"Polars provides an eager execution mode via the DataFrame class, where operations are executed immediately and return results synchronously. The eager API is implemented in the polars-core crate and provides a familiar interface for users transitioning from pandas. Eager execution is useful for interactive exploration and small datasets, though it lacks the optimization benefits of lazy evaluation. The eager API supports all operations available in the lazy API, but without query optimization.","intents":["I want to explore data interactively with immediate feedback","I need to work with small datasets where optimization overhead is not worth the complexity","I want a pandas-like API for quick prototyping"],"best_for":["Data scientists exploring data in notebooks","Teams prototyping with small datasets","Developers familiar with pandas API"],"limitations":["Eager execution lacks optimization benefits; complex queries may be slower than lazy equivalents","Memory usage is higher because intermediate results are materialized","Eager execution is not suitable for large datasets or production pipelines"],"requires":["Python 3.8+","Polars installed"],"input_types":["Data from various sources (CSV, Parquet, etc.)","Python lists, dicts, NumPy arrays"],"output_types":["DataFrame (immediate result)","Series (single column)"],"categories":["data-processing-analysis","eager-execution"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_12","uri":"capability://tool.use.integration.pyo3.ffi.bridge.for.python.rust.integration","name":"pyo3 ffi bridge for python-rust integration","description":"Polars uses PyO3 to create a Foreign Function Interface (FFI) bridge between Python and Rust, allowing Python code to call Rust functions and vice versa. The bridge is implemented in the polars-python crate and handles type conversions, memory management, and error propagation between the two languages. This architecture enables Polars to provide a high-level Python API while leveraging Rust's performance for the core implementation. The FFI layer is transparent to users, but enables the entire performance advantage of the library.","intents":["I want to use Polars' Rust performance from Python without writing Rust code","I need to extend Polars with custom Rust functions","I want to integrate Polars with other Rust libraries"],"best_for":["Python developers requiring high-performance data processing","Teams building hybrid Python-Rust applications","Developers extending Polars with custom functionality"],"limitations":["FFI overhead adds latency to function calls; very small operations may not benefit from Rust implementation","Debugging across the Python-Rust boundary is complex; stack traces may be unclear","Custom Rust extensions require knowledge of both Rust and PyO3; not accessible to pure Python developers"],"requires":["Python 3.8+","Polars installed (pre-compiled wheels for common platforms)","For custom extensions: Rust toolchain and PyO3 knowledge"],"input_types":["Python objects (DataFrames, Series, etc.)","Rust data structures (via PyO3 bindings)"],"output_types":["Python objects (DataFrames, Series, etc.)","Rust data structures (via PyO3 bindings)"],"categories":["tool-use-integration","language-interop"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_13","uri":"capability://data.processing.analysis.streaming.execution.engine.for.memory.constrained.environments","name":"streaming execution engine for memory-constrained environments","description":"Polars implements a streaming execution engine via the polars-lazy crate that processes data in chunks rather than loading entire datasets into memory. The streaming engine is integrated with the lazy optimizer, allowing predicates and column selections to be pushed down to the streaming operators. This enables processing of datasets larger than available memory, with the tradeoff of slower execution compared to in-memory processing. The streaming engine is automatically selected for operations that support it, with fallback to in-memory execution for unsupported operations.","intents":["I need to process datasets larger than available memory","I want to minimize memory usage for data pipelines","I need to process streaming data sources (e.g., Parquet files on disk)"],"best_for":["Data engineers processing multi-gigabyte datasets on memory-constrained machines","Teams processing data from cloud storage with bandwidth constraints","Applications requiring predictable memory usage"],"limitations":["Streaming execution is slower than in-memory execution (2-5x slower) due to chunk processing overhead","Not all operations support streaming; some operations force fallback to in-memory execution","Streaming execution is not available for all I/O formats; CSV and Parquet are well-supported, but others may not be"],"requires":["Python 3.8+","Polars installed","Understanding of streaming execution model and its limitations"],"input_types":["LazyFrame (deferred computation graph)","File paths or file-like objects"],"output_types":["DataFrame (materialized result after collect())","Iterator of DataFrames (for streaming output)"],"categories":["data-processing-analysis","streaming-execution"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_14","uri":"capability://data.processing.analysis.schema.inference.and.validation.for.data.loading","name":"schema inference and validation for data loading","description":"Polars automatically infers column types and schemas when loading data from files, with support for explicit schema specification and validation. The schema inference is implemented in the polars-io crate and uses heuristics to determine column types from sample data. Users can override inferred types with explicit schema specifications, and Polars validates that loaded data matches the specified schema. This enables robust data loading with automatic type detection or strict type enforcement.","intents":["I want to automatically detect column types when loading data","I need to enforce a specific schema and validate that loaded data matches","I want to handle type mismatches gracefully during data loading"],"best_for":["Data engineers building robust data pipelines","Teams working with data quality requirements","Analysts loading data from multiple sources with varying schemas"],"limitations":["Type inference from CSV files can be incorrect for ambiguous data (e.g., '1' could be int or string); explicit schema specification is recommended","Schema validation is strict; data that doesn't match the schema will cause an error rather than coercion","Inferring schema requires scanning sample data, which adds latency to data loading"],"requires":["Python 3.8+","Polars installed"],"input_types":["File paths or file-like objects","Explicit schema specifications (dict or Polars Schema)"],"output_types":["DataFrame with inferred or specified schema","Schema information (for inspection)"],"categories":["data-processing-analysis","data-validation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_2","uri":"capability://data.processing.analysis.expression.based.dsl.for.composable.data.transformations","name":"expression-based dsl for composable data transformations","description":"Polars provides a functional expression API where operations are built as composable symbolic expressions (e.g., pl.col('x').filter(...).sum()) rather than imperative method chains. Expressions are evaluated lazily and can be combined, reused, and optimized as a unit. This is implemented via the Expression type in polars-plan, which represents operations as an AST that can be analyzed and rewritten before execution. The DSL supports column selection, arithmetic, string operations, temporal operations, and custom aggregations.","intents":["I want to write data transformations that are composable and reusable across multiple contexts","I need to apply the same transformation logic to multiple columns without repeating code","I want to build complex multi-step transformations that are readable and maintainable"],"best_for":["Data engineers building reusable transformation pipelines","Analysts writing complex aggregations and window functions","Teams transitioning from SQL to a programmatic DSL"],"limitations":["Learning curve for developers familiar with imperative pandas API; requires thinking in terms of expressions rather than method chains","Debugging expressions can be difficult because errors occur at collect() time, not during expression construction","Some Python operations (e.g., custom functions with side effects) are not supported in lazy context"],"requires":["Python 3.8+","Polars installed","Familiarity with functional programming concepts (map, filter, reduce)"],"input_types":["Column names (strings)","Expressions (symbolic operations)","Literals (constants)"],"output_types":["Expression (symbolic representation)","Series or DataFrame (after evaluation)"],"categories":["data-processing-analysis","domain-specific-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_3","uri":"capability://data.processing.analysis.multi.format.i.o.with.streaming.and.partitioned.reads","name":"multi-format i/o with streaming and partitioned reads","description":"Polars provides I/O operations for CSV, Parquet, NDJSON, and other formats via the polars-io crate, with support for streaming reads (processing data in chunks without loading entire file into memory) and Hive-style partitioned directory structures. The I/O layer integrates with the lazy execution engine, allowing predicates and column selections to be pushed down to the file reader, reducing data loaded from disk. Parquet support includes native Hive partitioning, where partition columns are inferred from directory structure.","intents":["I need to read large files that don't fit in memory by processing them in chunks","I want to filter and select columns at the I/O layer to minimize data transfer","I need to work with partitioned datasets organized in Hive-style directory structures"],"best_for":["Data engineers processing multi-gigabyte datasets on single machines","Teams working with cloud storage (S3, GCS) where bandwidth is a constraint","Analytics teams using partitioned data warehouses"],"limitations":["Streaming mode is not available for all formats (e.g., limited for NDJSON with certain operations)","Hive partitioning inference requires strict directory naming conventions; custom partitioning schemes are not supported","Remote file access (S3, GCS) requires additional dependencies and configuration; not included in base install"],"requires":["Python 3.8+","Polars installed","For cloud storage: optional dependencies (s3fs, gcsfs, etc.)","For Parquet: pyarrow or fastparquet backend"],"input_types":["File paths (local or remote URLs)","File-like objects (BytesIO, etc.)","Directory paths (for partitioned reads)"],"output_types":["DataFrame (eager read)","LazyFrame (lazy read with predicate pushdown)","Iterator of DataFrames (streaming mode)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_4","uri":"capability://data.processing.analysis.groupby.aggregation.with.multiple.aggregation.functions","name":"groupby aggregation with multiple aggregation functions","description":"Polars implements efficient GroupBy operations via the polars-ops crate, supporting multiple simultaneous aggregations (sum, mean, min, max, count, etc.) on grouped data. The implementation uses a hash-based grouping strategy that builds a hash table of group keys and applies vectorized aggregation functions to each group. Aggregations can be combined with expressions, allowing complex transformations like conditional aggregations and multiple aggregations on different columns in a single operation.","intents":["I need to compute multiple aggregations (sum, mean, count) across groups in a single pass","I want to apply different aggregations to different columns within the same groupby","I need to perform conditional aggregations (e.g., sum where condition is true)"],"best_for":["Data analysts computing summary statistics by group","ETL pipelines aggregating high-cardinality data","Teams building dashboards with pre-aggregated metrics"],"limitations":["GroupBy with very high cardinality (millions of unique groups) can consume significant memory for the hash table","Custom aggregation functions written in Python are not vectorized and will be slow; Rust-based custom aggregations are not yet supported","Streaming GroupBy is not available; all data must be loaded before grouping"],"requires":["Python 3.8+","Polars installed","Data must fit in memory (no streaming groupby)"],"input_types":["DataFrame or LazyFrame","Column names (for grouping keys)","Expressions (for aggregations)"],"output_types":["DataFrame (grouped and aggregated result)","LazyFrame (if using lazy evaluation)"],"categories":["data-processing-analysis","aggregation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_5","uri":"capability://data.processing.analysis.join.operations.with.multiple.join.types.and.strategies","name":"join operations with multiple join types and strategies","description":"Polars implements joins (inner, left, right, outer, cross) via the polars-ops crate using hash-based join algorithms for efficiency. The join implementation selects between hash join and sort-merge join strategies based on data characteristics. Joins are integrated with the lazy execution engine, allowing join order optimization and predicate pushdown. The implementation supports joining on single or multiple columns, with optional suffix handling for duplicate column names.","intents":["I need to combine two DataFrames on common columns with different join semantics","I want to join on multiple columns with automatic handling of duplicate names","I need to optimize join order and predicates across multiple joins"],"best_for":["Data engineers combining data from multiple sources","Analytics teams performing multi-table aggregations","ETL pipelines with complex data lineage"],"limitations":["Join performance degrades with very large join keys (millions of unique values) due to hash table overhead","Streaming joins are not supported; both DataFrames must fit in memory","Join order optimization is limited; complex multi-join queries may not be optimized as well as a query planner would"],"requires":["Python 3.8+","Polars installed","Both DataFrames must fit in memory"],"input_types":["DataFrame or LazyFrame (left and right tables)","Column names or expressions (join keys)","Join type (inner, left, right, outer, cross)"],"output_types":["DataFrame (eager join result)","LazyFrame (lazy join with optimization)"],"categories":["data-processing-analysis","join-operations"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_6","uri":"capability://data.processing.analysis.window.functions.with.partitioning.and.ordering","name":"window functions with partitioning and ordering","description":"Polars implements window functions (rank, row_number, lag, lead, sum over window, etc.) via the polars-ops crate, allowing computations over sliding or expanding windows of rows. Window functions support partitioning (grouping rows for window computation) and ordering (determining row order within windows). The implementation uses efficient algorithms for common window functions, with lazy evaluation integration for optimization.","intents":["I need to compute running totals or moving averages within groups","I want to rank rows within partitions based on a column value","I need to access previous or next row values for time-series analysis"],"best_for":["Time-series analysts computing rolling statistics","Data engineers building feature engineering pipelines","Analytics teams computing rankings and percentiles"],"limitations":["Window functions require data to be sorted by the ordering column, which can be expensive for large datasets","Custom window functions are not supported; only built-in functions are available","Streaming window functions are not available; all data must be loaded before computation"],"requires":["Python 3.8+","Polars installed","Data must fit in memory"],"input_types":["DataFrame or LazyFrame","Column names (for partitioning and ordering)","Window function expressions"],"output_types":["DataFrame (with window function results as new columns)","LazyFrame (if using lazy evaluation)"],"categories":["data-processing-analysis","window-functions"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_7","uri":"capability://data.processing.analysis.string.operations.and.pattern.matching","name":"string operations and pattern matching","description":"Polars provides string manipulation functions via the polars-ops crate, including substring extraction, pattern matching (regex), case conversion, splitting, and concatenation. String operations are vectorized and can be applied to entire columns efficiently. The implementation supports regex patterns with capture groups and named captures, enabling complex text processing without explicit iteration.","intents":["I need to extract or transform text data in a column using regex patterns","I want to split strings into multiple columns or filter rows based on text patterns","I need to perform case-insensitive comparisons or standardize text formatting"],"best_for":["Data engineers cleaning and standardizing text data","Analysts extracting structured data from unstructured text","Teams processing log files or natural language data"],"limitations":["Regex performance can be slow for very large strings or complex patterns; no optimization for common patterns","Unicode handling is correct but may be slower than ASCII-only operations","Custom string functions are not supported; only built-in functions are available"],"requires":["Python 3.8+","Polars installed","Familiarity with regex syntax for pattern matching"],"input_types":["Series or DataFrame columns (string type)","Regex patterns (as strings)","Replacement strings"],"output_types":["Series (string results)","DataFrame (if applied to multiple columns)"],"categories":["data-processing-analysis","text-processing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_8","uri":"capability://data.processing.analysis.temporal.operations.and.date.time.manipulation","name":"temporal operations and date/time manipulation","description":"Polars provides temporal data types (Date, Time, DateTime, Duration) and operations via the polars-time crate, including date arithmetic, timezone handling, date component extraction, and temporal filtering. Temporal operations are vectorized and support efficient computation over large date/time columns. The implementation includes support for multiple date formats and timezone conversions.","intents":["I need to extract date components (year, month, day) or perform date arithmetic","I want to convert between timezones or handle timezone-aware timestamps","I need to filter or group data by temporal periods (e.g., by week or month)"],"best_for":["Time-series analysts working with temporal data","Data engineers processing event logs with timestamps","Teams building financial or operational analytics"],"limitations":["Timezone support is limited to standard IANA timezone names; custom timezone definitions are not supported","Leap second handling is not implemented; timestamps are assumed to follow standard Unix time","Temporal operations on very large date ranges may have precision issues due to underlying integer representation"],"requires":["Python 3.8+","Polars installed","Understanding of temporal data types and timezone concepts"],"input_types":["Date, Time, DateTime, or Duration columns","Temporal expressions (e.g., date arithmetic)"],"output_types":["Date, Time, DateTime, or Duration (depending on operation)","Integer or String (for component extraction)"],"categories":["data-processing-analysis","temporal-operations"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-polars__cap_9","uri":"capability://data.processing.analysis.type.system.with.automatic.type.inference.and.coercion","name":"type system with automatic type inference and coercion","description":"Polars implements a rich type system via the polars-core crate, supporting primitive types (int, float, bool, string), temporal types (date, time, datetime), complex types (list, struct, categorical), and null handling. Type inference is performed during data loading, with support for explicit type specification. Type coercion rules are applied during operations to ensure type safety while minimizing explicit casting. The implementation includes support for nullable types and missing value handling.","intents":["I need to ensure type safety in data transformations without explicit casting","I want to work with complex data types (lists, structs) in a type-safe manner","I need to handle missing values (nulls) correctly in computations"],"best_for":["Data engineers building robust data pipelines with type safety","Teams working with complex nested data structures","Analysts requiring strict type checking to catch data quality issues"],"limitations":["Type inference from CSV files can be incorrect for ambiguous data; explicit type specification is recommended","Complex types (list, struct) have limited support for some operations; not all functions work with nested types","Type coercion rules are implicit and may surprise users unfamiliar with the rules"],"requires":["Python 3.8+","Polars installed","Understanding of Polars type system and coercion rules"],"input_types":["Data from various sources (CSV, Parquet, etc.)","Explicit type specifications (schema)"],"output_types":["Typed DataFrame with inferred or specified schema","Type information (for inspection)"],"categories":["data-processing-analysis","type-system"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":26,"verified":false,"data_access_risk":"high","permissions":["Python 3.8+","Polars installed via pip or conda","Understanding of expression-based DSL (not SQL-like)","Polars compiled with Arrow support (default in PyPI builds)","Understanding of columnar vs row-oriented tradeoffs","Polars installed with SQL support (polars[sql] extra)","Familiarity with SQL syntax","Polars installed","Polars installed (pre-compiled wheels for common platforms)","For custom extensions: Rust toolchain and PyO3 knowledge"],"failure_modes":["Lazy evaluation requires explicit .collect() call to materialize results, adding a mental model shift from eager pandas","Debugging lazy queries is harder because errors surface only at collect() time, not during expression building","Some operations (e.g., custom Python functions) force eager evaluation, breaking the optimization chain","Columnar format is slower for row-wise access patterns (e.g., iterating row-by-row)","Memory overhead for very wide tables with many small columns due to Arrow metadata per column","Compression is optional and not automatic; users must explicitly enable it","SQL support is not 100% complete; some advanced SQL features may not be implemented","Performance of SQL queries may be slightly lower than equivalent expression-based queries due to parsing overhead","Debugging SQL queries is harder because errors are reported in SQL terms rather than Polars expression terms","Eager execution lacks optimization benefits; complex queries may be slower than lazy equivalents","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.48999999999999994,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:22.334Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-polars","compare_url":"https://unfragile.ai/compare?artifact=pypi-polars"}},"signature":"GPrSAYmRnoT1OXnb8+3t8+Opijy9d5eE9jbcNnRKVo2MZ9T7KyDDpEGEWeqnf93gJvZsinGG+SLgNxYHdI01DA==","signedAt":"2026-06-21T23:49:57.597Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-polars","artifact":"https://unfragile.ai/pypi-polars","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-polars","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}