distparser 0.2.0__tar.gz

distparser-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juyoung Choi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

distparser-0.2.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: distparser
+Version: 0.2.0
+Summary: Parse function-call strings into frozen scipy.stats distributions
+Author-email: Juyoung Choi <njuyoung35@gmail.com>
+Maintainer-email: Juyoung Choi <njuyoung35@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/njuyoung35/distparser
+Project-URL: Repository, https://github.com/njuyoung35/distparser
+Project-URL: Documentation, https://distparser.readthedocs.io
+Keywords: scipy,distribution,parsing,rvs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-rtd-theme>=2.0.0; extra == "docs"
+Requires-Dist: pymdown-extensions>=10.0; extra == "docs"
+Dynamic: license-file
+
+# distparser
+
+**Parse function‑call syntax strings into frozen `scipy.stats` distributions**
+
+[![PyPI version](https://badge.fury.io/py/distparser.svg)](https://badge.fury.io/py/distparser)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why `distparser`?
+
+When you have configuration files or user input that specifies a probability
+distribution (e.g. `"norm(loc=0, scale=1)"`), you want to turn that string
+into a ready‑to‑sample object. `distparser` does exactly that, with a tiny
+API and zero surprises.
+
+## Installation
+
+```bash
+pip install distparser
+```
+
+## Quick Start
+
+```
+from distparser import parse_dist
+
+# Positional arguments (order matters)
+dist = parse_dist("uniform(0, 1)")
+sample = dist.rvs()          # e.g. 0.374
+
+# Keyword arguments (order ignored)
+dist = parse_dist("norm(loc=0, scale=1)")
+samples = dist.rvs(size=5)   # array([-0.12, 1.03, ...])
+
+# Mixed (positional + keyword) – works, but not recommended
+dist = parse_dist("expon(scale=2, loc=1)")
+```
+
+## Supported Distributions
+
+Built‑in registry covers the most common continuous distributions:
+
+- `uniform(loc, scale)`
+- `norm(loc, scale)`
+- `expon(loc, scale)`
+- … and many more (see [docs](https://distparser.readthedocs.io)).
+
+You can **add your own** at runtime:
+
+```python
+from distparser import register_distribution
+from scipy.stats import gumbel_r
+
+register_distribution("gumbel", gumbel_r, ["loc", "scale"])
+```
+
+## Development
+
+See [AGENTS.md](AGENTS.md) for development setup and guidelines.
+
+## License
+
+MIT

distparser-0.2.0/README.md

@@ -0,0 +1,63 @@
+# distparser
+
+**Parse function‑call syntax strings into frozen `scipy.stats` distributions**
+
+[![PyPI version](https://badge.fury.io/py/distparser.svg)](https://badge.fury.io/py/distparser)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why `distparser`?
+
+When you have configuration files or user input that specifies a probability
+distribution (e.g. `"norm(loc=0, scale=1)"`), you want to turn that string
+into a ready‑to‑sample object. `distparser` does exactly that, with a tiny
+API and zero surprises.
+
+## Installation
+
+```bash
+pip install distparser
+```
+
+## Quick Start
+
+```
+from distparser import parse_dist
+
+# Positional arguments (order matters)
+dist = parse_dist("uniform(0, 1)")
+sample = dist.rvs()          # e.g. 0.374
+
+# Keyword arguments (order ignored)
+dist = parse_dist("norm(loc=0, scale=1)")
+samples = dist.rvs(size=5)   # array([-0.12, 1.03, ...])
+
+# Mixed (positional + keyword) – works, but not recommended
+dist = parse_dist("expon(scale=2, loc=1)")
+```
+
+## Supported Distributions
+
+Built‑in registry covers the most common continuous distributions:
+
+- `uniform(loc, scale)`
+- `norm(loc, scale)`
+- `expon(loc, scale)`
+- … and many more (see [docs](https://distparser.readthedocs.io)).
+
+You can **add your own** at runtime:
+
+```python
+from distparser import register_distribution
+from scipy.stats import gumbel_r
+
+register_distribution("gumbel", gumbel_r, ["loc", "scale"])
+```
+
+## Development
+
+See [AGENTS.md](AGENTS.md) for development setup and guidelines.
+
+## License
+
+MIT

distparser-0.2.0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "distparser"
+version = "0.2.0"
+description = "Parse function-call strings into frozen scipy.stats distributions"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Juyoung Choi", email = "njuyoung35@gmail.com"}]
+maintainers = [{name = "Juyoung Choi", email = "njuyoung35@gmail.com"}]
+keywords = ["scipy", "distribution", "parsing", "rvs"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+]
+requires-python = ">=3.8,<3.14"
+dependencies = [
+    "scipy>=1.7.0",
+    "numpy>=1.21.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/njuyoung35/distparser"
+Repository = "https://github.com/njuyoung35/distparser"
+Documentation = "https://distparser.readthedocs.io"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "ruff",
+    "mypy",
+    "build",
+    "twine",
+]
+docs = [
+    "mkdocs>=1.5.0",
+    "mkdocs-rtd-theme>=2.0.0",
+    "pymdown-extensions>=10.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+testpaths = ["tests"]
+addopts = "-v --cov=src/distparser --cov-report=term-missing"
+
+[tool.mypy]
+python_version = "3.8"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

distparser-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

distparser-0.2.0/src/distparser/__init__.py

@@ -0,0 +1,21 @@
+"""distparser – parse function-call strings into frozen scipy.stats distributions."""
+
+from distparser.core import (
+    REGISTRY,
+    DistParserError,
+    ParseError,
+    UnknownDistributionError,
+    parse_dist,
+    register_distribution,
+)
+from distparser.version import __version__
+
+__all__ = [
+    "__version__",
+    "DistParserError",
+    "ParseError",
+    "UnknownDistributionError",
+    "REGISTRY",
+    "parse_dist",
+    "register_distribution",
+]

distparser-0.2.0/src/distparser/core.py

@@ -0,0 +1,205 @@
+"""Core parsing logic and distribution registry."""
+
+from __future__ import annotations
+
+import ast
+import re
+from typing import Any
+
+from scipy.stats import (
+    beta,
+    cauchy,
+    chi2,
+    expon,
+    f,
+    gamma,
+    laplace,
+    logistic,
+    lognorm,
+    norm,
+    pareto,
+    rayleigh,
+    t,
+    uniform,
+    weibull_min,
+)
+
+__all__ = [
+    "DistParserError",
+    "ParseError",
+    "UnknownDistributionError",
+    "REGISTRY",
+    "parse_dist",
+    "register_distribution",
+]
+
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+
+class DistParserError(Exception):
+    """Base exception for all distparser errors."""
+
+
+class ParseError(DistParserError):
+    """Raised when a distribution string cannot be parsed."""
+
+
+class UnknownDistributionError(DistParserError):
+    """Raised when a distribution name is not in the registry."""
+
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+REGISTRY: dict[str, dict[str, Any]] = {
+    # Shape-parameter distributions (alphabetical)
+    "beta": {"class": beta, "param_order": ["a", "b", "loc", "scale"]},
+    "chi2": {"class": chi2, "param_order": ["df", "loc", "scale"]},
+    "f": {"class": f, "param_order": ["dfn", "dfd", "loc", "scale"]},
+    "gamma": {"class": gamma, "param_order": ["a", "loc", "scale"]},
+    "lognorm": {"class": lognorm, "param_order": ["s", "loc", "scale"]},
+    "pareto": {"class": pareto, "param_order": ["b", "loc", "scale"]},
+    "t": {"class": t, "param_order": ["df", "loc", "scale"]},
+    "weibull_min": {"class": weibull_min, "param_order": ["c", "loc", "scale"]},
+    # Loc/scale-only distributions (alphabetical)
+    "cauchy": {"class": cauchy, "param_order": ["loc", "scale"]},
+    "expon": {"class": expon, "param_order": ["loc", "scale"]},
+    "laplace": {"class": laplace, "param_order": ["loc", "scale"]},
+    "logistic": {"class": logistic, "param_order": ["loc", "scale"]},
+    "norm": {"class": norm, "param_order": ["loc", "scale"]},
+    "rayleigh": {"class": rayleigh, "param_order": ["loc", "scale"]},
+    "uniform": {"class": uniform, "param_order": ["loc", "scale"]},
+}
+
+
+def register_distribution(
+    name: str,
+    dist_class: Any,
+    param_order: list[str],
+) -> None:
+    """Register a new distribution in the global registry.
+
+    Args:
+        name: Name used in parse strings (e.g. ``"gumbel"``).
+        dist_class: A scipy.stats distribution class.
+        param_order: Ordered list of parameter names for positional arguments.
+    """
+    REGISTRY[name] = {"class": dist_class, "param_order": list(param_order)}
+
+
+# ---------------------------------------------------------------------------
+# Argument splitting (comma-aware, quote-safe)
+# ---------------------------------------------------------------------------
+
+
+def _split_args(args_str: str) -> list[str]:
+    """Split *args_str* on commas, respecting single- and double-quoted regions.
+
+    Empty parts are filtered out so that ``"norm()"`` yields ``[]``.
+    """
+    parts: list[str] = []
+    current: list[str] = []
+    in_single = False
+    in_double = False
+
+    for ch in args_str:
+        if ch == "'" and not in_double:
+            in_single = not in_single
+            current.append(ch)
+        elif ch == '"' and not in_single:
+            in_double = not in_double
+            current.append(ch)
+        elif ch == "," and not in_single and not in_double:
+            parts.append("".join(current).strip())
+            current = []
+        else:
+            current.append(ch)
+
+    parts.append("".join(current).strip())
+    return [p for p in parts if p]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+_NAME_RE = re.compile(r"^([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)$")
+
+
+def parse_dist(s: str) -> Any:
+    """Parse a function-call string into a frozen ``scipy.stats`` distribution.
+
+    Args:
+        s: A string like ``"norm(loc=0, scale=1)"`` or ``"uniform(0, 1)"``.
+
+    Returns:
+        A frozen scipy.stats distribution object (callable for ``.rvs()``).
+
+    Raises:
+        ParseError: If the string cannot be parsed.
+        UnknownDistributionError: If the distribution name is not registered.
+
+    Examples:
+        >>> from distparser import parse_dist
+        >>> d = parse_dist("norm(loc=0, scale=1)")
+        >>> d.rvs(size=3)  # doctest: +SKIP
+        array([...])
+    """
+    s = s.strip()
+    m = _NAME_RE.match(s)
+    if not m:
+        raise ParseError(f"Cannot parse {s!r}. Expected format: 'name(args)'.")
+
+    name = m.group(1)
+    if name not in REGISTRY:
+        raise UnknownDistributionError(
+            f"Unknown distribution {name!r}. Registered: {', '.join(sorted(REGISTRY))}."
+        )
+
+    entry = REGISTRY[name]
+    dist_class = entry["class"]
+    param_order: list[str] = entry["param_order"]
+
+    raw_args = _split_args(m.group(2))
+
+    # Separate positional values from keyword assignments
+    positional: list[Any] = []
+    keyword: dict[str, Any] = {}
+
+    for arg in raw_args:
+        arg = arg.strip()
+        if "=" in arg:
+            key, val_str = arg.split("=", 1)
+            key = key.strip()
+            val_str = val_str.strip()
+            keyword[key] = _eval_arg(val_str, s)
+        else:
+            positional.append(_eval_arg(arg, s))
+
+    # Build final parameter dict: positional first, keywords override
+    params: dict[str, Any] = {}
+    for i, value in enumerate(positional):
+        if i >= len(param_order):
+            raise ParseError(
+                f"Too many positional arguments in {s!r}. "
+                f"{name!r} accepts at most {len(param_order)} "
+                f"positional args: {', '.join(param_order)}."
+            )
+        params[param_order[i]] = value
+
+    params.update(keyword)
+
+    return dist_class(**params)
+
+
+def _eval_arg(raw: str, full_str: str) -> Any:
+    """Evaluate a single argument value via ``ast.literal_eval``, with a
+    helpful error message on failure."""
+    try:
+        return ast.literal_eval(raw)
+    except (ValueError, SyntaxError) as exc:
+        raise ParseError(f"Cannot evaluate {raw!r} in {full_str!r}: {exc}") from exc

distparser-0.2.0/src/distparser/version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

distparser-0.2.0/src/distparser.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: distparser
+Version: 0.2.0
+Summary: Parse function-call strings into frozen scipy.stats distributions
+Author-email: Juyoung Choi <njuyoung35@gmail.com>
+Maintainer-email: Juyoung Choi <njuyoung35@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/njuyoung35/distparser
+Project-URL: Repository, https://github.com/njuyoung35/distparser
+Project-URL: Documentation, https://distparser.readthedocs.io
+Keywords: scipy,distribution,parsing,rvs
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: numpy>=1.21.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-rtd-theme>=2.0.0; extra == "docs"
+Requires-Dist: pymdown-extensions>=10.0; extra == "docs"
+Dynamic: license-file
+
+# distparser
+
+**Parse function‑call syntax strings into frozen `scipy.stats` distributions**
+
+[![PyPI version](https://badge.fury.io/py/distparser.svg)](https://badge.fury.io/py/distparser)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Why `distparser`?
+
+When you have configuration files or user input that specifies a probability
+distribution (e.g. `"norm(loc=0, scale=1)"`), you want to turn that string
+into a ready‑to‑sample object. `distparser` does exactly that, with a tiny
+API and zero surprises.
+
+## Installation
+
+```bash
+pip install distparser
+```
+
+## Quick Start
+
+```
+from distparser import parse_dist
+
+# Positional arguments (order matters)
+dist = parse_dist("uniform(0, 1)")
+sample = dist.rvs()          # e.g. 0.374
+
+# Keyword arguments (order ignored)
+dist = parse_dist("norm(loc=0, scale=1)")
+samples = dist.rvs(size=5)   # array([-0.12, 1.03, ...])
+
+# Mixed (positional + keyword) – works, but not recommended
+dist = parse_dist("expon(scale=2, loc=1)")
+```
+
+## Supported Distributions
+
+Built‑in registry covers the most common continuous distributions:
+
+- `uniform(loc, scale)`
+- `norm(loc, scale)`
+- `expon(loc, scale)`
+- … and many more (see [docs](https://distparser.readthedocs.io)).
+
+You can **add your own** at runtime:
+
+```python
+from distparser import register_distribution
+from scipy.stats import gumbel_r
+
+register_distribution("gumbel", gumbel_r, ["loc", "scale"])
+```
+
+## Development
+
+See [AGENTS.md](AGENTS.md) for development setup and guidelines.
+
+## License
+
+MIT

distparser-0.2.0/src/distparser.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/distparser/__init__.py
+src/distparser/core.py
+src/distparser/version.py
+src/distparser.egg-info/PKG-INFO
+src/distparser.egg-info/SOURCES.txt
+src/distparser.egg-info/dependency_links.txt
+src/distparser.egg-info/requires.txt
+src/distparser.egg-info/top_level.txt
+tests/test_core.py

distparser-0.2.0/src/distparser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

distparser-0.2.0/src/distparser.egg-info/requires.txt

@@ -0,0 +1,15 @@
+scipy>=1.7.0
+numpy>=1.21.0
+
+[dev]
+pytest>=7.0
+pytest-cov
+ruff
+mypy
+build
+twine
+
+[docs]
+mkdocs>=1.5.0
+mkdocs-rtd-theme>=2.0.0
+pymdown-extensions>=10.0

distparser-0.2.0/src/distparser.egg-info/top_level.txt

@@ -0,0 +1 @@
+distparser

distparser-0.2.0/tests/test_core.py

@@ -0,0 +1,242 @@
+"""Tests for distparser.core."""
+
+import pytest
+from scipy.stats import expon, norm, uniform
+
+from distparser.core import (
+    REGISTRY,
+    DistParserError,
+    ParseError,
+    UnknownDistributionError,
+    parse_dist,
+    register_distribution,
+)
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+
+class TestRegistry:
+    def test_builtin_entries(self):
+        assert "uniform" in REGISTRY
+        assert "norm" in REGISTRY
+        assert "expon" in REGISTRY
+
+    def test_builtin_classes(self):
+        assert REGISTRY["uniform"]["class"] is uniform
+        assert REGISTRY["norm"]["class"] is norm
+        assert REGISTRY["expon"]["class"] is expon
+
+    def test_builtin_param_orders(self):
+        assert REGISTRY["uniform"]["param_order"] == ["loc", "scale"]
+        assert REGISTRY["norm"]["param_order"] == ["loc", "scale"]
+        assert REGISTRY["expon"]["param_order"] == ["loc", "scale"]
+
+
+class TestRegisterDistribution:
+    def test_adds_to_registry(self):
+        register_distribution("_test", uniform, ["loc", "scale"])
+        assert "_test" in REGISTRY
+        assert REGISTRY["_test"]["class"] is uniform
+        assert REGISTRY["_test"]["param_order"] == ["loc", "scale"]
+
+    def test_custom_distribution_is_usable(self):
+        from scipy.stats import gamma
+
+        register_distribution("_gamma_test", gamma, ["a", "loc", "scale"])
+        d = parse_dist("_gamma_test(2.0, loc=0, scale=1.5)")
+        assert abs(d.kwds["a"] - 2.0) < 1e-12
+        assert abs(d.kwds["scale"] - 1.5) < 1e-12
+
+
+# ---------------------------------------------------------------------------
+# parse_dist – success cases
+# ---------------------------------------------------------------------------
+
+
+class TestParseDistPositional:
+    def test_all_positional(self):
+        d = parse_dist("uniform(0, 1)")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+        assert abs(d.kwds["scale"] - 1.0) < 1e-12
+
+    def test_partial_positional(self):
+        d = parse_dist("uniform(5)")
+        # Only explicitly passed args appear in kwds
+        assert abs(d.kwds["loc"] - 5.0) < 1e-12
+        # scale is not in kwds; verify default (1.0) via std
+        assert abs(d.std() - 1.0 / (12**0.5)) < 1e-12
+
+
+class TestParseDistKeyword:
+    def test_all_keyword(self):
+        d = parse_dist("norm(loc=0, scale=2)")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+        assert abs(d.kwds["scale"] - 2.0) < 1e-12
+
+    def test_keyword_order_independent(self):
+        d = parse_dist("norm(scale=3, loc=10)")
+        assert abs(d.kwds["loc"] - 10.0) < 1e-12
+        assert abs(d.kwds["scale"] - 3.0) < 1e-12
+
+
+class TestParseDistMixed:
+    def test_keyword_overrides_positional(self):
+        d = parse_dist("uniform(0, loc=5)")
+        assert abs(d.kwds["loc"] - 5.0) < 1e-12
+
+    def test_partial_positional_plus_keyword(self):
+        d = parse_dist("expon(0.5, scale=3)")
+        assert abs(d.kwds["loc"] - 0.5) < 1e-12
+        assert abs(d.kwds["scale"] - 3.0) < 1e-12
+
+
+class TestParseDistDefaults:
+    def test_no_args_uses_defaults(self):
+        d = parse_dist("uniform()")
+        # No explicitly passed args => kwds is empty; verify via stats
+        assert d.kwds == {}
+        # uniform(0, 1): mean = (0+1)/2 = 0.5, std = 1/sqrt(12)
+        assert abs(d.mean() - 0.5) < 1e-12
+        assert abs(d.std() - 1.0 / (12**0.5)) < 1e-12
+
+    def test_whitespace_handling(self):
+        d = parse_dist("  norm ( loc = 0 , scale = 1 )  ")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+        assert abs(d.kwds["scale"] - 1.0) < 1e-12
+
+
+class TestParseDistCommaInQuotes:
+    def test_string_arg_with_comma(self):
+        d = parse_dist("uniform(0, '1,2,3')")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+
+    def test_keyword_string_with_comma(self):
+        d = parse_dist('uniform(loc="a,b", scale=5)')
+        assert d.kwds["loc"] == "a,b"
+        assert abs(d.kwds["scale"] - 5.0) < 1e-12
+
+
+class TestParseDistReturnsFrozenDistribution:
+    def test_rvs_returns_array(self):
+        import numpy as np
+
+        d = parse_dist("norm(loc=0, scale=1)")
+        samples = d.rvs(size=10, random_state=42)
+        assert isinstance(samples, np.ndarray)
+        assert len(samples) == 10
+
+    def test_reproducible_with_seed(self):
+        d = parse_dist("norm(loc=0, scale=1)")
+        s1 = d.rvs(size=5, random_state=42)
+        s2 = d.rvs(size=5, random_state=42)
+        import numpy as np
+
+        assert np.array_equal(s1, s2)
+
+
+class TestParseDistNewDistributions:
+    """Smoke tests: parse + rvs for each newly added distribution."""
+
+    def test_gamma(self):
+        d = parse_dist("gamma(2.0, loc=0, scale=1.5)")
+        assert abs(d.kwds["a"] - 2.0) < 1e-12
+        assert d.rvs(size=3, random_state=42).shape == (3,)
+
+    def test_beta(self):
+        d = parse_dist("beta(2, 5, loc=0, scale=1)")
+        assert d.rvs(size=3, random_state=42).shape == (3,)
+
+    def test_lognorm(self):
+        d = parse_dist("lognorm(0.5, loc=0, scale=2)")
+        assert abs(d.kwds["s"] - 0.5) < 1e-12
+
+    def test_weibull_min(self):
+        d = parse_dist("weibull_min(1.5, loc=0, scale=1)")
+        assert abs(d.kwds["c"] - 1.5) < 1e-12
+
+    def test_t(self):
+        d = parse_dist("t(10, loc=0, scale=1)")
+        assert abs(d.kwds["df"] - 10.0) < 1e-12
+
+    def test_chi2(self):
+        d = parse_dist("chi2(5, loc=0, scale=1)")
+        assert abs(d.kwds["df"] - 5.0) < 1e-12
+
+    def test_f(self):
+        d = parse_dist("f(4, 10, loc=0, scale=1)")
+        assert abs(d.kwds["dfn"] - 4.0) < 1e-12
+        assert abs(d.kwds["dfd"] - 10.0) < 1e-12
+
+    def test_pareto(self):
+        d = parse_dist("pareto(3, loc=0, scale=1)")
+        assert abs(d.kwds["b"] - 3.0) < 1e-12
+
+    def test_cauchy(self):
+        d = parse_dist("cauchy(loc=0, scale=1)")
+        assert d.rvs(size=3, random_state=42).shape == (3,)
+
+    def test_laplace(self):
+        d = parse_dist("laplace(loc=0, scale=2)")
+        assert abs(d.kwds["scale"] - 2.0) < 1e-12
+
+    def test_logistic(self):
+        d = parse_dist("logistic(loc=1, scale=3)")
+        assert abs(d.kwds["loc"] - 1.0) < 1e-12
+
+    def test_rayleigh(self):
+        d = parse_dist("rayleigh(loc=0, scale=1)")
+        assert d.rvs(size=3, random_state=42).shape == (3,)
+
+
+# ---------------------------------------------------------------------------
+# parse_dist – error cases
+# ---------------------------------------------------------------------------
+
+
+class TestParseDistErrors:
+    def test_empty_string(self):
+        with pytest.raises(ParseError, match="Cannot parse"):
+            parse_dist("")
+
+    def test_no_parens(self):
+        with pytest.raises(ParseError, match="Cannot parse"):
+            parse_dist("norm")
+
+    def test_only_name_and_parens_missing(self):
+        with pytest.raises(ParseError):
+            parse_dist("123(0, 1)")
+
+    def test_unknown_distribution(self):
+        with pytest.raises(UnknownDistributionError, match="xyzzy"):
+            parse_dist("xyzzy(0, 1)")
+
+    def test_unknown_dist_suggests_registered(self):
+        with pytest.raises(UnknownDistributionError, match="Registered"):
+            parse_dist("foobar(0)")
+
+    def test_too_many_positional(self):
+        with pytest.raises(ParseError, match="Too many positional"):
+            parse_dist("uniform(0, 1, 2, 3)")
+
+    def test_unclosed_quote(self):
+        with pytest.raises((ParseError, SyntaxError)):
+            parse_dist("uniform(0, 'hello)")
+
+    def test_garbage_input(self):
+        with pytest.raises(ParseError):
+            parse_dist("!!not valid!!")
+
+
+# ---------------------------------------------------------------------------
+# Exception hierarchy
+# ---------------------------------------------------------------------------
+
+
+class TestExceptionHierarchy:
+    def test_parse_error_is_distparser_error(self):
+        assert issubclass(ParseError, DistParserError)
+
+    def test_unknown_distribution_is_distparser_error(self):
+        assert issubclass(UnknownDistributionError, DistParserError)