distparser 0.2.0__tar.gz → 0.3.0__tar.gz

{distparser-0.2.0/src/distparser.egg-info → distparser-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distparser
-Version: 0.2.0
+Version: 0.3.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>
@@ -18,6 +18,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy>=1.7.0
 Requires-Dist: numpy>=1.21.0
+Requires-Dist: asteval>=0.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -27,7 +28,6 @@ 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-0.2.0 → distparser-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "distparser"
-version = "0.2.0"
+version = "0.3.0"
 description = "Parse function-call strings into frozen scipy.stats distributions"
 readme = "README.md"
 license = {text = "MIT"}
@@ -21,6 +21,7 @@ requires-python = ">=3.8,<3.14"
 dependencies = [
     "scipy>=1.7.0",
     "numpy>=1.21.0",
+    "asteval>=0.9.0",
 ]
 
 [project.urls]
@@ -39,7 +40,6 @@ dev = [
 ]
 docs = [
     "mkdocs>=1.5.0",
-    "mkdocs-rtd-theme>=2.0.0",
     "pymdown-extensions>=10.0",
 ]
 
@@ -52,12 +52,16 @@ testpaths = ["tests"]
 addopts = "-v --cov=src/distparser --cov-report=term-missing"
 
 [tool.mypy]
-python_version = "3.8"
+python_version = "3.12"
 strict = true
 warn_return_any = true
 warn_unused_configs = true
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+module = ["scipy.stats", "asteval"]
+ignore_missing_imports = true
+
 [tool.ruff]
 line-length = 88
 target-version = "py38"

{distparser-0.2.0 → distparser-0.3.0}/src/distparser/__init__.py

@@ -8,6 +8,8 @@ from distparser.core import (
     parse_dist,
     register_distribution,
 )
+from distparser.graph import DistGraph, seed, seed_context
+from distparser.mapping import DISTRIBUTION_ALIASES, normalize_dist_name
 from distparser.version import __version__
 
 __all__ = [
@@ -16,6 +18,11 @@ __all__ = [
     "ParseError",
     "UnknownDistributionError",
     "REGISTRY",
+    "DISTRIBUTION_ALIASES",
+    "normalize_dist_name",
     "parse_dist",
     "register_distribution",
+    "DistGraph",
+    "seed",
+    "seed_context",
 ]

{distparser-0.2.0 → distparser-0.3.0}/src/distparser/core.py

@@ -24,6 +24,8 @@ from scipy.stats import (
     weibull_min,
 )
 
+from distparser.mapping import normalize_dist_name
+
 __all__ = [
     "DistParserError",
     "ParseError",
@@ -154,7 +156,7 @@ def parse_dist(s: str) -> Any:
     if not m:
         raise ParseError(f"Cannot parse {s!r}. Expected format: 'name(args)'.")
 
-    name = m.group(1)
+    name = normalize_dist_name(m.group(1))
     if name not in REGISTRY:
         raise UnknownDistributionError(
             f"Unknown distribution {name!r}. Registered: {', '.join(sorted(REGISTRY))}."

distparser-0.3.0/src/distparser/graph.py

@@ -0,0 +1,272 @@
+"""DistGraph: dependency-aware distribution graph with safe expression evaluation."""
+
+from __future__ import annotations
+
+import ast as _ast
+import contextlib
+from typing import Any, Iterator
+
+import graphlib
+import numpy as np
+from asteval import Interpreter
+
+from distparser.core import REGISTRY, ParseError
+
+# ---------------------------------------------------------------------------
+# Seed management
+# ---------------------------------------------------------------------------
+
+_DEFAULT_SEED: int | None = None
+_DEFAULT_RNG: np.random.Generator | None = None
+
+
+def seed(value: int) -> None:
+    """Set the global legacy seed for distribution sampling."""
+    global _DEFAULT_SEED, _DEFAULT_RNG
+    _DEFAULT_SEED = value
+    _DEFAULT_RNG = np.random.default_rng(value)
+
+
+@contextlib.contextmanager
+def seed_context(value: int) -> Iterator[None]:
+    """Temporarily override the global seed within a ``with`` block.
+
+    Example:
+        >>> with seed_context(42):
+        ...     graph = DistGraph({"x": "uniform(0,1)"})
+        ...     graph.resolve_all()
+    """
+    global _DEFAULT_RNG
+    old_rng = _DEFAULT_RNG
+    _DEFAULT_RNG = np.random.default_rng(value)
+    try:
+        yield
+    finally:
+        _DEFAULT_RNG = old_rng
+
+
+def _get_current_rng() -> np.random.Generator:
+    """Return the current global RNG, creating a fresh one if unset."""
+    global _DEFAULT_RNG
+    if _DEFAULT_RNG is None:
+        _DEFAULT_RNG = np.random.default_rng()
+    return _DEFAULT_RNG
+
+
+# ---------------------------------------------------------------------------
+# Distribution sampler factory
+# ---------------------------------------------------------------------------
+
+# Math constants and functions exposed in expressions
+_MATH_SYMBOLS: dict[str, Any] = {
+    "sin": np.sin,
+    "cos": np.cos,
+    "tan": np.tan,
+    "exp": np.exp,
+    "log": np.log,
+    "log10": np.log10,
+    "sqrt": np.sqrt,
+    "abs": abs,
+    "pi": np.pi,
+    "e": np.e,
+}
+
+
+def _make_dist_samplers(rng: np.random.Generator) -> dict[str, Any]:
+    """Build a dict mapping each registered distribution name to a callable
+    sampler that returns a single ``.rvs()`` sample."""
+    samplers: dict[str, Any] = {}
+    for name, entry in REGISTRY.items():
+        dist_class = entry["class"]
+        param_order: list[str] = entry["param_order"]
+
+        def _sampler(
+            *args: Any,
+            _dc: Any = dist_class,
+            _po: list[str] = param_order,
+            _rng: np.random.Generator = rng,
+            **kwargs: Any,
+        ) -> Any:
+            params: dict[str, Any] = {}
+            for i, val in enumerate(args):
+                if i < len(_po):
+                    params[_po[i]] = val
+            params.update(kwargs)
+            return _dc(**params).rvs(random_state=_rng)
+
+        samplers[name] = _sampler
+    return samplers
+
+
+# ---------------------------------------------------------------------------
+# DistGraph
+# ---------------------------------------------------------------------------
+
+
+class DistGraph:
+    """A dependency-aware graph of distribution expressions.
+
+    Users supply a flat dictionary mapping keys to expressions (or numeric
+    values).  ``DistGraph`` detects cross-references, resolves evaluation
+    order via topological sort, and injects resolved values into subsequent
+    expressions.
+
+    Parameters
+    ----------
+    config : dict
+        Mapping of key → expression string, numeric value, or bounds dict.
+        See the user guide for the bounds dict format.
+    seed : int | None
+        Per-instance RNG seed.  Overrides any global seed setting.
+    """
+
+    def __init__(self, config: dict[str, Any], seed: int | None = None) -> None:
+        self._raw_config = config
+        self._rng = np.random.default_rng(seed) if seed is not None else None
+        self._resolved: dict[str, Any] = {}
+        self._bounds: dict[str, dict[str, tuple[float, float]]] = {}
+
+        # Parse config into dist expressions + bounds
+        self._dists: dict[str, Any] = {}
+        self._parse_config()
+
+        # Build dependency graph and resolve evaluation order
+        self._order = self._resolve_order()
+
+    # ------------------------------------------------------------------
+    # Config parsing
+    # ------------------------------------------------------------------
+
+    def _parse_config(self) -> None:
+        for key, value in self._raw_config.items():
+            if isinstance(value, dict):
+                if "dist" not in value:
+                    raise ParseError(
+                        f"Config key {key!r} is a dict but missing required "
+                        f"'dist' key.  Use 'dist' for the expression string."
+                    )
+                self._dists[key] = value["dist"]
+                if "bounds" in value:
+                    self._bounds[key] = value["bounds"]
+            else:
+                self._dists[key] = value
+
+    # ------------------------------------------------------------------
+    # Dependency resolution
+    # ------------------------------------------------------------------
+
+    def _resolve_order(self) -> list[str]:
+        graph: dict[str, set[str]] = {k: set() for k in self._dists}
+        for key, expr in self._dists.items():
+            if isinstance(expr, str):
+                for var in self._extract_variables(expr):
+                    if var in self._dists:
+                        graph[key].add(var)
+        try:
+            ts = graphlib.TopologicalSorter(graph)
+            return list(ts.static_order())
+        except graphlib.CycleError as exc:
+            raise ParseError(f"Circular dependency detected in config: {exc}") from exc
+
+    @staticmethod
+    def _extract_variables(expr: str) -> set[str]:
+        """Return the set of bare-name identifiers in *expr*."""
+        try:
+            tree = _ast.parse(expr, mode="eval")
+        except SyntaxError:
+            return set()
+        return {node.id for node in _ast.walk(tree) if isinstance(node, _ast.Name)}
+
+    # ------------------------------------------------------------------
+    # Evaluation
+    # ------------------------------------------------------------------
+
+    def _evaluate(self, key: str) -> Any:
+        expr = self._dists[key]
+        if not isinstance(expr, str):
+            return expr
+
+        rng = self._rng or _get_current_rng()
+
+        interp = Interpreter()
+        # Pre-populate with already-resolved dependencies
+        interp.symtable.update(self._resolved)
+        # Math symbols
+        interp.symtable.update(_MATH_SYMBOLS)
+        # Distribution samplers
+        interp.symtable.update(_make_dist_samplers(rng))
+
+        result = interp(expr)
+        if interp.error:
+            messages: list[str] = []
+            for err in interp.error:
+                messages.append(f"{err.msg} (line {err.lineno})")
+            raise ParseError(
+                f"Error evaluating {expr!r} for key {key!r}: " + "; ".join(messages)
+            )
+        return result
+
+    def resolve_all(self) -> dict[str, Any]:
+        """Evaluate all keys in dependency order and return resolved values."""
+        for key in self._order:
+            if key not in self._resolved:
+                self._resolved[key] = self._evaluate(key)
+        return dict(self._resolved)
+
+    # ------------------------------------------------------------------
+    # Access
+    # ------------------------------------------------------------------
+
+    def __getitem__(self, key: str) -> Any:
+        """Access a resolved value, evaluating on demand if needed."""
+        if key not in self._dists:
+            raise KeyError(key)
+        if key not in self._resolved:
+            # Build the dependency graph to find what 'key' needs
+            graph = self._build_dep_graph()
+            self._resolve_deps(key, graph)
+        return self._resolved[key]
+
+    def _build_dep_graph(self) -> dict[str, set[str]]:
+        """Build the dependency graph (key → set of keys it depends on)."""
+        graph: dict[str, set[str]] = {k: set() for k in self._dists}
+        for k, expr in self._dists.items():
+            if isinstance(expr, str):
+                for var in self._extract_variables(expr):
+                    if var in self._dists:
+                        graph[k].add(var)
+        return graph
+
+    def _resolve_deps(self, key: str, graph: dict[str, set[str]]) -> None:
+        """Recursively resolve dependencies of *key*, then evaluate *key*."""
+        if key in self._resolved:
+            return
+        for dep in graph.get(key, set()):
+            self._resolve_deps(dep, graph)
+        self._resolved[key] = self._evaluate(key)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._dists
+
+    def __len__(self) -> int:
+        return len(self._dists)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._dists)
+
+    def keys(self) -> Any:
+        return self._dists.keys()
+
+    def get_bounds(self, key: str) -> dict[str, tuple[float, float]] | None:
+        """Return the bounds dict for *key*, or ``None`` if no bounds set."""
+        return self._bounds.get(key)
+
+    @property
+    def order(self) -> list[str]:
+        """The topological evaluation order (read-only)."""
+        return list(self._order)
+
+    def __repr__(self) -> str:
+        resolved_count = len(self._resolved)
+        total = len(self._dists)
+        return f"<DistGraph keys={total} resolved={resolved_count}>"

distparser-0.3.0/src/distparser/mapping.py

@@ -0,0 +1,18 @@
+"""Distribution name aliases and canonicalization."""
+
+from __future__ import annotations
+
+DISTRIBUTION_ALIASES: dict[str, str] = {
+    "normal": "norm",
+    "gaussian": "norm",
+    "unif": "uniform",
+}
+
+
+def normalize_dist_name(name: str) -> str:
+    """Return the canonical distribution name for *name*.
+
+    If *name* is a known alias, the canonical name is returned.
+    Otherwise *name* is returned unchanged.
+    """
+    return DISTRIBUTION_ALIASES.get(name, name)

distparser-0.3.0/src/distparser/version.py

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

{distparser-0.2.0 → distparser-0.3.0/src/distparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distparser
-Version: 0.2.0
+Version: 0.3.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>
@@ -18,6 +18,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: scipy>=1.7.0
 Requires-Dist: numpy>=1.21.0
+Requires-Dist: asteval>=0.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -27,7 +28,6 @@ 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-0.2.0 → distparser-0.3.0}/src/distparser.egg-info/SOURCES.txt

@@ -3,10 +3,14 @@ README.md
 pyproject.toml
 src/distparser/__init__.py
 src/distparser/core.py
+src/distparser/graph.py
+src/distparser/mapping.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
+tests/test_core.py
+tests/test_graph.py
+tests/test_mapping.py

{distparser-0.2.0 → distparser-0.3.0}/src/distparser.egg-info/requires.txt

@@ -1,5 +1,6 @@
 scipy>=1.7.0
 numpy>=1.21.0
+asteval>=0.9.0
 
 [dev]
 pytest>=7.0
@@ -11,5 +12,4 @@ twine
 
 [docs]
 mkdocs>=1.5.0
-mkdocs-rtd-theme>=2.0.0
 pymdown-extensions>=10.0

{distparser-0.2.0 → distparser-0.3.0}/tests/test_core.py

@@ -190,6 +190,29 @@ class TestParseDistNewDistributions:
         assert d.rvs(size=3, random_state=42).shape == (3,)
 
 
+class TestParseDistAliases:
+    """Verify that distribution aliases are resolved."""
+
+    def test_normal_alias(self):
+        d = parse_dist("normal(loc=0, scale=1)")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+
+    def test_gaussian_alias(self):
+        d = parse_dist("gaussian(loc=5, scale=2)")
+        assert abs(d.kwds["loc"] - 5.0) < 1e-12
+
+    def test_unif_alias(self):
+        d = parse_dist("unif(0, 1)")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+
+    def test_unknown_distribution_with_alias_message(self):
+        # Even with normalize, unknown names still raise UnknownDistributionError
+        from distparser.core import UnknownDistributionError
+
+        with pytest.raises(UnknownDistributionError):
+            parse_dist("not_an_alias(0, 1)")
+
+
 # ---------------------------------------------------------------------------
 # parse_dist – error cases
 # ---------------------------------------------------------------------------

distparser-0.3.0/tests/test_graph.py

@@ -0,0 +1,260 @@
+"""Tests for distparser.graph (DistGraph + seed management)."""
+
+import numpy as np
+import pytest
+
+from distparser.core import ParseError
+from distparser.graph import DistGraph, seed, seed_context
+
+# ---------------------------------------------------------------------------
+# Simple configs — no dependencies
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphSimple:
+    def test_single_distribution(self):
+        g = DistGraph({"x": "uniform(0, 1)"})
+        result = g.resolve_all()
+        assert "x" in result
+        assert 0 <= result["x"] <= 1
+
+    def test_numeric_value_passthrough(self):
+        g = DistGraph({"a": 42, "b": 3.14})
+        result = g.resolve_all()
+        assert result["a"] == 42
+        assert result["b"] == 3.14
+
+    def test_empty_config(self):
+        g = DistGraph({})
+        result = g.resolve_all()
+        assert result == {}
+
+    def test_arithmetic_expression_no_deps(self):
+        g = DistGraph({"x": "60 + 30 * uniform(0, 1)"})
+        result = g.resolve_all()
+        assert 60 <= result["x"] <= 90
+
+
+# ---------------------------------------------------------------------------
+# Dependencies — cross-references between keys
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphDependencies:
+    def test_linear_chain(self):
+        g = DistGraph({"a": 10, "b": "a + 5", "c": "b * 2"})
+        result = g.resolve_all()
+        assert result["a"] == 10
+        assert result["b"] == 15
+        assert result["c"] == 30
+
+    def test_topological_order(self):
+        g = DistGraph({"a": 1, "b": "a + 1", "c": "a + b"})
+        result = g.resolve_all()
+        assert result["a"] == 1
+        assert result["b"] == 2
+        assert result["c"] == 3
+        # 'a' must come before 'b' and 'c'
+        order = g.order
+        assert order.index("a") < order.index("b")
+        assert order.index("a") < order.index("c")
+
+    def test_distribution_with_dependency(self):
+        g = DistGraph({"mean": 5.0, "x": "norm(mean, 0.1)"}, seed=42)
+        result = g.resolve_all()
+        assert result["mean"] == 5.0
+        assert abs(result["x"] - 5.0) < 1.0  # should be near mean
+
+    def test_separate_sampling_per_evaluation(self):
+        g = DistGraph({"a": "uniform(0, 1)", "b": "uniform(0, 1)"}, seed=42)
+        result = g.resolve_all()
+        # With same seed but separate calls, patterns should differ
+        assert result["a"] != result["b"]
+
+
+# ---------------------------------------------------------------------------
+# Circular dependencies
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphCycles:
+    def test_direct_cycle_detected(self):
+        with pytest.raises(ParseError, match="Circular"):
+            DistGraph({"a": "b + 1", "b": "a + 1"})
+
+    def test_indirect_cycle_detected(self):
+        with pytest.raises(ParseError, match="Circular"):
+            DistGraph({"a": "b", "b": "c", "c": "a"})
+
+
+# ---------------------------------------------------------------------------
+# __getitem__ access
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphGetItem:
+    def test_lazy_resolution(self):
+        g = DistGraph({"a": 1, "b": "a + 2"})
+        assert g["a"] == 1
+        assert g["b"] == 3
+
+    def test_missing_key(self):
+        g = DistGraph({"a": 1})
+        with pytest.raises(KeyError):
+            _ = g["nonexistent"]
+
+    def test_contains_and_len(self):
+        g = DistGraph({"a": 1, "b": "a + 2"})
+        assert "a" in g
+        assert "c" not in g
+        assert len(g) == 2
+
+    def test_iter_and_keys(self):
+        g = DistGraph({"a": 1, "b": 2})
+        assert set(g) == {"a", "b"}
+        assert set(g.keys()) == {"a", "b"}
+
+
+# ---------------------------------------------------------------------------
+# Seed management
+# ---------------------------------------------------------------------------
+
+
+class TestSeedManagement:
+    def test_global_seed_reproducible(self):
+        seed(42)
+        g1 = DistGraph({"x": "uniform(0, 1)"})
+        v1 = g1.resolve_all()["x"]
+
+        seed(42)
+        g2 = DistGraph({"x": "uniform(0, 1)"})
+        v2 = g2.resolve_all()["x"]
+
+        assert v1 == v2
+
+    def test_per_instance_seed_overrides_global(self):
+        seed(99)
+        g1 = DistGraph({"x": "uniform(0, 1)"}, seed=42)
+        g2 = DistGraph({"x": "uniform(0, 1)"}, seed=42)
+        assert g1.resolve_all()["x"] == g2.resolve_all()["x"]
+
+    def test_seed_context_manager(self):
+        seed(0)
+        with seed_context(42):
+            g = DistGraph({"x": "uniform(0, 1)"})
+            v_ctx = g.resolve_all()["x"]
+
+        # Outside context, back to seed(0) RNG
+        g2 = DistGraph({"x": "uniform(0, 1)"})
+        v_outside = g2.resolve_all()["x"]
+
+        # Different seeds should produce different values (usually)
+        assert v_ctx != v_outside
+
+
+# ---------------------------------------------------------------------------
+# Bounds
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphBounds:
+    def test_bounds_dict_format(self):
+        g = DistGraph(
+            {
+                "wall": {
+                    "dist": "norm(loc=0.25, scale=0.025)",
+                    "bounds": {"loc": (0.0, 1.0), "scale": (0.001, 0.1)},
+                }
+            }
+        )
+        result = g.resolve_all()
+        assert abs(result["wall"] - 0.25) < 0.2
+
+    def test_get_bounds(self):
+        g = DistGraph({"x": {"dist": "uniform(0, 1)", "bounds": {"loc": (-1, 2)}}})
+        bounds = g.get_bounds("x")
+        assert bounds == {"loc": (-1, 2)}
+
+    def test_get_bounds_none(self):
+        g = DistGraph({"x": "uniform(0, 1)"})
+        assert g.get_bounds("x") is None
+
+    def test_missing_dist_key_raises(self):
+        with pytest.raises(ParseError, match="missing required 'dist'"):
+            DistGraph({"x": {"bounds": {"loc": (0, 1)}}})
+
+    def test_bounds_not_used_for_sampling(self):
+        # bounds are metadata only — sampling should still work
+        g = DistGraph(
+            {
+                "x": {
+                    "dist": "norm(loc=100, scale=0.01)",
+                    "bounds": {"loc": (0.0, 1.0)},
+                }
+            },
+            seed=42,
+        )
+        result = g.resolve_all()
+        # Value is near loc=100, not clipped to bounds (0, 1)
+        assert abs(result["x"] - 100.0) < 1.0
+
+
+# ---------------------------------------------------------------------------
+# Math expressions
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphMath:
+    def test_sin_cos(self):
+        g = DistGraph({"x": "sin(0)", "y": "cos(0)"})
+        result = g.resolve_all()
+        assert abs(result["x"]) < 1e-12
+        assert abs(result["y"] - 1.0) < 1e-12
+
+    def test_pi(self):
+        g = DistGraph({"x": "pi"})
+        result = g.resolve_all()
+        assert abs(result["x"] - np.pi) < 1e-12
+
+    def test_sqrt(self):
+        g = DistGraph({"x": "sqrt(16)"})
+        result = g.resolve_all()
+        assert abs(result["x"] - 4.0) < 1e-12
+
+
+# ---------------------------------------------------------------------------
+# Error cases
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphErrors:
+    def test_invalid_expression(self):
+        g = DistGraph({"x": "1 / 0"})
+        with pytest.raises(ParseError, match="Error evaluating"):
+            g.resolve_all()
+
+    def test_undefined_variable(self):
+        g = DistGraph({"x": "unknown_func(0)"})
+        with pytest.raises(ParseError, match="Error evaluating"):
+            g.resolve_all()
+
+    def test_syntax_error_expression_graceful(self):
+        # Invalid Python syntax → extract returns empty set, init succeeds
+        g = DistGraph({"bad": "x +", "ok": "42"})
+        # 'ok' has no deps and is valid — resolves fine
+        assert g["ok"] == 42
+        # 'bad' has invalid syntax — evaluation raises
+        with pytest.raises(ParseError, match="Error evaluating"):
+            g.resolve_all()
+
+
+# ---------------------------------------------------------------------------
+# Repr
+# ---------------------------------------------------------------------------
+
+
+class TestDistGraphRepr:
+    def test_repr(self):
+        g = DistGraph({"a": 1, "b": "a + 2"})
+        assert "DistGraph" in repr(g)
+        assert "keys=2" in repr(g)

distparser-0.3.0/tests/test_mapping.py

@@ -0,0 +1,26 @@
+"""Tests for distparser.mapping."""
+
+from distparser.mapping import DISTRIBUTION_ALIASES, normalize_dist_name
+
+
+class TestNormalizeDistName:
+    def test_known_alias(self):
+        assert normalize_dist_name("normal") == "norm"
+        assert normalize_dist_name("gaussian") == "norm"
+        assert normalize_dist_name("unif") == "uniform"
+
+    def test_unknown_name_passthrough(self):
+        assert normalize_dist_name("norm") == "norm"
+        assert normalize_dist_name("gamma") == "gamma"
+        assert normalize_dist_name("custom_dist") == "custom_dist"
+
+    def test_case_sensitive(self):
+        assert normalize_dist_name("Normal") == "Normal"
+        assert normalize_dist_name("NORM") == "NORM"
+
+
+class TestAliasMap:
+    def test_contains_expected_aliases(self):
+        assert DISTRIBUTION_ALIASES["normal"] == "norm"
+        assert DISTRIBUTION_ALIASES["gaussian"] == "norm"
+        assert DISTRIBUTION_ALIASES["unif"] == "uniform"

distparser-0.2.0/src/distparser/version.py

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