---
id: flupy
version: "1.2.4"
license: MIT
license_treatment: permissive
maintenance: active
---

# flupy — Fluent data processing in Python - a chainable stream processing library for expressive data manipulation using method chaining

License: permissive · Maintenance: active · Downloads: 1.8M/mo

## What it is and what it does

Flupy is a lightweight, zero-dependency Python library that implements a fluent interface for working with iterables. It lets you chain operations like map, filter, chunk, and take in a readable, method-chaining style while maintaining lazy evaluation—all transformations are generators that process data on-demand rather than loading everything into memory at once.

The library is designed as a pure-Python alternative to Apache Spark for scenarios where you need expressive, memory-efficient data pipelines without external dependencies. It supports both library usage (importing `flu` and chaining methods) and command-line usage through a `flu` shell command that applies the same lazy pipeline syntax to file or stdin input.

Use it for:

- Process infinite or very large sequences (like itertools.count) without exhausting memory by chaining transformations.
- Build readable, chainable data transformation pipelines in place of nested loops or complex list comprehensions.
- Filter, map, and chunk streaming data in a shell script using the flupy CLI tool.
- Prototype data processing logic that could later scale to Spark without rewriting the pipeline structure.
- Combine multiple lazy operations (e.g., map → filter → chunk → take) while keeping intermediate results as generators.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Flupy provides a fluent interface for lazy evaluation of operations on Python iterables, allowing you to chain transformations like map, filter, and chunk while processing data in constant memory regardless of input size.

Yes. Flupy is a low-friction, well-maintained library with zero dependencies, permissive licensing, and no known vulnerabilities. Install it if you want readable, chainable lazy evaluation for iterables without the overhead of larger frameworks. It's particularly useful for memory-constrained scenarios or when you prefer functional-style pipelines over imperative loops.

## Install

pip install flupy
uv add flupy
poetry add flupy

## Installing flupy

Before you install: Installation is straightforward with no runtime dependencies. The package is actively maintained with a recent release (27 days ago) and has been stable since its initial 2018 release, supporting Python 3.10 through 3.13.

License in practice: MIT license permits commercial and private use with minimal restrictions, making it safe to adopt in most projects without licensing concerns.

Quickstart:

from flupy import flu
from itertools import count

pipeline = (
    flu(count())
    .map(lambda x: x**2)
    .filter(lambda x: x % 517 == 0)
    .take(3)
)

for item in pipeline:
    print(item)

Requires Python 3.10 or later.

Verify before relying:

- Whether the CLI tool is included in the standard pip installation or requires additional setup.
- Performance characteristics on very large datasets compared to alternatives like itertools or pandas.
- Community adoption and real-world usage patterns beyond the documented examples.

## Package facts

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: active
- Downloads: 1.8M/month (top 5,000 on PyPI)
- Known vulnerabilities: none known

## Tags

lazy evaluation iterables, fluent interface data processing, chainable stream operations, memory-efficient data transformation, generator-based pipelines, functional data processing python, iterable method chaining, lazy-evaluation, functional-programming, stream-processing

[View on SkillFed](https://skillfed.io/packages/flupy) · [View on PyPI](https://pypi.org/project/flupy/)