|2 days ago||1 day ago|
|Apache License 2.0||MIT License|
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
What is a library in another language that you wish would exist in Haskell
1 project | reddit.com/r/haskell | 21 Jan 2022
I took a deeper look and find Julia has gained great coverage of Arrow data standard: https://github.com/apache/arrow/tree/master/julia/Arrow
Awkward: Nested, jagged, differentiable, mixed type, GPU-enabled, JIT'd NumPy
5 projects | news.ycombinator.com | 16 Dec 2021
Hi! I'm the original author of Awkward Array (Jim Pivarski), though there are now many contributors with about five regulars. Two of my colleagues just pointed me here—I'm glad you're interested! I can answer any questions you have about it.
First, sorry about all the TODOs in the documentation: I laid out a table of contents structure as a reminder to myself of what ought to be written, but haven't had a chance to fill in all of the topics. From the front page (https://awkward-array.org/), if you click through to the Python API reference (https://awkward-array.readthedocs.io/), that site is 100% filled in. Like NumPy, the library consists of one basic data type, `ak.Array`, and a suite of functions that act on it, `ak.this` and `ak.that`. All of those functions are individually documented, and many have examples.
The basic idea starts with a data structure like Apache Arrow (https://arrow.apache.org/)—a tree of general, variable-length types, organized in memory as a collection of columnar arrays—but performs operations on the data without ever taking it out of its columnar form. (3.5 minute explanation here: https://youtu.be/2NxWpU7NArk?t=661) Those columnar operations are compiled (in C++); there's a core of structure-manipulation functions suggestively named "cpu-kernels" that will also be implemented in CUDA (some already have, but that's in an experimental stage).
A key aspect of this is that structure can be manipulated just by changing values in some internal arrays and rearranging the single tree organizing those arrays. If, for instance, you want to replace a bunch of objects in variable-length lists with another structure, it never needs to instantiate those objects or lists as explicit types (e.g. `struct` or `std::vector`), and so the functions don't need to be compiled for specific data types. You can define any new data types at runtime and the same compiled functions apply. Therefore, JIT compilation is not necessary.
We do have Numba extensions so that you can iterate over runtime-defined data types in JIT-compiled Numba, but that's a second way to manipulate the same data. By analogy with NumPy, you can compute many things using NumPy's precompiled functions, as long as you express your workflow in NumPy's vectorized way. Numba additionally allows you to express your workflow in imperative loops without losing performance. It's the same way with Awkward Array: unpacking a million record structures or slicing a million variable-length lists in a single function call makes use of some precompiled functions (no JIT), but iterating over them at scale with imperative for loops requires JIT-compilation in Numba.
Just as we work with Numba to provide both of these programming styles—array-oriented and imperative—we'll also be working with JAX to add autodifferentiation (Anish Biswas will be starting on this in January; he's actually continuing work from last spring, but in a different direction). We're also working with Martin Durant and Doug Davis to replace our homegrown lazy arrays with industry-standard Dask, as a new collection type (https://github.com/ContinuumIO/dask-awkward/). A lot of my time, with Ianna Osborne and Ioana Ifrim at my university, is being spent refactoring the internals to make these kinds of integrations easier (https://indico.cern.ch/event/855454/contributions/4605044/). We found that we had implemented too much in C++ and need more, but not all, of the code to be in Python to be able to interact with third-party libraries.
If you have any other questions, I'd be happy to answer them!
Test Parquet float16 Support in Pandas
3 projects | dev.to | 14 Dec 2021
https://github.com/apache/arrow/issues/2691 https://issues.apache.org/jira/browse/ARROW-7242 https://issues.apache.org/jira/browse/PARQUET-1647
Any role that Rust could have in the Data world (Big Data, Data Science, Machine learning, etc.)?
8 projects | reddit.com/r/rust | 4 Dec 2021
pigeon-rs: Open source email automation written in Rust
5 projects | reddit.com/r/rust | 20 Nov 2021
Connectorx is using arrow2 data format for fetching from a database. This data format is optimized for columnar data :
Introducing tidypolars - a Python data frame package for R tidyverse users
9 projects | reddit.com/r/rstats | 10 Nov 2021
I think having a basic understanding of pandas, given how broadly it's used, is beneficial. That being said, polars seems to be matching or beating data.table in performance, so I think it'd be very worth it to take it up. Wes McKinney, creator of pandas, has been quite vocal about architecture flaws of pandas -- which is why he's been working on the Arrow project. polars is based on Arrow, so in principle it's kinda like pandas 2.0 (adopting the changes that Wes proposed).9 projects | reddit.com/r/rstats | 10 Nov 2021
So the question is really - how is polars so fast? Polars is packed by Apache Arrow, which is a columnar memory format that is designed specifically for performance.
Comparing SQLite, DuckDB and Arrow
5 projects | news.ycombinator.com | 27 Oct 2021
The Data Engineer Roadmap 🗺
11 projects | dev.to | 19 Oct 2021
C++ Jobs - Q4 2021
4 projects | reddit.com/r/cpp | 2 Oct 2021
Technologies: Apache Arrow, Flatbuffers, C++ Actor Framework, Linux, Docker, Kubernetes
Polars DataFrame library 0.19.0 is out!
2 projects | reddit.com/r/rust | 19 Jan 2022
What would it take to recreate dplyr in Python?
3 projects | news.ycombinator.com | 17 Jan 2022
It says [here](https://github.com/pola-rs/polars/issues/580#issuecomment-82...) that Polars has zero copy for arrow and numpy.
Raku for the the scientist/PROGRAMMER that is hitting the limits of Python
7 projects | reddit.com/r/rakulang | 3 Jan 2022
polars is a DataFrame library in Rust, is it possible to have Raku call this library?
The polars dataframe library now also exposes bindings to NodeJS
2 projects | reddit.com/r/node | 22 Dec 2021
See the README
Writing Rust libraries for the Python scientific computing ecosystem
12 projects | reddit.com/r/rust | 19 Dec 2021
All the problems you describe are thing we also encountered in writing polars. Take a look at the py-polars directory in root. I believe we have done all you listed. :)12 projects | reddit.com/r/rust | 19 Dec 2021
Maybe you'll find some other inspiration with this lib: Polars (if you don't already know it)
Polars: Lightning-fast DataFrame library for Rust and Python
13 projects | news.ycombinator.com | 16 Dec 2021
Rust and what it needs to gain space in computation-oriented applications
7 projects | reddit.com/r/rust | 24 Nov 2021
You should check out polars, datafusion, influxdb iox and databend, all written in native Rust and powered by the Apache Arrow format. Polars in particular is pretty dam fast and has bindings for Python.
How to pass dataframes between Rust and Python?
4 projects | reddit.com/r/rust | 20 Nov 2021
A solution for either Polars or Datafusion (or something else?) would be fine. For both libraries, python packages exist, that contain the python bindings: https://github.com/pola-rs/polars/tree/master/py-polars https://github.com/apache/arrow-datafusion/tree/master/python4 projects | reddit.com/r/rust | 20 Nov 2021
It's working for me now. :-) To get it working, I used the code from the suggested directory as well as the class PyPolarsError, which I copied into a local module: https://github.com/pola-rs/polars/tree/master/py-polars/src/arrow_interop https://github.com/pola-rs/polars/blob/629f5012bcefaa3c9a9c1a236e64dc057e8d472c/py-polars/src/error.rs Besides the polars dependency, also these are needed:
What are some alternatives?
vaex - Out-of-Core hybrid Apache Arrow/NumPy DataFrame for Python, ML, visualization and exploration of big tabular data at a billion rows per second 🚀
h5py - HDF5 for Python -- The h5py package is a Pythonic interface to the HDF5 binary data format.
arrow-datafusion - Apache Arrow DataFusion and Ballista query engines
arquero - Query processing and transformation of array-backed data tables.
Apache Spark - Apache Spark - A unified analytics engine for large-scale data processing
ta-lib - Python wrapper for TA-Lib (http://ta-lib.org/).
db-benchmark - reproducible benchmark of database-like ops
DataFrames.jl - In-memory tabular data in Julia
arrow-rs - Official Rust implementation of Apache Arrow
spark-rapids - Spark RAPIDS plugin - accelerate Apache Spark with GPUs
arrow2 - Unofficial transmute-free Rust library to work with the Arrow format