goad-toolkit 0.2.0__tar.gz → 0.2.2__tar.gz

goad_toolkit-0.2.2/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cd /Users/rgrouls/code/courses/goad_toolkit && cat pyproject.toml)"
+    ]
+  }
+}

goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+## 0.2.1
+
+### Breaking
+
+- **`FileConfig` gained `date_column` and `date_index`.** `FileHandler.load` reads csv and
+  parquet (reader picked from the suffix), parses `date_column` as dates and, when
+  `date_index` is true, moves it into the index. The defaults (`"date"`, `True`) keep the
+  covid pipeline working unchanged, but a `FileConfig` subclass that overrode `load` to
+  support another shape can now express it as configuration instead. A file whose suffix has
+  no reader, or a `date_column` that is not in the frame, raises `ValueError`. Parquet needs
+  `pyarrow`, available as the `parquet` extra.
+- **`DistributionRegistry` is a normal class.** Constructing one no longer returns a shared
+  process-wide instance, so a registration affects only the registry it was made on. Code
+  that registered a family on one registry and relied on a separately constructed
+  `DistributionFitter()` picking it up must now pass it: `DistributionFitter(registry)`.
+
+### Added
+
+- `goad` console script: fits every family in the registry to one column of a csv or parquet
+  file and prints the fits ranked by log-likelihood (`goad data/residuals.csv residual`).
+- `DistributionFitter` accepts an optional `DistributionRegistry`.
+- `filehandler.reader_for`, `filehandler.write_frame` and `filehandler.parse_dates` as
+  reusable pieces; `FileHandler.save` writes parquet as well as csv.
+- A pytest suite under `tests/`.
+
+### Fixed
+
+- `BarWithDates.build` and `VerticalDate.build` return `(fig, ax)` like every other `build`.
+- Plots draw on `self.ax` / `self.fig` instead of module-level `plt` calls, so a layer placed
+  with `plot_on_axes` lands on the axis it was handed rather than on matplotlib's current one.
+- The `goad` console script points at a module that exists.
+
+### Changed
+
+- `__version__` is read from the installed package metadata.

goad_toolkit-0.2.0/PKG-INFO → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511/README.md

@@ -1,21 +1,3 @@
-Metadata-Version: 2.4
-Name: goad-toolkit
-Version: 0.2.0
-Summary: An extensible toolkit for Goal Oriented Analysis of Data
-Project-URL: Github, https://github.com/raoulg/goad_toolkit
-Author-email: raoul grouls <Raoul.Grouls@han.nl>
-Requires-Python: >=3.12
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: matplotlib>=3.10.1
-Requires-Dist: numpy>=2.2.4
-Requires-Dist: pandas>=2.2.3
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: requests>=2.32.3
-Requires-Dist: scipy>=1.15.2
-Requires-Dist: seaborn>=0.13.2
-Requires-Dist: tqdm>=4.67.1
-Description-Content-Type: text/markdown
-
 # GOAD🐐 is the GOAT - Goal Oriented Analysis of Data
 [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
 [![image](https://shields.io/pypi/v/goad_toolkit.svg)](https://pypi.org/project/goad_toolkit/)
@@ -61,6 +43,23 @@ Or, if you prefer your dependencies to be installed 100x slower, with pip:
 pip install goad-toolkit
 ```
 
+Add the `parquet` extra if you want to read and write parquet files:
+```bash
+uv add "goad-toolkit[parquet]"
+```
+
+### Command line
+
+The install ships a `goad` command that fits every distribution in the registry to one column
+of a csv or parquet file and prints the fits, ranked by log-likelihood:
+
+```bash
+goad data/residuals.csv residual
+```
+
+Use `--discrete` for count data, `--criterion {likelihood,ks,combined}` to pick which fits are
+marked best, and `goad --help` for the rest.
+
 ## 📋 Demo: Linear Model Analysis
 
 GOAD🐐 includes a comprehensive [demo](demo/linear.py) that shows how to use its components together.
@@ -147,7 +146,7 @@ class ComparePlot(BasePlot):
         compare = LinePlot(self.settings)
         self.plot_on(compare, data=data, x=x, y=y1, label=y1, **kwargs)
         self.plot_on(compare, data=data, x=x, y=y2, label=y2, **kwargs)
-        plt.xticks(rotation=45)
+        self.ax.tick_params(axis="x", rotation=45)
 
         return self.fig, self.ax
 
@@ -203,12 +202,15 @@ registry.register_distribution(
     num_params=2
 )
 
-# Now it will be used automatically in the  DistributionFitter for discrete fits
+# Hand the registry to the fitter to use your families
 from goad_toolkit.analytics import DistributionFitter
-fitter = DistributionFitter()
+fitter = DistributionFitter(registry)
 print(fitter.registry) # shows all registered distributions
 ```
 
+Registrations belong to the registry you made them on, so a fitter built without one
+(`DistributionFitter()`) uses a fresh registry with only the shipped families.
+
 
 
 ## 🔧 Advanced Usage: Composing Plots

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/docs/02-pipelines.md

@@ -175,6 +175,16 @@ data = processor.process(save=True)   # and writes the result to data/processed/
 Subclasses implement exactly one method: `config_pipeline`. Everything else — the download,
 the directory creation, the raw/processed split, the save — is inherited.
 
+`FileConfig` also says how the file is read: the reader follows the suffix (`.csv` or
+`.parquet`), `date_column` names the column to parse as dates, and `date_index` decides
+whether it becomes the index. For a dataset without a time axis, set `date_column=None`.
+
+```python
+config = FileConfig(
+    data_dir=Path("data"), filename=Path("sales.parquet"), date_column="ordered_at"
+)
+```
+
 The pipeline's parameters come from a pydantic `DataConfig`, which means the tuning knobs of
 your analysis (the shift period, the smoothing window, the date range) live in one typed
 object rather than scattered as literals through the steps. When somebody asks "what happens

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/docs/03-plot-composition.md

@@ -98,7 +98,7 @@ class ComparePlot(BasePlot):
         line = LinePlot(self.settings)
         self.plot_on(line, data=data, x=x, y=y1, label=y1, **kwargs)
         self.plot_on(line, data=data, x=x, y=y2, label=y2, **kwargs)
-        plt.xticks(rotation=45)
+        self.ax.tick_params(axis="x", rotation=45)
         return self.fig, self.ax
 ```
 
@@ -113,7 +113,7 @@ class ResidualPlot(BasePlot):
     def build(self, data, x, y, date, datelabel, interval=1):
         self.plot_on(BarWithDates(self.settings), data=data, x=x, y=y, interval=interval)
         self.plot_on(VerticalDate(self.settings), date=date, label=datelabel)
-        plt.xticks(rotation=45)
+        self.ax.tick_params(axis="x", rotation=45)
         return self.fig, self.ax
 ```
 
@@ -205,17 +205,20 @@ scatter.plot_on(TrendLine(settings), data=df, x="weight", y="mpg", order=2)
 Grey data, one coloured layer carrying the message. That is guideline five, expressed as two
 lines of code.
 
-## 3.8 Known rough edges
-
-- `BarWithDates` and `VerticalDate` do not return `(fig, ax)` from `build`. Everything else
-  does. Do not rely on their return value.
-- `VerticalDate` and several compositions call `plt.*` module-level functions rather than
-  methods on `self.ax`, which means they act on matplotlib's *current* axes. Inside a
-  `plot_on` chain that is the axis you want; in a multi-panel figure built by hand it may not
-  be. When in doubt, use `plot_on_axes` and draw on the axis you were handed.
-- `PlotFits` overrides `plot` rather than `build`, because it needs to know how many panels
-  to create before the figure exists. Its `build` is a no-op. It is the exception, not a
-  pattern to copy.
+## 3.8 Two rules that keep compositions composable
+
+- **`build` returns `(self.fig, self.ax)`.** Every shipped plot does, layers included, so a
+  caller can keep working with the figure whichever piece it got back. Yours should too.
+- **Draw on `self.ax` and `self.fig`, never on `plt`.** Module-level calls like
+  `plt.xticks(...)` or `plt.axvline(...)` act on matplotlib's *current* axes, which is not
+  necessarily the axis your plot was handed — in a multi-panel figure it is usually the wrong
+  one. The explicit forms are `self.ax.tick_params(axis="x", rotation=45)`,
+  `self.ax.axvline(...)`, `self.fig.suptitle(...)`. Keeping to them is what makes
+  `plot_on_axes` reliable.
+
+`PlotFits` overrides `plot` rather than `build`, because it needs to know how many panels to
+create before the figure exists. Its `build` is a no-op. It is the exception, not a pattern to
+copy.
 
 ---
 

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/docs/05-distributions.md

@@ -45,11 +45,17 @@ Two things to know before you rely on it:
 
 - **`num_params` must be right.** It selects the bounds template the fitter builds (see §5.3),
   so a wrong count produces a confusing optimisation failure rather than a clear error.
-- **The registry is a process-wide singleton.** `DistributionRegistry()` returns the same
-  object every time, and `__init__` is a no-op after the first call. So a registration in one
-  cell affects every later fit in the session, and re-running the registration cell does
-  nothing surprising but also does not reset anything. If you need a clean slate, restart the
-  kernel.
+- **Registrations are scoped to the registry object.** Every `DistributionRegistry()` starts
+  from the shipped families, so a registration in one cell affects only the fits that use that
+  registry, and a fresh instance is your clean slate — no kernel restart needed. Pass the
+  registry you extended to the fitter:
+
+  ```python
+  fitter = DistributionFitter(registry)
+  ```
+
+  `DistributionFitter()` without an argument builds its own registry with the shipped
+  families.
 
 ## 5.3 `DistributionFitter`
 

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/docs/08-api-reference.md

@@ -14,6 +14,8 @@ class FileConfig(BaseModel):
     data_dir: Path = Path.home() / ".cache/mads_datasets/covid"
     filename: Path = Path("covid.csv")
     url: str = "https://raw.githubusercontent.com/mzelst/covid-19/master/data/rivm_by_day.csv"
+    date_column: Optional[str] = "date"
+    date_index: bool = True
 
 class DataConfig(BaseModel):
     period: int = -14
@@ -22,6 +24,9 @@ class DataConfig(BaseModel):
     end_date: str = "2021-06-01"
 ```
 
+`date_column` names the column parsed as dates; `None` for data without a time axis.
+`date_index` decides whether that column becomes the index.
+
 `DataConfig` holds the tuning knobs a pipeline reads. Subclass it for your own analysis
 rather than passing loose numbers into `Pipeline.add`.
 
@@ -30,6 +35,13 @@ rather than passing loose numbers into `Pipeline.add`.
 ## 8.2 `goad_toolkit.filehandler`
 
 ```python
+READERS: dict[str, Callable[[Path], pd.DataFrame]]      # ".csv", ".parquet"
+
+def reader_for(path: Path) -> Callable[[Path], pd.DataFrame]
+def write_frame(data: pd.DataFrame, path: Path) -> None
+def parse_dates(data: pd.DataFrame, date_column: Optional[str],
+                as_index: bool) -> pd.DataFrame
+
 class FileHandler:
     def __init__(self, config: FileConfig)
     def download(self, filename: Optional[Path] = None) -> None
@@ -41,8 +53,13 @@ class FileHandler:
 - Creates `data_dir`, `data_dir/raw` and `data_dir/processed` on construction.
 - `load(raw=True)` reads from `raw/` and downloads first if the file is missing;
   `load(raw=False)` reads from `processed/`.
-- **`load` currently assumes a CSV with a `date` column, parsed as dates and used as the
-  index.** Other shapes need a subclass overriding `load`.
+- The reader and writer follow the file suffix: `.csv` and `.parquet`. Anything else raises a
+  `ValueError` naming the supported suffixes. Parquet needs `pyarrow`, installed with the
+  `parquet` extra: `uv add "goad-toolkit[parquet]"`.
+- Date handling follows `FileConfig`: `date_column` is parsed as dates and, when
+  `date_index` is true, moved into the index. A frame whose dates already *are* the index is
+  accepted too, so a `save` → `load` round trip keeps its shape. A missing `date_column`
+  raises a `ValueError` listing the columns that are there.
 
 ---
 
@@ -109,7 +126,7 @@ class Distribution:
     is_discrete: bool
     num_params: int
 
-class DistributionRegistry:     # process-wide singleton
+class DistributionRegistry:
     def register_distribution(self, name: str, dist, is_discrete: bool, num_params: int)
     def get_distribution(self, name: str) -> Distribution
     def get_names(self) -> List[str]
@@ -117,7 +134,8 @@ class DistributionRegistry:     # process-wide singleton
 ```
 
 Registered by default: `norm`, `uniform`, `lognorm`, `poisson`, `exponential`, `skewnorm`,
-`gamma`, `weibull`.
+`gamma`, `weibull`. Every instance starts from that set, so a registration is scoped to the
+registry you made it on — hand that registry to `DistributionFitter(registry)` to use it.
 
 ---
 
@@ -156,7 +174,9 @@ Result = Union[FitResult, FailedFit]
 
 ```python
 class DistributionFitter:
-    registry: list[str]                                     # property
+    def __init__(self, registry: Optional[DistributionRegistry] = None)
+
+    registry: list[str]                                     # property, the names
 
     def fit(self, data: np.ndarray, discrete: bool,
             method: str = "mle",
@@ -255,24 +275,46 @@ class PlotFits(BasePlot):
              fitplotsettings: FitPlotSettings) -> Figure
 ```
 
+Every `build` returns `(self.fig, self.ax)`, and every plot draws on `self.ax` / `self.fig`
+rather than on matplotlib's current axes, so a layer placed with `plot_on_axes` lands on the
+axis it was handed.
+
 `PlotFits` overrides `plot` rather than `build`, because the panel count depends on the fit
 results. `HistogramPlot` uses `stat="density"` so a pdf overlays correctly; `DistPlot` takes a
 **frozen** distribution and falls back to `pmf` when there is no `pdf`.
 
 ---
 
-## 8.9 Rough edges worth knowing
-
-- `BarWithDates.build` and `VerticalDate.build` return `None`; every other `build` returns
-  `(fig, ax)`.
-- Several plots call module-level `plt.*` functions, which act on matplotlib's current axes
-  rather than `self.ax`. Inside a `plot_on` chain this is the axis you want; when composing
-  panels by hand, prefer `plot_on_axes`.
-- `DistributionRegistry` is a process-wide singleton — registrations persist for the life of
-  the session and cannot be undone without a restart.
-- `FileHandler.load` hardcodes CSV with a `date` index column.
-- `pyproject.toml` declares a console script `goad = "goad:main"`; there is no such module in
-  the package.
+## 8.9 `goad_toolkit.cli`
+
+The `goad` console script fits every family in the registry to one column and prints the fits
+ranked by log-likelihood.
+
+```bash
+goad data/residuals.parquet residual
+goad data/counts.csv events --discrete --criterion ks
+```
+
+```python
+def parse_args(argv: List[str] | None = None) -> argparse.Namespace
+def load_column(file: Path, column: str) -> np.ndarray    # dropna, as an array
+def format_results(results: List[Result]) -> str
+def main(argv: List[str] | None = None) -> None
+```
+
+`--discrete` fits the discrete families instead of the continuous ones; `--criterion` is one
+of `likelihood`, `ks`, `combined`; `--method` is passed to `scipy.stats.fit`.
+
+---
+
+## 8.10 Rough edges worth knowing
+
+- `PlotFits` overrides `plot` rather than `build`; its `build` is a no-op. It is the one
+  exception to the `build` contract.
+- Fits that fail come back as `FailedFit` values in the result list rather than raising, so
+  a list of results can contain both kinds and needs an `isinstance` check.
+- `Pipeline.apply` copies the frame once and then mutates that copy in place, so transforms
+  see each other's columns — the order you add steps in matters.
 
 ---
 

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/docs/README.md

@@ -83,7 +83,8 @@ src/goad_toolkit/
 ├── distributions.py    # Distribution, DistributionRegistry
 ├── analytics.py        # DistributionFitter, FitResult, FailedFit, KSTestResult
 ├── models.py           # linear_model, logistic, mse, train_model
-└── visualizer.py       # PlotSettings + BasePlot and its subclasses, PlotFits
+├── visualizer.py       # PlotSettings + BasePlot and its subclasses, PlotFits
+└── cli.py              # the `goad` command: fit the registry to one column
 ```
 
 Plus, outside the package:

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "goad-toolkit"
-version = "0.2.0"
+version = "0.2.1"
 description = "An extensible toolkit for Goal Oriented Analysis of Data"
 readme = "README.md"
 authors = [
@@ -20,8 +20,11 @@ dependencies = [
 ]
 urls = {Github = "https://github.com/raoulg/goad_toolkit"}
 
+[project.optional-dependencies]
+parquet = ["pyarrow>=19.0.0"]
+
 [project.scripts]
-goad = "goad:main"
+goad = "goad_toolkit.cli:main"
 
 [build-system]
 requires = ["hatchling"]
@@ -31,8 +34,15 @@ build-backend = "hatchling.build"
 dev = [
     "isort>=6.0.1",
     "jupyter>=1.1.1",
+    "pyarrow>=19.0.0",
     "pyright>=1.1.397",
+    "pytest>=8.3.5",
     "ruff>=0.11.0",
 ]
 [tool.ruff.lint]
 select = ["E4", "E7", "E9", "F", "N", "C4", "DTZ", "PT", "S"]
+
+[tool.ruff.lint.per-file-ignores]
+# assert is the assertion mechanism in tests and the demo script
+"tests/**" = ["S101"]
+"demo/**" = ["S101"]

goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511/src/goad_toolkit/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("goad-toolkit")
+except PackageNotFoundError:  # source tree without an installed distribution
+    __version__ = "unknown"

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/src/goad_toolkit/analytics.py

@@ -75,9 +75,13 @@ Result = Union[FitResult, FailedFit]
 class DistributionFitter:
     """Class to fit distributions from a registry to data."""
 
-    def __init__(self) -> None:
-        """Initialize with a distribution registry."""
-        self._registry = DistributionRegistry()
+    def __init__(self, registry: Optional[DistributionRegistry] = None) -> None:
+        """Initialize with a distribution registry.
+
+        Pass a registry to fit a custom set of families; a fresh registry with
+        the shipped families is used otherwise.
+        """
+        self._registry = registry if registry is not None else DistributionRegistry()
 
     @property
     def registry(self) -> list[str]:

goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511/src/goad_toolkit/cli.py

@@ -0,0 +1,92 @@
+"""Command line entry point: fit the distribution registry to one column."""
+
+import argparse
+from pathlib import Path
+from typing import List
+
+import numpy as np
+
+from goad_toolkit.analytics import DistributionFitter, FitResult, Result
+from goad_toolkit.filehandler import reader_for
+
+
+def parse_args(argv: List[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="goad",
+        description=(
+            "Fit every distribution in the registry to one column of a csv or "
+            "parquet file and print the fits, ranked by log-likelihood."
+        ),
+    )
+    parser.add_argument("file", type=Path, help="path to a .csv or .parquet file")
+    parser.add_argument("column", help="name of the column to fit")
+    parser.add_argument(
+        "--discrete",
+        action="store_true",
+        help="fit the discrete families instead of the continuous ones",
+    )
+    parser.add_argument(
+        "--criterion",
+        default="combined",
+        choices=["likelihood", "ks", "combined"],
+        help="which fits to mark as best (default: combined)",
+    )
+    parser.add_argument(
+        "--method", default="mle", help="scipy fitting method (default: mle)"
+    )
+    return parser.parse_args(argv)
+
+
+def load_column(file: Path, column: str) -> np.ndarray:
+    """Read one column and return it as a float array without missing values."""
+    if not file.exists():
+        raise SystemExit(f"No such file: {file}")
+    data = reader_for(file)(file)
+    if column not in data.columns:
+        raise SystemExit(
+            f"Column '{column}' not found. Available: {list(data.columns)}"
+        )
+    return data[column].dropna().to_numpy()
+
+
+def format_results(results: List[Result]) -> str:
+    """Render fits as a table, best log-likelihood first, failures last."""
+    successes = [fit for fit in results if isinstance(fit, FitResult)]
+    failures = [fit for fit in results if not isinstance(fit, FitResult)]
+    successes.sort(
+        key=lambda fit: fit.log_likelihood
+        if fit.log_likelihood is not None
+        else -np.inf,
+        reverse=True,
+    )
+
+    header = f"{'distribution':<14}{'loglik':>14}{'ks p':>10}  best"
+    lines = [header, "-" * len(header)]
+    for fit in successes:
+        loglik = "n/a" if fit.log_likelihood is None else f"{fit.log_likelihood:.2f}"
+        ks = "n/a" if fit.kstest is None else f"{fit.kstest.p_value:.4f}"
+        marks = []
+        if fit.best_likelihood:
+            marks.append("likelihood")
+        if fit.best_ks:
+            marks.append("ks")
+        row = f"{fit.distribution:<14}{loglik:>14}{ks:>10}  {', '.join(marks)}"
+        lines.append(row.rstrip())
+    for fit in failures:
+        lines.append(f"{fit.distribution:<14}{'failed: ' + fit.message}")
+    return "\n".join(lines)
+
+
+def main(argv: List[str] | None = None) -> None:
+    args = parse_args(argv)
+    values = load_column(args.file, args.column)
+    fitter = DistributionFitter()
+    results = fitter.fit(
+        values, discrete=args.discrete, method=args.method, criterion=args.criterion
+    )
+    print(f"\n{len(values)} values from {args.file}:{args.column}\n")
+    print(format_results(results))
+
+
+if __name__ == "__main__":
+    main()

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/src/goad_toolkit/config.py

@@ -1,17 +1,31 @@
 from pathlib import Path
+from typing import Optional
 
 from pydantic import BaseModel
 
 
 class FileConfig(BaseModel):
+    """Where the data lives and how to read it.
+
+    `date_column` names the column to parse as dates; set it to None for data
+    without a time axis. `date_index` decides whether that column becomes the
+    index. The reader is picked from the file suffix (`.csv`, `.parquet`).
+    """
+
     data_dir: Path = Path.home() / ".cache/mads_datasets/covid"
     filename: Path = Path("covid.csv")
     url: str = (
         "https://raw.githubusercontent.com/mzelst/covid-19/master/data/rivm_by_day.csv"
     )
+    date_column: Optional[str] = "date"
+    date_index: bool = True
 
     def __repr__(self):
-        return f"FileConfig(data_dir={self.data_dir},\n filename={self.filename},\nurl={self.url})"
+        return (
+            f"FileConfig(data_dir={self.data_dir},\n filename={self.filename},\n"
+            f"url={self.url},\n date_column={self.date_column},\n"
+            f" date_index={self.date_index})"
+        )
 
 
 class DataConfig(BaseModel):

{goad_toolkit-0.2.0 → goad_toolkit-0.2.2/.claude/worktrees/quizzical-solomon-b62511}/src/goad_toolkit/distributions.py

@@ -22,48 +22,38 @@ class Distribution:
         return f"Distribution(name='{self.name}',\n dist={self.dist.__class__.__name__},\n is_discrete={self.is_discrete},\n num_params={self.num_params})"
 
 
-@dataclass
 class DistributionRegistry:
-    """Registry for statistical distributions with metadata."""
-
-    _instance = None
+    """Registry for statistical distributions with metadata.
 
-    def __new__(cls):
-        """Ensure only one instance of DistributionRegistry exists."""
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance.initialized = False
-        return cls._instance
+    Every instance starts from the shipped set of families, so registrations
+    are scoped to the registry you registered them on.
+    """
 
     def __init__(self):
         """Initialize the registry with common distributions."""
-        if not self.initialized:
-            self.distributions: Dict[str, Distribution] = {}
-            self.register_distribution(
-                "norm", stats.norm, is_discrete=False, num_params=2
-            )
-            self.register_distribution(
-                "uniform", stats.uniform, is_discrete=False, num_params=2
-            )
-            self.register_distribution(
-                "lognorm", stats.lognorm, is_discrete=False, num_params=3
-            )
-            self.register_distribution(
-                "poisson", stats.poisson, is_discrete=True, num_params=1
-            )
-            self.register_distribution(
-                "exponential", stats.expon, is_discrete=False, num_params=2
-            )
-            self.register_distribution(
-                "skewnorm", stats.skewnorm, is_discrete=False, num_params=3
-            )
-            self.register_distribution(
-                "gamma", stats.gamma, is_discrete=False, num_params=3
-            )
-            self.register_distribution(
-                "weibull", stats.weibull_min, is_discrete=False, num_params=3
-            )
-            self.initialized = True
+        self.distributions: Dict[str, Distribution] = {}
+        self.register_distribution("norm", stats.norm, is_discrete=False, num_params=2)
+        self.register_distribution(
+            "uniform", stats.uniform, is_discrete=False, num_params=2
+        )
+        self.register_distribution(
+            "lognorm", stats.lognorm, is_discrete=False, num_params=3
+        )
+        self.register_distribution(
+            "poisson", stats.poisson, is_discrete=True, num_params=1
+        )
+        self.register_distribution(
+            "exponential", stats.expon, is_discrete=False, num_params=2
+        )
+        self.register_distribution(
+            "skewnorm", stats.skewnorm, is_discrete=False, num_params=3
+        )
+        self.register_distribution(
+            "gamma", stats.gamma, is_discrete=False, num_params=3
+        )
+        self.register_distribution(
+            "weibull", stats.weibull_min, is_discrete=False, num_params=3
+        )
 
     def __repr__(self) -> str:
         """Detailed representation of the registry."""