dpyr 0.0.1__tar.gz

dpyr-0.0.1/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: dpyr
+Version: 0.0.1
+Summary: dplyr for Python: tidy piped verbs over polars and duckdb, with real autocompletion. Name reservation — API under active development.
+Project-URL: Repository, https://github.com/maximerivest/dataframe
+Author-email: Maxime Rivest <mrive052@gmail.com>
+License: MIT
+Keywords: data-analysis,dataframe,dplyr,duckdb,polars,tidyverse
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dpyr
+
+**dplyr for Python.** A tidy, pipe-style data manipulation API — fronting
+[polars](https://pola.rs) and [duckdb](https://duckdb.org) — with real IDE
+autocompletion and dplyr-faithful semantics, verified by differential testing
+against dplyr itself.
+
+```python
+from dpyr import read_parquet, col, n, desc, starts_with
+
+(
+    starwars
+    .filter(col.height > 180, col.mass < 100)
+    .mutate(bmi = col.mass / (col.height / 100) ** 2)
+    .group_by(col.species)
+    .summarize(
+        n = n(),
+        mean_bmi = col.bmi.mean(),
+    )
+    .arrange(desc(col.mean_bmi))
+)
+```
+
+## Principles (the elevator pitch)
+
+1. **dplyr's vocabulary, Python's idiom.** The verbs are dplyr's, verbatim
+   (`filter`, `mutate`, `select`, `arrange`, `group_by`, `summarize`,
+   joins, tidyselect). The pipe is Python's: method chaining.
+2. **As lazy as possible internally, as eager as possible observably.**
+   Verbs build a plan; schema errors raise immediately on the offending
+   line; displaying/exporting auto-collects. Interactive feel, query-engine
+   performance.
+3. **Autocompletion is a feature, not an accident.** The `col` proxy and
+   per-schema stub generation make column names and column-typed methods
+   complete in any IDE.
+4. **Two backends, one semantics.** polars (in-memory/files) and duckdb
+   (SQL pushdown) must agree, bit-for-bit modulo the documented semantics
+   spec. Verified continuously.
+5. **dplyr is the oracle.** Compatibility is demonstrated, not claimed:
+   golden outputs are generated by actual dplyr in CI.
+
+## Project documents
+
+| Doc | What it pins down |
+|---|---|
+| [docs/DESIGN.md](docs/DESIGN.md) | API design, laziness/materialization model, autocompletion strategy, architecture |
+| [docs/SEMANTICS.md](docs/SEMANTICS.md) | The conformance spec: every deliberate decision where R, polars and duckdb disagree |
+| [docs/TESTING.md](docs/TESTING.md) | Test strategy: dplyr-as-oracle, backend differential tests, Hypothesis properties |
+| [docs/ROADMAP.md](docs/ROADMAP.md) | Epics and stories to MVP, in dependency order |
+
+## Status
+
+Pre-MVP. The plan is in [docs/ROADMAP.md](docs/ROADMAP.md).

dpyr-0.0.1/README.md

@@ -0,0 +1,53 @@
+# dpyr
+
+**dplyr for Python.** A tidy, pipe-style data manipulation API — fronting
+[polars](https://pola.rs) and [duckdb](https://duckdb.org) — with real IDE
+autocompletion and dplyr-faithful semantics, verified by differential testing
+against dplyr itself.
+
+```python
+from dpyr import read_parquet, col, n, desc, starts_with
+
+(
+    starwars
+    .filter(col.height > 180, col.mass < 100)
+    .mutate(bmi = col.mass / (col.height / 100) ** 2)
+    .group_by(col.species)
+    .summarize(
+        n = n(),
+        mean_bmi = col.bmi.mean(),
+    )
+    .arrange(desc(col.mean_bmi))
+)
+```
+
+## Principles (the elevator pitch)
+
+1. **dplyr's vocabulary, Python's idiom.** The verbs are dplyr's, verbatim
+   (`filter`, `mutate`, `select`, `arrange`, `group_by`, `summarize`,
+   joins, tidyselect). The pipe is Python's: method chaining.
+2. **As lazy as possible internally, as eager as possible observably.**
+   Verbs build a plan; schema errors raise immediately on the offending
+   line; displaying/exporting auto-collects. Interactive feel, query-engine
+   performance.
+3. **Autocompletion is a feature, not an accident.** The `col` proxy and
+   per-schema stub generation make column names and column-typed methods
+   complete in any IDE.
+4. **Two backends, one semantics.** polars (in-memory/files) and duckdb
+   (SQL pushdown) must agree, bit-for-bit modulo the documented semantics
+   spec. Verified continuously.
+5. **dplyr is the oracle.** Compatibility is demonstrated, not claimed:
+   golden outputs are generated by actual dplyr in CI.
+
+## Project documents
+
+| Doc | What it pins down |
+|---|---|
+| [docs/DESIGN.md](docs/DESIGN.md) | API design, laziness/materialization model, autocompletion strategy, architecture |
+| [docs/SEMANTICS.md](docs/SEMANTICS.md) | The conformance spec: every deliberate decision where R, polars and duckdb disagree |
+| [docs/TESTING.md](docs/TESTING.md) | Test strategy: dplyr-as-oracle, backend differential tests, Hypothesis properties |
+| [docs/ROADMAP.md](docs/ROADMAP.md) | Epics and stories to MVP, in dependency order |
+
+## Status
+
+Pre-MVP. The plan is in [docs/ROADMAP.md](docs/ROADMAP.md).

dpyr-0.0.1/docs/DESIGN.md

@@ -0,0 +1,132 @@
+# DESIGN — intent and architecture
+
+This document records the design decisions and *why* they were made, so the
+project stays coherent as it grows. Changes to anything in here deserve a
+discussion, not a drive-by PR.
+
+## 1. The problem
+
+dplyr's ergonomics rest on non-standard evaluation (bare column names),
+which Python cannot do. Prior ports each gave up something essential:
+
+- **dfply / dplython** — emulated `%>%` with `>>` operator hacks; alien to
+  Python, broke tooling, unmaintained.
+- **siuba** — closest in spirit (`_` proxy, SQL backend) but weak typing
+  and completion.
+- **tidypolars** — dplyr verb names over polars, but string column refs:
+  no completion, no expression typing.
+- **ibis** — the right architecture (expression IR, many backends, lazy
+  with interactive mode) but the API drifted far from dplyr.
+
+We take ibis's architecture, dplyr's API, and add the missing piece nobody
+shipped: schema-aware autocompletion.
+
+## 2. API surface
+
+### Verbs (dplyr names, verbatim)
+
+MVP set: `filter`, `mutate`, `select`, `rename`, `arrange`, `group_by`
+(+ implicit ungroup after `summarize`), `summarize`/`summarise`,
+`distinct`, `slice_head`/`slice_tail`/`slice_sample`, `count`,
+`left_join`/`inner_join`/`right_join`/`full_join`/`semi_join`/`anti_join`,
+`pivot_longer`, `pivot_wider`, `pull`.
+
+Pipe = method chaining. No `>>`/`|` operator overloading, ever.
+New columns via kwargs: `mutate(bmi = ...)`, `summarize(n = n())`.
+
+### The `col` proxy
+
+`col.height > 180` builds an expression tree (our IR), not a value.
+Column-typed expression classes (`NumExpr`, `StrExpr`, `BoolExpr`,
+`DtExpr`, ...) carry the appropriate methods (`.mean()`, `.str_detect()`,
+`.year()`), so completion is type-correct.
+
+Helpers as plain functions: `n()`, `desc()`, `if_else()`, `case_when()`,
+`across()`, and tidyselect (`starts_with`, `ends_with`, `contains`,
+`matches`, `where`, `everything`); negation via unary minus.
+
+### Autocompletion strategy (the differentiator)
+
+Three tiers, weakest to strongest:
+
+1. **Runtime**: `DFrame.__getattr__`/`__dir__` and a frame-bound `df.c`
+   proxy populated from the live schema → Jupyter/REPL completion for free.
+2. **Generic typing**: `DFrame[S]` parameterized by a `Cols` schema class;
+   `filter(lambda c: c.height > 180)` completes via the lambda's inferred
+   parameter type.
+3. **Stub codegen**: a CLI (`dpyr stubgen data/*.parquet`) reads
+   parquet/duckdb schemas and emits `Cols` subclasses + typed module
+   attributes, giving full static completion and type-checking in any IDE.
+
+## 3. Materialization model
+
+**Schema-eager, data-lazy, display-eager.** (The core UX decision.)
+
+- *Schema-eager*: every verb validates inputs against the known schema and
+  computes its output schema synchronously. Wrong column name, type
+  mismatch, bad group reference → exception on that line, with a one-frame
+  traceback. Requires only metadata; costs nothing.
+- *Data-lazy*: verbs append to a logical plan. No intermediate
+  materialization within a chain → query fusion, predicate pushdown into
+  parquet/duckdb.
+- *Display-eager* (default on): materialization happens automatically at
+  the boundaries where a value escapes the expression world —
+  `__repr__`/`_repr_html_` (fetch a capped preview, like tibble's 10-row
+  print), `len`, `.shape`, iteration, `.to_polars()`, `.to_pandas()`,
+  plotting hooks. In a notebook this *feels* fully eager; in a pipeline
+  that only collects at the end, the same code gets full laziness.
+  `mode="lazy"` / `.lazy()` opts out for production.
+
+Rationale: dplyr rose to fame *eager*; immediate errors and immediate
+results are why interactive analysis felt good. Immediate errors need only
+the schema. Immediate results need collection only at display points.
+
+### Sharp edges, handled deliberately
+
+- **Repeated re-execution**: cache results on first materialization, keyed
+  by plan hash. Plus an explicit `.persist()` checkpoint verb
+  (polars: collected frame; duckdb: `CREATE TEMP TABLE`).
+- **Source mutation between displays**: `persist()` is the snapshot
+  operator; documented honestly.
+- **Schema-needs-data ops** (`pivot_wider` — output columns come from
+  values): implicitly persist their input, compute, continue. Users never
+  see the distinction.
+- **Provenance in print**: repr shows collected rows plus
+  `# source: parquet (lazy) · showing 10 of ~87 rows`.
+
+## 4. Architecture
+
+```
+user API (verbs, col proxy)
+        │  builds
+        ▼
+logical plan + expression IR  ←— schema inference/validation lives here
+        │  compiles to
+        ├──────────────► polars LazyFrame (expression 1:1 mapping)
+        └──────────────► SQL string / relation for duckdb
+```
+
+- The IR is *ours* and small; semantics (NA handling, sort stability,
+  grouped ordering — see SEMANTICS.md) are pinned in the IR, and each
+  backend compiler is responsible for complying, inserting casts/sorts
+  where the engine's defaults differ.
+- Backend chosen at the source: `read_parquet/read_csv/from_polars/
+  from_pandas` → polars; `from_duckdb(con, "tbl")` / `read_sql` → duckdb.
+- `group_by` returns `GroupedDFrame` (separate type → separate completion
+  surface), auto-ungrouping after `summarize`, matching dplyr.
+
+## 5. Non-goals (MVP)
+
+- No pandas execution backend (only conversion in/out).
+- No R-style NSE magic via frame inspection / AST tricks.
+- No plotting, no modeling. Frames out are polars/pandas; the ecosystem
+  does the rest.
+- No distributed execution.
+
+## 6. Name
+
+PyPI name: `dpyr` — dplyr with the L dropped, so "py" sits in the middle:
+dplyr-for-Python in four characters. Chosen 2026-06-09 after `dataframe`
+turned out to be PyPI policy-blocked and `dataframes`/`table`/most
+expressive English words were squatted; `tibble` and `dplyr` were free but
+carry Posit brand-risk. Import name: `dpyr`.

dpyr-0.0.1/docs/ROADMAP.md

@@ -0,0 +1,100 @@
+# ROADMAP — epics & stories to MVP
+
+Ordered by dependency. A story is done when its tests (per TESTING.md) are
+green on both backends. MVP = Epics 0–7 complete.
+
+**MVP definition:** a user can `uv add dpyr`, read parquet/CSV or a
+duckdb table, run the core dplyr verb set with the `col` proxy, get
+immediate schema errors and auto-displayed results in Jupyter, and trust
+the output because it's differentially tested against dplyr.
+
+---
+
+## Epic 0 — Project foundation
+- **0.1** Repo scaffold: uv project, `pyproject.toml`, ruff, mypy/pyright,
+  pytest, pre-commit, GitHub Actions skeleton. ✅ (this commit)
+- **0.2** Reserve `dpyr` on PyPI with a 0.0.1 placeholder that
+  errors helpfully on import-and-use. (`dataframe` is PyPI policy-blocked;
+  see DESIGN.md §6 for the naming history.)
+- **0.3** Commit intent docs (DESIGN/SEMANTICS/TESTING/ROADMAP). ✅
+
+## Epic 1 — Expression IR & schema engine (the core)
+- **1.1** Dtype system: Int64/Float64/Bool/Str/Date/Datetime/Null + NA
+  model (SEMANTICS S1).
+- **1.2** Expression nodes: column refs, literals, arithmetic/comparison/
+  boolean ops, function calls; typed expr classes (NumExpr, StrExpr, ...).
+- **1.3** `col` proxy producing typed expressions; `desc()`, `n()`,
+  `if_else()`, `case_when()`.
+- **1.4** Logical plan nodes for every MVP verb; **schema inference +
+  validation per node** with did-you-mean errors and one-frame tracebacks.
+- **1.5** Plan hashing (for the materialization cache) and stable repr
+  (for IR snapshot tests).
+- Tests: unit + Hypothesis property 1 (schema soundness).
+
+## Epic 2 — polars backend
+- **2.1** Sources: `read_parquet`, `read_csv`, `from_polars`, `from_pandas`.
+- **2.2** Compile IR → polars LazyFrame for: filter, mutate, select,
+  rename, arrange, distinct, slices.
+- **2.3** group_by/summarize incl. grouped ordering (S7) and ungroup
+  semantics (S9).
+- **2.4** Joins (all six) with dplyr suffix & NA-matching rules (S10–S11).
+- **2.5** Semantics shims: sort stability/NA position (S3), int division
+  (S4), counts dtype (S13), division by zero (S14).
+
+## Epic 3 — Materialization model (the UX)
+- **3.1** Display-eager boundaries: `__repr__`/`_repr_html_` with capped
+  preview + provenance line, `len`, `.shape`, iteration, `.to_polars()`,
+  `.to_pandas()`, `.pull()`.
+- **3.2** Result cache keyed by plan hash; invalidation on `persist()`.
+- **3.3** `.persist()` checkpoint verb; `.lazy()` / `mode="lazy"` opt-out.
+- **3.4** Implicit persist for schema-needs-data ops (groundwork for
+  pivot_wider).
+- Tests: metamorphic laws on persist/collect/repr equivalence.
+
+## Epic 4 — Oracle harness (start early, runs forever)
+- **4.1** YAML spec format + Python spec runner.
+- **4.2** `oracle/run_specs.R` + pinned rocker container; golden parquet
+  generation; fixture metadata (dplyr version).
+- **4.3** Comparison/normalization harness implementing SEMANTICS
+  S6/S17/S19.
+- **4.4** CI: per-push spec tests vs committed goldens; nightly golden
+  drift job.
+- **4.5** Seed corpus: ~12 hand-written specs per MVP verb + ported dplyr
+  doc examples.
+
+## Epic 5 — duckdb backend
+- **5.1** Sources: `from_duckdb(con, table)`, `read_sql`.
+- **5.2** IR → SQL compiler for the Epic-2 verb set, with semantics shims
+  (casts, ORDER BY NULLS LAST, etc.).
+- **5.3** `persist()` as `CREATE TEMP TABLE`.
+- **5.4** Hypothesis property 2: backend agreement, in CI on every push.
+
+## Epic 6 — tidyselect, across, reshaping
+- **6.1** tidyselect: `starts_with/ends_with/contains/matches/where/
+  everything`, negation; works in `select`, `rename`, `distinct`.
+- **6.2** `across()` in mutate/summarize with `names=` templating.
+- **6.3** `pivot_longer`; `pivot_wider` (uses 3.4); `count`; `pull`.
+- **6.4** `GroupedDFrame` type with its own completion surface; grouped
+  filter/mutate window semantics.
+
+## Epic 7 — Autocompletion & developer experience
+- **7.1** Runtime completion: `__dir__` from live schema; frame-bound
+  `df.c` proxy.
+- **7.2** `DFrame[S]` generic typing + lambda-style `filter(lambda c: ...)`.
+- **7.3** `dpyr stubgen` CLI: parquet/duckdb schema → `Cols` stubs;
+  stubs checked by mypy+pyright in CI.
+- **7.4** Error message polish pass (the "feels eager" acceptance test:
+  every user mistake surfaces on the line that made it).
+
+## Epic 8 — Hardening & release (MVP gate)
+- **8.1** Port dplyr testthat regression tests for MVP verbs.
+- **8.2** Nightly Hypothesis-vs-oracle fuzzing job.
+- **8.3** Docs site: tutorial mirroring the dplyr vignette, dplyr→dataframe
+  cheat sheet, SEMANTICS as a public page.
+- **8.4** `0.1.0` to PyPI; announce with the differential-test count as
+  the headline ("passes N dplyr-generated golden tests").
+
+## Post-MVP (parking lot)
+`separate/unite`, `nest`, window function breadth, `slice_min/max`,
+list-columns, streaming collect, arrow Flight sources, sqlite/postgres
+backends via the duckdb SQL layer, plugin API for custom verbs.

dpyr-0.0.1/docs/SEMANTICS.md

@@ -0,0 +1,35 @@
+# SEMANTICS — the conformance spec
+
+Where R/dplyr, polars and duckdb disagree, this file records the decision.
+Every row below must be encoded as a test that links back here. Comparison
+against the dplyr oracle is checked *modulo these documented divergences* —
+never fuzzily.
+
+Legend: **R** = follow dplyr · **P** = follow polars/duckdb · **pinned** =
+our own rule, backends forced to comply.
+
+| # | Area | dplyr | polars/duckdb | Decision |
+|---|------|-------|---------------|----------|
+| S1 | Missing values | typed `NA`, `NaN` distinct | `null` vs `NaN` | **pinned**: NA ↔ null bidirectionally; NaN preserved as NaN; document |
+| S2 | `mean/sum/...` with missing | `NA` unless `na.rm=TRUE` | ignore nulls | **P**, with `na_rm: bool = True` kwarg for familiarity |
+| S3 | Sort: NA position & stability | NAs last, stable sort | varies per engine | **pinned**: stable, NAs last; `desc()` keeps NAs last |
+| S4 | `int / int` | promotes to double | varies | **R** (saner) |
+| S5 | Integer overflow | promotes / warns | wraps or errors | **pinned**: Int64 default; overflow errors |
+| S6 | String ordering / collation | locale-dependent (!) | byte/UTF-8 | **pinned**: C-locale codepoint order — *known divergence from R*; oracle harness normalizes |
+| S7 | Grouped result ordering | sorted by group keys | hash order | **R**: sort by keys |
+| S8 | Empty groups / zero-row inputs | specific dplyr behaviors | varies | **R**; port dplyr regression tests |
+| S9 | `summarize` ungrouping | drops last group level | n/a | **R**, including the multi-key behavior |
+| S10 | Join key NA matching | `NA` matches `NA` by default | SQL: NULL ≠ NULL | **R** default, `na_matches="never"` opt-out (mirrors dplyr arg) |
+| S11 | Join suffixes | `.x` / `.y` | `_right` etc. | **R**: `(".x", ".y")` |
+| S12 | Boolean with NA (3-valued logic) | NA propagates; `filter` drops NA | same in SQL | **R/SQL** (they agree); test it anyway |
+| S13 | `n()` / counts dtype | integer | u32/i64 | **pinned**: Int64 |
+| S14 | Division by zero | `Inf`/`NaN` | varies (duckdb errors on int) | **R**: `Inf`/`-Inf`/`NaN`, cast first on duckdb |
+| S15 | `case_when` no match | `NA` | null | agree; pin the result dtype unification rule |
+| S16 | Date/time zones | rich, messy | UTC-leaning | **pinned**: tz-aware UTC default; naive allowed; conversions explicit |
+| S17 | Factors | core R type | none | not supported; oracle harness converts factors → strings before compare |
+| S18 | Recycling length-1 values in `mutate` | yes | literals broadcast | **R** for scalars only; no general recycling |
+| S19 | Float comparison in tests | — | — | harness: sort-normalize where order unspecified + ULP tolerance |
+
+Process: when a differential test fails and the cause is a *new* semantic
+disagreement, the fix is (1) add a row here, (2) encode it in the harness
+normalization or backend compiler, (3) add a dedicated test naming the row.

dpyr-0.0.1/docs/TESTING.md

@@ -0,0 +1,81 @@
+# TESTING — strategy
+
+Three layers. dplyr is the oracle; polars↔duckdb agreement is the
+workhorse; Hypothesis finds what nobody thought to write.
+
+## Layer 1 — differential testing against dplyr (the oracle)
+
+Test cases live in a neutral spec format (YAML), input data + verb chain:
+
+```yaml
+# tests/specs/summarize/grouped_mean.yaml
+input: starwars
+chain:
+  - filter: "height > 180"
+  - group_by: [species]
+  - summarize: {n: "n()", mh: "mean(height, na.rm=TRUE)"}
+```
+
+- `oracle/run_specs.R` translates each spec to dplyr code, runs it, writes
+  the result as **parquet** (lossless types, NA fidelity — never CSV) into
+  `tests/golden/`.
+- pytest runs the same spec through our library (both backends) and
+  asserts frame equality via the normalization harness (see SEMANTICS.md
+  S6/S17/S19).
+
+**R stays out of the inner loop.** Golden parquets are generated offline
+and committed. Day-to-day `pytest` is pure Python. A separate CI job in a
+pinned `rocker/tidyverse` container regenerates all goldens and fails on
+drift — catching both our bugs and wrongly-encoded expectations. dplyr
+version is pinned and recorded in fixture metadata.
+
+## Layer 2 — mined test corpus
+
+- Port **dplyr's documented examples** (every verb's examples, vignettes,
+  relevant R4DS chapters) into specs. They double as our tutorial docs.
+- Read **dplyr's testthat suite** and port its *regression tests* — each
+  is a documented historical bug (zero-row groups, grouped filter, join
+  multiplicities, `across()` corners).
+- **dbplyr's translation tests** inform the duckdb compiler.
+
+## Layer 3 — property-based testing (Hypothesis)
+
+Strategies generate small random frames (mixed dtypes, nulls, empty,
+single-row, duplicates) and type-correct random verb chains (a grammar
+over the IR).
+
+Properties, in order of cost:
+
+1. **Schema soundness** (no oracle): predicted output schema ==
+   actually-collected schema. Cheap; run always. This is the test of the
+   schema-eager promise.
+2. **Backend agreement** (no oracle): polars result == duckdb result for
+   the same plan. Our most important invariant. Run always.
+3. **Metamorphic laws** (no oracle):
+   - `filter(p).filter(q)` ≡ `filter(p & q)`
+   - `arrange ∘ filter` ≡ `filter ∘ arrange` (as multisets)
+   - `mutate` of an unused column doesn't change downstream `summarize`
+   - chain collected once ≡ collected verb-by-verb with `persist()`
+     between every step ← *specifically exercises the lazy/eager machinery*
+   - repr (display-eager) then collect ≡ collect directly (cache
+     correctness)
+4. **Oracle fuzzing** (needs R): sampled generated cases through the
+   dplyr oracle. Nightly job, not per-commit.
+
+## Unit layers (ordinary but required)
+
+- IR construction & schema inference per verb (golden IR snapshots).
+- duckdb compiler: IR → SQL string snapshots.
+- Error UX: wrong column names raise immediately with short tracebacks
+  and did-you-mean suggestions (asserted on message content).
+- Stubgen: generated stubs compile under mypy & pyright in CI.
+
+## CI matrix
+
+| Job | Trigger | Needs R |
+|---|---|---|
+| pytest (specs vs committed goldens, both backends) | every push | no |
+| Hypothesis schema/backend/metamorphic | every push | no |
+| golden regeneration + drift check | nightly + golden-touching PRs | yes (docker) |
+| oracle fuzzing | nightly | yes (docker) |
+| mypy/pyright incl. generated stubs | every push | no |

dpyr-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "dpyr"
+version = "0.0.1"
+description = "dplyr for Python: tidy piped verbs over polars and duckdb, with real autocompletion. Name reservation — API under active development."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Maxime Rivest", email = "mrive052@gmail.com" }]
+keywords = ["dplyr", "dataframe", "polars", "duckdb", "tidyverse", "data-analysis"]
+classifiers = [
+  "Development Status :: 1 - Planning",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Repository = "https://github.com/maximerivest/dataframe"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff", "mypy", "hypothesis"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dpyr"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

dpyr-0.0.1/src/dpyr/__init__.py

@@ -0,0 +1,17 @@
+"""dataframe — dplyr for Python, fronting polars and duckdb.
+
+This release reserves the package name while the library is under active
+development. See https://github.com/maximerivest/dpyr for the design
+documents and roadmap.
+"""
+
+__version__ = "0.0.1"
+
+
+def __getattr__(name: str):
+    raise NotImplementedError(
+        f"dpyr.{name} is not available yet: version {__version__} is a "
+        "name-reservation release. The dplyr-style API (filter, mutate, "
+        "group_by, summarize, ...) is under development — see "
+        "https://github.com/maximerivest/dpyr for the roadmap."
+    )