memframe 0.2.0__tar.gz → 0.2.2__tar.gz

{memframe-0.2.0 → memframe-0.2.2}/.github/workflows/release-testpypi.yml

@@ -20,7 +20,14 @@ jobs:
         env:
           UV_PUBLISH_TOKEN: ${{ secrets.TEST_PYPI_TOKEN }}
         run: uv publish --publish-url https://test.pypi.org/legacy/
+      - name: Extract release notes from CHANGELOG
+        env:
+          VERSION: ${{ github.ref_name }}
+        run: |
+          ver="${VERSION#v}"
+          awk -v v="## [$ver]" '$0 ~ "^## \\[" ver "\\]"{f=1;next} /^## \[/{if(f)exit} f' CHANGELOG.md > release_notes.md
+          cat release_notes.md
       - name: Create GitHub release
         uses: softprops/action-gh-release@v2
         with:
-          generate_release_notes: true
+          body_path: release_notes.md

{memframe-0.2.0 → memframe-0.2.2}/.gitignore

@@ -86,3 +86,4 @@ Thumbs.db
 plot.html
 *.html
 
+src/memframe/test_main.py

memframe-0.2.2/.opencode/plans/corr_cov_single_scan.md

@@ -0,0 +1,154 @@
+# Plan: Pure in-DB single-scan correlation / covariance (Tier-1 + Tier-2 ClickHouse)
+
+Status: APPLICATION BLOCKED — an active permission rule denies `edit` on source files
+(`edit * -> deny`), consistent with read-only plan mode. The code below is ready to
+apply once edit permission / plan mode is lifted.
+
+## Goal
+Replace the `UNION ALL` of per-pair `CORR()`/`COVAR_SAMP()` (one full table scan per
+pair ≈ n²/2 scans) with batches of B aggregate calls inside ONE `SELECT` (one scan per
+batch). The DB engine evaluates all aggregates in a single pass over the data. Keep the
+DB-native `CORR`/`COVAR_SAMP` so results still match `pandas.corr()/.cov()` within
+`rtol=1e-5` (existing tests pass). Drop the intermediate output table.
+
+## Tier-2 (ClickHouse, adaptive single-scan, no UDF)
+Batch size `B = min(total_pairs, 250)` for ClickHouse; when the whole pair set fits the
+expression budget the loop issues a *single* `SELECT` (one scan). Wider tables fall back
+to batching (still one scan per batch). DuckDB/Postgres use `B = min(total_pairs, 500)`.
+
+## File: src/memframe/core/analytix/stats.py
+
+### 1) Replace `_exec_union_batched` (lines 809-819) with this helper
+
+```python
+    async def _multi_column_assoc_matrix(
+        self,
+        table: str,
+        schema: str,
+        columns: List[str],
+        agg_fn: str,
+        backend=None,
+        data_id: Optional[str] = None,
+        new_table: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Compute an n x n correlation/covariance matrix purely in the database.
+
+        All CORR/COVAR_SAMP calls are batched into single SELECT statements so the
+        engine scans the table once per batch, not once per pair. ClickHouse uses a
+        tighter batch so a single scan covers the table whenever the pair count fits
+        its expression budget (Tier-2); wider tables fall back to batching.
+        """
+        try:
+            if not isinstance(self.db, (PostgresAdapter, DuckDBAdapter, ClickHouseAdapter)):
+                raise self._unsupported_backend_error()
+
+            q = self._qualified_table(table, schema)
+            cols = [SQLIdentifierSanitizer.sanitize(c) for c in columns]
+            n = len(cols)
+            if n < 1:
+                return self._error_response("No columns provided", columns)
+
+            def _cast(c: str) -> str:
+                if isinstance(self.db, PostgresAdapter):
+                    return f'CAST(NULLIF("{c}"::text, \'\') AS DOUBLE PRECISION)'
+                if isinstance(self.db, DuckDBAdapter):
+                    return f'TRY_CAST("{c}" AS DOUBLE)'
+                return f'toFloat64OrNull(toString("{c}"))'
+
+            alias = {c: f"a{idx}" for idx, c in enumerate(cols)}
+            pairs = [(i, j) for i in range(n) for j in range(i, n)]
+
+            # ponytail: batch size chosen under each backend's expression-count limit
+            if isinstance(self.db, ClickHouseAdapter):
+                B = min(len(pairs), 250)
+            else:
+                B = min(len(pairs), 500)
+
+            results: Dict[tuple, Any] = {}
+            for start in range(0, len(pairs), B):
+                batch = pairs[start:start + B]
+                used = sorted(
+                    {cols[i] for (i, j) in batch} | {cols[j] for (i, j) in batch},
+                    key=lambda c: cols.index(c),
+                )
+                cte = ", ".join(f"{_cast(c)} AS {alias[c]}" for c in used)
+                sel = []
+                for k, (i, j) in enumerate(batch):
+                    ai, aj = alias[cols[i]], alias[cols[j]]
+                    cond = f"{ai} IS NOT NULL AND {aj} IS NOT NULL"
+                    sel.append(
+                        f"{agg_fn}(CASE WHEN {cond} THEN {ai} END, "
+                        f"CASE WHEN {cond} THEN {aj} END) AS v_{k}"
+                    )
+                sql = f"WITH q AS (SELECT {cte} FROM {q}) SELECT " + ", ".join(sel) + " FROM q"
+                rows = await self._fetch(sql)
+                row = rows[0] if rows else {}
+                for k, (i, j) in enumerate(batch):
+                    val = row.get(f"v_{k}") if row else None
+                    results[(i, j)] = val if val is not None else float("nan")
+
+            mat = [[results.get((min(i, j), max(i, j))) for j in range(n)] for i in range(n)]
+            df = pd.DataFrame(mat, index=columns, columns=columns)
+            msg = f"Computed {agg_fn} matrix for {n} columns"
+            return self._success_response(msg, columns, result=df)
+
+        except Exception as e:
+            return self._error_response(
+                f"multi_column_assoc_matrix error: {str(e)}\n{traceback.format_exc()}",
+                columns,
+            )
+```
+
+### 2) Replace `numeric_multi_column_correlation` (lines 821-889) with
+
+```python
+    async def numeric_multi_column_correlation(
+        self,
+        table: str,
+        schema: str,
+        columns: List[str],
+        backend=None,
+        data_id: Optional[str] = None,
+        new_table: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        agg = "CORR" if isinstance(self.db, (PostgresAdapter, DuckDBAdapter)) else "corr"
+        return await self._multi_column_assoc_matrix(
+            table, schema, columns, agg, backend=backend, data_id=data_id, new_table=new_table
+        )
+```
+
+### 3) Replace `numeric_multi_column_covariance` (lines 891-952) with
+
+```python
+    async def numeric_multi_column_covariance(
+        self,
+        table: str,
+        schema: str,
+        columns: List[str],
+        backend=None,
+        data_id: Optional[str] = None,
+        new_table: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        agg = "COVAR_SAMP" if isinstance(self.db, (PostgresAdapter, DuckDBAdapter)) else "covarSamp"
+        return await self._multi_column_assoc_matrix(
+            table, schema, columns, agg, backend=backend, data_id=data_id, new_table=new_table
+        )
+```
+
+## Why it is correct
+- One `SELECT` with B `CORR`/`COVAR_SAMP` = one table scan (SQL engines aggregate in a
+  single pass). Scans drop from n(n+1)/2 to ceil(n(n+1)/2 / B).
+- Per-pair `CASE WHEN ai IS NOT NULL AND aj IS NOT NULL THEN ai END` keeps pairwise
+  deletion; cast yields NULL on empty-string/non-numeric, so old behaviour is preserved.
+- Uses the DB's native `CORR`/`COVAR_SAMP` (sample, ddof=1) → matches pandas within rtol.
+- `new_table`/output table removed; cache auto-persists the result DataFrame.
+
+## Removed
+- `_exec_union_batched` (was only used by these two functions).
+
+## Validation
+1. `tests/integration/ops/test_inspect.py::test_corr`
+   `tests/integration/ops/test_stats.py::test_corr` / `test_cov` / `test_autocorr`
+   on DuckDB + Postgres + ClickHouse → green.
+2. `/tmp/opencode/covid_sample_test.py` (56 cols × 3 backends) vs `df.corr()/.cov()` (rtol=1e-5).
+3. Timing: 61×350k DuckDB before (~65s) vs after (seconds).

{memframe-0.2.0 → memframe-0.2.2}/CHANGELOG.md

@@ -6,6 +6,26 @@ to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-08-19
+
+### Changed
+- Data Quality Reports (missing-values, completeness, numeric summary, profile report) relocated from the cleaning module to the inspect module.
+- Removed bivariate association methods (chi_square, cramers_v, theil_u, mutual_information) and their categorical wrappers.
+- CONTRIBUTING.md: added a distinct `[refactor]` commit tag (pure restructuring, no behavior/public-API change) separate from `[upgrade]`.
+- README and docs: documented that every call compiles to backend-native SQL; added Open-in-Colab badge.
+
+## [0.2.1] - 2026-08-17
+
+### Fixed
+- Postgres `.corr()`/`.cov()` now compute via streaming in-memory numpy for wide
+  feature sets, removing the Postgres aggregate-explosion hang and greatly
+  speeding up wide correlation/covariance matrices.
+- DuckDB `.corr()` recursion-depth failure fixed for large column-pair counts.
+- Arithmetic `add`/`subtract`/`multiply`/`divide` now correctly handle
+  vector-scalar operands (column ± scalar, scalar ± column, negative and float
+  scalars); scalar-scalar operands are now rejected with a clear `OperationError`.
+- Fixed `clip` date parsing bug.
+
 ## [0.2.0] - 2026-08-16
 
 ### Changed

{memframe-0.2.0 → memframe-0.2.2}/CONTRIBUTING.md

@@ -48,7 +48,8 @@ tidy. The full set:
 | ----------- | ----------------------------------------------------------------------------------------- |
 | `[feat]`    | New feature addition. **Fork the repo and open a PR from a feature branch** — never commit `[feat]` directly to `main`. |
 | `[fix]`     | Any bug fix — incorrect behavior, broken test, wrong SQL, etc.                           |
-| `[upgrade]` | Existing feature rewritten, refactored, or extended into a new shape (e.g. expanding the cleaning tool surface). |
+| `[upgrade]` | Existing feature rewritten or extended into a new shape — **behavior or public-API change** (e.g. expanding the cleaning tool surface, moving a public method between classes). |
+| `[refactor]` | Pure restructuring with **no behavior or public-API change** — moving private helpers, renaming internals, reorganizing files/modules. Can land directly on `main`. |
 | `[ci]`      | CI / GitHub Actions / pre-commit / hooks / workflow changes only.                        |
 | `[docs]`    | Documentation-only changes (README, `docs/`, docstrings).                                |
 | `[add]`     | Adding a supporting file that does not introduce a feature (fixture, config, isolated helper). |
@@ -64,7 +65,7 @@ tidy. The full set:
 
 - Tag is lowercase, bracketed, single space, then the summary.
 - Summary is imperative mood, ≤72 chars, no trailing period.
-- The seven tags above are exhaustive. If a change genuinely fits none of them, prefer the closest tag and explain in the body. `[update]` is **not** a valid tag — use `[upgrade]` or `[docs]` instead.
+- The eight tags above are exhaustive. If a change genuinely fits none of them, prefer the closest tag and explain in the body. `[update]` is **not** a valid tag — use `[upgrade]` or `[docs]` instead.
 
 ### Examples
 
@@ -72,6 +73,7 @@ tidy. The full set:
 git commit -m "[feat] Add ClickHouse adapter for cache reload"
 git commit -m "[fix] Avoid double COUNT(*) on empty select_dtypes result"
 git commit -m "[upgrade] Stats tool surface to full wrapper parity"
+git commit -m "[refactor] Move data-quality reports into the inspect module"
 git commit -m "[ci] Remove integration job from ci workflow"
 git commit -m "[docs] Slim README and add agent section"
 git commit -m "[add] tests/datasets/sample.parquet fixture"
@@ -99,7 +101,8 @@ branch + pull request — never commit directly to `main`):
 Direct commits to `main` are reserved for the maintainer's small,
 self-contained changes that don't need another pair of eyes: single-file
 `[fix]`, single-file `[docs]`, single-file `[add]`, single-file
-`[remove]`, and small single-workflow `[ci]` tweaks.
+`[remove]`, small `[refactor]` (no public-API change), and small
+single-workflow `[ci]` tweaks.
 
 When in doubt, open a branch.
 

{memframe-0.2.0 → memframe-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memframe
-Version: 0.2.0
+Version: 0.2.2
 Summary: memFrame is a Python package for working with database-backed DataFrame operations. It lets you upload CSV files, Parquet files, and pandas DataFrames into a local DuckDB database or a remote PostgreSQL/Clickhouse database, then run DataFrame-style inspection, selection, cleaning, and table-management operations through one consistent API.
 Project-URL: Homepage, https://github.com/Debojit95/memFrame
 Project-URL: Documentation, https://debojit95.github.io/memFrame/
@@ -55,12 +55,14 @@ Description-Content-Type: text/markdown
 [![Tox](https://img.shields.io/github/actions/workflow/status/Debojit95/memFrame/tox.yml?label=tox)](https://github.com/Debojit95/memFrame/actions/workflows/tox.yml)
 [![License - AGPL-3.0](https://img.shields.io/github/license/Debojit95/memFrame)](https://github.com/Debojit95/memFrame/blob/main/LICENSE)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/memframe)](https://pypi.org/project/memframe/)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1UtoPjzTmia4Cr6y2btDmV8mINgXaBPGP?usp=sharing)
 
 > *memFrame brings a pandas-like DataFrame API to DuckDB, PostgreSQL, and ClickHouse — async-first, with an optional AI agent for natural-language data work.*
 
 ## Features
 
 - Database-backed DataFrame API across DuckDB, PostgreSQL, and ClickHouse.
+- Compiles every pandas-style call to backend-native SQL (DuckDB / PostgreSQL / ClickHouse) and runs it in-engine — your data never leaves the database.
 - Async-first surface with sync equivalents for every operation.
 - Upload from CSV, Parquet, or pandas DataFrame.
 - Inspection, selection, cleaning, statistics, arithmetic, Plotly charts.

{memframe-0.2.0 → memframe-0.2.2}/README.md

@@ -10,12 +10,14 @@
 [![Tox](https://img.shields.io/github/actions/workflow/status/Debojit95/memFrame/tox.yml?label=tox)](https://github.com/Debojit95/memFrame/actions/workflows/tox.yml)
 [![License - AGPL-3.0](https://img.shields.io/github/license/Debojit95/memFrame)](https://github.com/Debojit95/memFrame/blob/main/LICENSE)
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/memframe)](https://pypi.org/project/memframe/)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1UtoPjzTmia4Cr6y2btDmV8mINgXaBPGP?usp=sharing)
 
 > *memFrame brings a pandas-like DataFrame API to DuckDB, PostgreSQL, and ClickHouse — async-first, with an optional AI agent for natural-language data work.*
 
 ## Features
 
 - Database-backed DataFrame API across DuckDB, PostgreSQL, and ClickHouse.
+- Compiles every pandas-style call to backend-native SQL (DuckDB / PostgreSQL / ClickHouse) and runs it in-engine — your data never leaves the database.
 - Async-first surface with sync equivalents for every operation.
 - Upload from CSV, Parquet, or pandas DataFrame.
 - Inspection, selection, cleaning, statistics, arithmetic, Plotly charts.

{memframe-0.2.0 → memframe-0.2.2}/docs/api/cleaning.md

@@ -46,10 +46,6 @@ Every cleaning operation has synchronous and asynchronous forms:
 | `isna()` | `await aisna()` | Boolean null mask |
 | `notna()` | `await anotna()` | Boolean non-null mask |
 | `drop_duplicates(subset=None, keep="first")` | `await adrop_duplicates(...)` | Remove duplicate rows |
-| `data_quality_missing_values(columns)` | `await adata_quality_missing_values(...)` | Missing-value counts |
-| `data_quality_completeness_score(columns)` | `await adata_quality_completeness_score(...)` | Completeness percentages |
-| `comprehensive_numeric_summary(columns)` | `await acomprehensive_numeric_summary(...)` | Numeric summary report |
-| `statistical_profile_report(columns)` | `await astatistical_profile_report(...)` | Combined profile report |
 
 Public methods return the operation value directly: usually a DataFrame, report
 dictionary, mask, or `None`. Invalid operations raise `OperationError`.
@@ -403,64 +399,6 @@ Parameters:
 | `subset` | `list[str]` or `None` | Columns used to identify duplicates. Defaults to all columns. |
 | `keep` | `"first"`, `"last"`, or `False` | Which duplicate row to keep. `False` keeps only rows with no duplicates. |
 
-## Data Quality Reports
-
-### `data_quality_missing_values`
-
-`data_quality_missing_values` returns per-column `total`, `non_null`,
-`missing`, and `missing_pct` values.
-
-```python
-result = dataset.data_quality_missing_values(
-    columns=["salary", "department"],
-)
-```
-
-```python
-result = await dataset.adata_quality_missing_values(
-    columns=["salary", "department"],
-)
-```
-
-### `data_quality_completeness_score`
-
-`data_quality_completeness_score` returns completeness percentages for each
-requested column.
-
-```python
-result = dataset.data_quality_completeness_score(columns=["salary"])
-```
-
-```python
-result = await dataset.adata_quality_completeness_score(columns=["salary"])
-```
-
-### `comprehensive_numeric_summary`
-
-`comprehensive_numeric_summary` generates numeric summaries for up to the first
-20 requested columns.
-
-```python
-result = dataset.comprehensive_numeric_summary(columns=["salary", "bonus"])
-```
-
-```python
-result = await dataset.acomprehensive_numeric_summary(columns=["salary", "bonus"])
-```
-
-### `statistical_profile_report`
-
-`statistical_profile_report` combines completeness scoring and numeric summary
-output into one response.
-
-```python
-result = dataset.statistical_profile_report(columns=["salary", "bonus"])
-```
-
-```python
-result = await dataset.astatistical_profile_report(columns=["salary", "bonus"])
-```
-
 ## Return Values and Errors
 
 Public cleaning methods return the underlying DataFrame, dictionary, mask, or
@@ -545,11 +483,3 @@ Cleaning methods raise `OperationError` for invalid input or backend failures.
         - notna
         - adrop_duplicates
         - drop_duplicates
-        - adata_quality_missing_values
-        - data_quality_missing_values
-        - adata_quality_completeness_score
-        - data_quality_completeness_score
-        - acomprehensive_numeric_summary
-        - comprehensive_numeric_summary
-        - astatistical_profile_report
-        - statistical_profile_report

{memframe-0.2.0 → memframe-0.2.2}/docs/api/inspect.md

@@ -38,24 +38,21 @@ Every inspect operation has synchronous and asynchronous forms:
 | `info()` | `await ainfo()` | Per-column table information |
 | `describe(columns=None)` | `await adescribe(...)` | Numeric descriptive statistics |
 | `null_analysis(columns=None)` | `await anull_analysis(...)` | Null distribution by column |
-| `corr(columns=None, method="pearson")` | `await acorr(...)` | Numeric correlation matrix |
+| `data_quality_missing_values(columns)` | `await adata_quality_missing_values(...)` | Missing-value counts |
+| `data_quality_completeness_score(columns)` | `await adata_quality_completeness_score(...)` | Completeness percentages |
+| `comprehensive_numeric_summary(columns)` | `await acomprehensive_numeric_summary(...)` | Numeric summary report |
+| `statistical_profile_report(columns)` | `await astatistical_profile_report(...)` | Combined profile report |
 | `full_table(columns=None, chunk_size=None)` | `await afull_table(...)` | Full table or chunk iterator |
 | `astype(columns=None, dtypes=None, dtype_map=None)` | `await aastype(...)` | Cast selected columns |
 | `insert(column, value)` | `await ainsert(...)` | Add a column from a value list |
 | `map(func, na_action=None, columns=None, datetime_action="skip")` | `await amap(...)` | Apply SQL expression to values |
 | `rename(columns)` | `await arename(...)` | Rename columns |
 | `set_index(columns)` | `await aset_index(...)` | Add a primary-key index |
-| `reset_index()` | `await areset_index()` | Recreate an `id` index column |
 | `update(on, other_table, other_schema="upload", overwrite=True, errors="ignore")` | `await aupdate(...)` | Update from another table |
 | `resample(time_column, rule, agg="COUNT", value_column=None, label="left", closed="left")` | `await aresample(...)` | Time-series aggregation |
-| `axes()` | `await aaxes()` | Row and column axes |
 | `columns()` | `await acolumns()` | Column labels |
 | `dtypes()` | `await adtypes()` | Column database types |
-| `first_valid_index()` | `await afirst_valid_index()` | First row with non-null values |
-| `memory_usage()` | `await amemory_usage()` | Backend table memory usage |
-| `ndim()` | `await andim()` | Number of dimensions |
 | `shape()` | `await ashape()` | Row and column count |
-| `size()` | `await asize()` | Total element count |
 | `values()` | `await avalues()` | Table values as nested lists |
 | `items()` | `await aitems()` | Column/value iterator result |
 | `iterrows()` | `await aiterrows()` | Row iterator result |
@@ -241,27 +238,64 @@ Parameters:
 The result DataFrame is indexed by column name when data is available and
 contains `contains_null` and `percent_missing` columns.
 
-### `corr`
 
-`corr` computes a numeric correlation matrix.
+## Data Quality Reports
+
+### `data_quality_missing_values`
+
+`data_quality_missing_values` returns per-column `total`, `non_null`,
+`missing`, and `missing_pct` values.
 
 ```python
-result = dataset.corr(columns=["amount", "score"])
+result = dataset.data_quality_missing_values(
+    columns=["salary", "department"],
+)
 ```
 
 ```python
-result = await dataset.acorr()
+result = await dataset.adata_quality_missing_values(
+    columns=["salary", "department"],
+)
 ```
 
-Parameters:
+### `data_quality_completeness_score`
 
-| Parameter | Type | Description |
-| --- | --- | --- |
-| `columns` | `list[str]`, `"*"`, or `None` | Numeric columns to include. Defaults to all numeric columns. |
-| `method` | `str` | Accepted by the wrapper. The current core implementation computes Pearson correlation with SQL `CORR`. |
+`data_quality_completeness_score` returns completeness percentages for each
+requested column.
+
+```python
+result = dataset.data_quality_completeness_score(columns=["salary"])
+```
+
+```python
+result = await dataset.adata_quality_completeness_score(columns=["salary"])
+```
+
+### `comprehensive_numeric_summary`
 
-At least two numeric columns are required. Metadata includes the analyzed
-columns and up to ten strong correlations.
+`comprehensive_numeric_summary` generates numeric summaries for up to the first
+20 requested columns.
+
+```python
+result = dataset.comprehensive_numeric_summary(columns=["salary", "bonus"])
+```
+
+```python
+result = await dataset.acomprehensive_numeric_summary(columns=["salary", "bonus"])
+```
+
+### `statistical_profile_report`
+
+`statistical_profile_report` combines completeness scoring and numeric summary
+output into one response.
+
+```python
+result = dataset.statistical_profile_report(columns=["salary", "bonus"])
+```
+
+```python
+result = await dataset.astatistical_profile_report(columns=["salary", "bonus"])
+```
 
 ## Table Utilities
 
@@ -388,19 +422,14 @@ Parameters:
 | --- | --- | --- |
 | `columns` | `dict[str, str]` | Mapping of old column names to new names. |
 
-### `set_index` and `reset_index`
+### `set_index`
 
-`set_index` adds a primary-key constraint over selected columns. `reset_index`
-recreates an `id` index column.
+`set_index` adds a primary-key constraint over selected columns.
 
 ```python
 result = dataset.set_index(columns=["customer_id"])
 ```
 
-```python
-result = await dataset.areset_index()
-```
-
 `set_index` parameters:
 
 | Parameter | Type | Description |
@@ -476,14 +505,9 @@ These methods return compact dictionary or list payloads directly:
 
 | Method | Async | Public result |
 | --- | --- | --- |
-| `axes()` | `aaxes()` | `[row_index, columns]` |
 | `columns()` | `acolumns()` | `[...]` |
 | `dtypes()` | `adtypes()` | `{column: db_type}` |
-| `first_valid_index()` | `afirst_valid_index()` | `{"first_valid_index": 0}` or `None` |
-| `memory_usage()` | `amemory_usage()` | `{"memory_bytes": value}` |
-| `ndim()` | `andim()` | `{"ndim": 2}` |
 | `shape()` | `ashape()` | `{"shape": (rows, columns)}` |
-| `size()` | `asize()` | `{"size": rows * columns}` |
 | `values()` | `avalues()` | `{"values": [[...], ...]}` |
 
 ```python
@@ -536,7 +560,7 @@ Failed operations raise `OperationError`.
 
 Some inspect methods create generated summary tables internally when method-call
 logging receives backend context. This is most visible for `info`, `describe`,
-`null_analysis`, and `corr`.
+`null_analysis`, and `sample`.
 
 Preview methods such as `head`, `tail`, `sample`, and unchunked `full_table`
 are read-oriented and return a DataFrame sample directly.
@@ -548,10 +572,9 @@ Inspect supports DuckDB and PostgreSQL adapters:
 - Both backends use quoted identifiers and schema-aware table names.
 - Schema discovery is delegated to the active database adapter.
 - `describe` uses backend-specific percentile functions.
-- `corr` uses SQL `CORR` over numeric columns.
 - `sample` uses backend `RANDOM()` ordering.
-- PostgreSQL can report relation memory usage; DuckDB currently returns `None`
-  for `memory_usage`.
+- PostgreSQL can report relation memory usage through `info`; DuckDB currently
+  returns `None` for `memory_usage`.
 - Column and table identifiers are sanitized before SQL is generated.
 
 ## Errors
@@ -560,14 +583,13 @@ Inspect methods raise `OperationError` for invalid input or backend failures.
 
 - Invalid `chunk_size` in `full_table` raises `OperationError`.
 - `describe` raises an error when no numeric columns are available.
-- `corr` raises an error when fewer than two numeric columns are available.
 - `astype` raises an error for missing columns or unsupported dtype aliases.
 - `astype` requires either `dtype_map` or matching `columns` and `dtypes`.
 - `insert` raises an error when `value` is not a list or its length does not
   match the row count.
 - `map` raises an error when `func` is not a SQL expression string or when no
   selected columns are compatible with the expression.
-- `rename`, `set_index`, `reset_index`, `update`, and `resample` can raise
+- `rename`, `set_index`, `update`, and `resample` can raise
   backend SQL errors when identifiers or constraints are invalid.
 
 ## API Reference
@@ -589,8 +611,6 @@ Inspect methods raise `OperationError` for invalid input or backend failures.
         - describe
         - anull_analysis
         - null_analysis
-        - acorr
-        - corr
         - afull_table
         - full_table
         - aastype
@@ -603,28 +623,16 @@ Inspect methods raise `OperationError` for invalid input or backend failures.
         - rename
         - aset_index
         - set_index
-        - areset_index
-        - reset_index
         - aupdate
         - update
         - aresample
         - resample
-        - aaxes
-        - axes
         - acolumns
         - columns
         - adtypes
         - dtypes
-        - afirst_valid_index
-        - first_valid_index
-        - amemory_usage
-        - memory_usage
-        - andim
-        - ndim
         - ashape
         - shape
-        - asize
-        - size
         - avalues
         - values
         - aitems