EZR.py: Toolkit & Easy Reads Overview

• EZR.py is a dual-purpose open-source Python project offering a compact toolkit for optimization tasks and a reformatting tool for improved paper readability.
• The toolkit employs minimal dependencies and a unified substrate to implement various AI methods, delivering competitive performance with significantly reduced code complexity.
• The Easy Reads component automates LaTeX source modifications to enhance accessibility by adjusting fonts, layout, and margins for reader-friendly documents.

Searching arXiv for the specified EZR.py-related papers to ground the article in current sources. EZR.py is the name of two distinct open-source Python programs described in arXiv preprints published in 2026. In one usage, EZR.py denotes a dependency-light toolkit for tabular software-engineering optimization tasks, implemented in approximately 400 lines and designed around a shared substrate for clustering, classification, regression, optimization, active learning, and text-mining (Menzies et al., 28 May 2026). In the other usage, EZR.py denotes “Easy Reads,” an end-to-end Python 3 program for fetching arXiv source files, reformatting LaTeX papers for larger fonts or single-column layout, and compiling a new PDF intended to be more reader-friendly and accessible (Verma, 18 Jun 2026). The shared name creates a nomenclature overlap; however, the two systems target different problem domains, employ different workflows, and embody different conceptions of software minimalism.

1. Nomenclature and scope

The term EZR.py is associated with two separate artifacts in the cited literature. The first is the EZR.py Toolkit, presented in “Can AI be Easy? Lessons Learned from the EZR.py Toolkit,” where it is defined as a Python toolkit for rows of $x$ and $y$ values in tabular software-engineering optimization tasks, with expensive-to-obtain $y$ values (Menzies et al., 28 May 2026). The second is EZR.py (“Easy Reads”), described as an open-source, end-to-end Python 3 program that automates fetching a source LaTeX paper from arXiv, re-formatting it for larger fonts or single-column layout, and compiling it to a new PDF (Verma, 18 Jun 2026).

The overlap is not merely lexical. In both cases, the software is positioned as compact, inspectable Python infrastructure that emphasizes direct manipulation of core representations rather than reliance on heavyweight stacks. This suggests a broader design motif: the acronym-like name “EZR” is used to signal simplification, but the simplification is directed at different targets. In the tabular-AI context, simplification concerns algorithmic substrate and implementation size. In the document-processing context, simplification concerns reading experience and command-line control over LaTeX formatting.

EZR.py usage	Domain	Core purpose
EZR.py Toolkit	Tabular software-engineering optimization	Implements Naive Bayes, $k$-means, trees, simulated annealing, local search, active learning, and complementary-Bayes text-mining
EZR.py (“Easy Reads”)	arXiv paper reformatting	Fetches arXiv source, changes formatting, and compiles a more reader-friendly PDF

2. EZR.py Toolkit: design goals and architectural substrate

In the toolkit sense, EZR.py was developed to test the hypothesis that many AI methods—clustering, classification, regression, optimization, active learning and even text-mining—share a common core and can be expressed in a few hundred lines of code without heavyweight dependencies (Menzies et al., 28 May 2026). The design goals are stated explicitly: minimal dependencies using only the Python standard library; compact code with all core functionality in 400 lines and functions averaging $5 \pm 4$ lines each; a unified substrate supporting all algorithms via four classes and one update primitive; readability and extensibility for human inspection, modification, and teaching; and competitive performance against SHAP, LIME, SMAC3, and FASTREAD while using less data, compute, and developer time.

The core substrate consists of four classes—Num, Sym, Data, and Cols—and a single update function, add. Num maintains streaming mean $\mu$, variance $m2$, and standard deviation $\sigma$ via Welford’s algorithm. Sym maintains symbol counts, mode, and entropy. Data stores rows plus summary columns and supports cloning. Cols acts as a factory for Num or Sym based on header conventions such as “+”, “–”, “X”, and “!”. All summary updates dispatch through add(obj, row_or_value, w=1), with w=-1 used for removal; for Data, cached centroids are invalidated and the update recurses (Menzies et al., 28 May 2026).

A 14-line CSV reader replaces pandas and coerces each cell to int, float, bool or str. The header conventions are central to the system’s compactness: columns ending in “+” or “–” mark goals, “!” marks class, “X” marks ignored columns, and uppercase initials denote Num while lowercase initials denote Sym. The paper argues that such conventions enable multiple learning and optimization procedures to collapse onto the same summaries and the same update mechanism. A plausible implication is that much of the implementation compression comes from moving variation out of model-specific data structures and into shared column semantics.

3. Algorithms implemented in the toolkit

The toolkit implements Naïve Bayes, $k$-means clustering, classification and regression trees, simulated annealing, local search, active learning, and complementary-Bayes text-mining relevance filtering (Menzies et al., 28 May 2026). The unifying claim is that these methods become “nearly the same once stripped back to their core,” with differences largely reduced to scoring functions and reuse of a shared substrate.

For Naïve Bayes, symbolic likelihood is defined as

$P(v\mid c)=\dfrac{\text{count}(v)+k\,P(c)}{N+k},$

while numeric likelihood uses a Gaussian PDF parameterized by streaming $y$0. The classification score is

$y$1

The code structure is summarized through like(col,v,prior) and likes(data,row,nr,nc), where the prior is computed as (|data.rows|+m)/(nr+m*nc).

For $y$2-means and $y$3-means++, distance combines numeric and symbolic differences using Aha’s heuristic via a Minkowski $y$4-norm with $y$5 for Euclidean distance:

$y$6

The clustering objective is

$y$7

The $y$8-means implementation initializes centroids randomly or via $y$9-means++, assigns each row to the nearest centroid through distx, and recomputes centroids via cached means or modes from mids(data). The $y$0-means++ seeding strategy uses weighted roulette-wheel selection through a single pick(ws) primitive, with probabilities proportional to squared distance from the nearest centroid.

Classification and regression trees are implemented in 43 lines. At each node, the selected column and cut minimize expected post-split uncertainty, where symbolic targets use entropy and numeric targets use standard deviation. The split score is

$y$1

Recursion stops when either side has fewer than leaf_min rows. Prediction traverses the cuts, and each leaf stores a Num or Sym distribution for the response.

Simulated annealing and local search are both presented as (1+1) search variants sharing the same oneplus1(...) loop and common mutation and acceptance functions. Simulated annealing uses

$y$2

whereas local search restarts from a random row if no improvement occurs in $y$3 steps. Mutations reuse pick(col, current), which is the same sampler used by $y$4-means++ and trees.

The active learning procedure, described as inspired by SMAC3 but using only two models, partitions labeled rows into “best” and “rest,” with “best” defined as the top $y$5 rows and “rest” as the remainder. The warm start labels $y$6 random rows, sorts them by disty, and splits them into best and rest. Then, for budget $y$7, each unlabeled row is scored by distx to best versus rest centroids; the top item is labeled and inserted with rebalancing performed in $y$8 row-swap operations. The paper states that no retraining of ensembles is required.

Complementary-Bayes text-mining, in approximately 30 lines, follows Rennie et al.’s complementary Naïve Bayes by updating counts for the non-relevant class and classifying by least-complement likelihood. It is integrated into the same acquire loop used for active learning. This suggests that the toolkit treats document selection as structurally analogous to expensive-label acquisition in tabular optimization.

4. Evaluation on MOOT and empirical claims

The evaluation is conducted on 124 multi-objective tabular software-engineering tasks from the MOOT repository, drawn from ICSE, FSE, TSE, IST, EMSE, TOSEM, and ASE papers and spanning configuration tuning, defect prediction, test selection, performance tuning, project management, and related tasks (Menzies et al., 28 May 2026). Each task has $y$9 features and $k$0 expensive goals.

The reported metrics include normalized regret (“wins”),

$k$1

with clamping at $k$2, together with w1 and w2 scores for training and hold-out halves, and Recall@k and false-alarm@k for text mining. Within this benchmark setting, several headline results are reported.

On 20 random MOOT tasks with budget = 1000 oracle calls, simulated annealing without restart achieves mean win approximately $k$3–$k$4, whereas local search without restart collapses to $k$5 and exhibits high variance; local search with restart recovers but does not beat simulated annealing. The stated conclusion is that simulated annealing, described as a 1983 default, still dominates 1990s local-search variants plus restart.

For active learning, the toolkit reportedly reaches $k$6–$k$7 of reference optimum with fewer than 100 labels and uses fewer than 10 features even when $k$8; model construction occurs in seconds rather than the hours reported for SMAC3, yielding a 500$k$9 speedup. The default configuration, budget = 50 and check = 5, is described as lying near the “knee” of the performance curve, with additional budget producing only marginal gains.

Plain regression trees trained on labels selected by the active learner are reported to match or exceed SHAP, LIME, and ReliefF on actionability and faithfulness while using one-tenth the labels. Complementary Bayes combined with active learning is reported to match Yu et al.’s FASTREAD recall of $5 \pm 4$0 with 100–150 labels rather than 300–600, while also reporting false-alarm curves that expose a harmful normalization step recommended by Rennie et al. The paper further states that the toolkit performs as well as or better than state-of-the-art explanation tools, the SMAC3 optimizer, and SVM-based text-mining filters, while using far less labeled data and compute.

These results are interpreted in the paper as evidence that benchmarking against minimal baselines is necessary to avoid unearned complexity. A plausible implication is that the primary contribution is methodological as much as algorithmic: the toolkit is positioned not only as a software artifact but also as an argument for refactoring and comparative reduction as a research practice.

5. Easy Reads EZR.py: document reformatting workflow

In the Easy Reads usage, EZR.py is an automated program for making scientific papers on arXiv more reader-friendly and accessible by changing paper features such as font size and the number of columns used (Verma, 18 Jun 2026). The primary goal is to facilitate ease of reading, with stated motivations including reduction of eye strain during screen reading and production of printer-friendly versions with more white space.

The core workflow is implemented in main_easy_reads.py. The program parses command-line arguments including --url, --font-size, --single-column, --single-column-margin, --baseline, and --output-suffix. It constructs an arXiv source URL by replacing /abs/ with /src/, downloads the .tar.gz archive into Downloads/, and unpacks it with Python’s tarfile module. It then recursively scans the extracted folder for the “main” .tex file, typically identified as the one containing \maketitle.

The LaTeX source is read into memory and modified by rewriting the \documentclass[...] line to use the requested font size, for example \documentclass[14pt]{article}. The system also inserts or updates packages and directives for geometry, line spacing, and column mode, including \usepackage[margin=<MARGIN>in]{geometry}, either setspace or \renewcommand{\baselinestretch}{<LINE_SPACING>}, and \onecolumn or \twocolumn. Compilation is then performed with pdflatex, or optionally latexmk, via subprocess, with two runs for cross-references. The output PDF is written into Formatted Papers/ and renamed by appending a suffix such as _formatted.

The feature set includes font-size adjustment with default 12 pt and user-specified values between, for example, 10–26 pt; preservation of the original column format or conversion to single-column layout; automatic margin and line-spacing calculation with baseline spacing defaulting to $5 \pm 4$1 font size; figure handling in which figures remain in the same order but reflow within new margins or column layout; and output naming by suffixing the filename. The paper’s end-to-end example describes the transformation of https://arxiv.org/abs/([2001.00001](/papers/2001.00001)) into a single-column, 14 pt reformatted document, with source download, extraction, preamble rewriting, two pdflatex runs, and final placement into Formatted Papers/.

The software architecture is comparatively conventional relative to the tabular-AI EZR.py. Its simplification lies less in a mathematical substrate and more in deterministic source transformation: locate source, patch preamble, compile, and rename. This suggests that the “easy” in Easy Reads concerns operational convenience and reading ergonomics rather than algorithmic unification.

6. Installation, usage conventions, limitations, and significance

The toolkit EZR.py is available under an open-source license and is installable via pip install ezr, with example data hosted at github.com/timm/moot (Menzies et al., 28 May 2026). Usage examples include: $5 \pm 4$2 and $5 \pm 4$3 Its data conventions are encoded in headers: independent columns carry no suffix, goals use “+” or “–”, class uses “!”, ignored fields use “X”, and numeric versus symbolic typing is inferred from capitalization.

Easy Reads EZR.py requires Python 3.6+, a LaTeX distribution in the system PATH, and Python dependencies including requests, tarfile, argparse, pathlib, and subprocess (Verma, 18 Jun 2026). Setup is performed by cloning the repository, optionally creating a virtual environment, installing requests, ensuring pdflatex or latexmk is accessible, and verifying the presence or creation of main_easy_reads.py, Downloads/, and Formatted Papers/. The CLI supports usage patterns such as default reformatting, larger font size, single-column conversion, custom margins, and custom output suffixes.

The documented limitations of Easy Reads include incomplete compatibility with journal-specific class files or custom macros, the possibility that figures and tables may overflow under extreme font changes, and the need for extra LaTeX runs or manual patching with bibliography packages such as BibLaTeX. Customization options include editing variables in the program’s “settings” block, inserting a user style file via \input{mycustom.sty}, and adjusting line spacing, column separation, or graphic scaling through custom LaTeX snippets. Proposed future extensions include finer control over heading, abstract, and caption fonts; automatic figure or table resizing or reflow; support for ePub or HTML; integration with arXiv API metadata and PDF fallback; and an interactive GUI or web front end.

Across both meanings of EZR.py, a common significance emerges. One system argues that many learning algorithms can be reduced to a compact, unified substrate without loss of competitiveness on a defined benchmark suite. The other argues that dense arXiv typography can be programmatically transformed into more readable output without altering scientific content. The name therefore denotes two distinct strands of 2026 Python software practice: reduction of algorithmic complexity in tabular software-engineering AI, and reduction of presentation friction in scholarly reading.