distparser 0.3.1__tar.gz → 0.3.2__tar.gz

{distparser-0.3.1/src/distparser.egg-info → distparser-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distparser
-Version: 0.3.1
+Version: 0.3.2
 Summary: Parse function-call strings into frozen scipy.stats distributions
 Author-email: Juyoung Choi <njuyoung35@gmail.com>
 Maintainer-email: Juyoung Choi <njuyoung35@gmail.com>
@@ -79,7 +79,7 @@ print(result["measurement"])  # 5.0 + sample from N(0, 0.1)
 - **DistGraph** — automatic dependency resolution via topological sort
 - **Arithmetic expressions** — `"60 + 30 * uniform(0, 1)"` with `sin`, `cos`, `exp`, `sqrt`, `pi` and more
 - **Seed management** — global `seed()`, context manager `seed_context()`, per-instance `DistGraph(seed=...)`
-- **Bounds constraints** — annotate parameters with physical limits for downstream validation
+- **Bounds clipping** — clamp sampled values with `min`/`max` or `lbound`/`rbound`
 - **Extensible registry** — register custom distributions at runtime
 
 ## Docs

{distparser-0.3.1 → distparser-0.3.2}/README.md

@@ -46,7 +46,7 @@ print(result["measurement"])  # 5.0 + sample from N(0, 0.1)
 - **DistGraph** — automatic dependency resolution via topological sort
 - **Arithmetic expressions** — `"60 + 30 * uniform(0, 1)"` with `sin`, `cos`, `exp`, `sqrt`, `pi` and more
 - **Seed management** — global `seed()`, context manager `seed_context()`, per-instance `DistGraph(seed=...)`
-- **Bounds constraints** — annotate parameters with physical limits for downstream validation
+- **Bounds clipping** — clamp sampled values with `min`/`max` or `lbound`/`rbound`
 - **Extensible registry** — register custom distributions at runtime
 
 ## Docs

{distparser-0.3.1 → distparser-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "distparser"
-version = "0.3.1"
+version = "0.3.2"
 description = "Parse function-call strings into frozen scipy.stats distributions"
 readme = "README.md"
 license = {text = "MIT"}

{distparser-0.3.1 → distparser-0.3.2}/src/distparser/core.py

@@ -26,6 +26,8 @@ from scipy.stats import (
 
 from distparser.mapping import normalize_dist_name
 
+_BOUND_KEYS = frozenset({"min", "max", "lbound", "rbound"})
+
 __all__ = [
     "DistParserError",
     "ParseError",
@@ -195,6 +197,10 @@ def parse_dist(s: str) -> Any:
 
     params.update(keyword)
 
+    # Strip bound keys before passing to scipy
+    for bk in _BOUND_KEYS:
+        params.pop(bk, None)
+
     return dist_class(**params)
 
 

{distparser-0.3.1 → distparser-0.3.2}/src/distparser/graph.py

@@ -4,13 +4,14 @@ from __future__ import annotations
 
 import ast as _ast
 import contextlib
+import re as _re
 from typing import Any, Iterator
 
 import graphlib
 import numpy as np
 from asteval import Interpreter
 
-from distparser.core import REGISTRY, ParseError
+from distparser.core import REGISTRY, ParseError, _split_args
 
 # ---------------------------------------------------------------------------
 # Seed management
@@ -57,6 +58,9 @@ def _get_current_rng() -> np.random.Generator:
 # Distribution sampler factory
 # ---------------------------------------------------------------------------
 
+
+_BOUND_KEYS = frozenset({"min", "max", "lbound", "rbound"})
+_NAME_RE = _re.compile(r"^([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*)\)$")
 # Math constants and functions exposed in expressions
 _MATH_SYMBOLS: dict[str, Any] = {
     "sin": np.sin,
@@ -74,7 +78,7 @@ _MATH_SYMBOLS: dict[str, Any] = {
 
 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."""
+    sampler that returns a single ``.rvs()`` sample, clipped to bounds."""
     samplers: dict[str, Any] = {}
     for name, entry in REGISTRY.items():
         dist_class = entry["class"]
@@ -87,12 +91,27 @@ def _make_dist_samplers(rng: np.random.Generator) -> dict[str, Any]:
             _rng: np.random.Generator = rng,
             **kwargs: Any,
         ) -> Any:
+            # Separate bound kwargs from distribution kwargs
+            bounds: dict[str, float] = {}
+            dist_kwargs: dict[str, Any] = {}
+            for k, v in kwargs.items():
+                if k in _BOUND_KEYS:
+                    bounds[k] = float(v)
+                else:
+                    dist_kwargs[k] = v
+
             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)
+            params.update(dist_kwargs)
+
+            value = float(_dc(**params).rvs(random_state=_rng))
+
+            # Clip to bounds
+            lb = bounds.get("min", bounds.get("lbound", -float("inf")))
+            ub = bounds.get("max", bounds.get("rbound", float("inf")))
+            return float(np.clip(value, lb, ub))
 
         samplers[name] = _sampler
     return samplers
@@ -124,7 +143,7 @@ class DistGraph:
         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]]] = {}
+        self._bounds: dict[str, dict[str, float]] = {}
 
         # Parse config into dist expressions + bounds
         self._dists: dict[str, Any] = {}
@@ -139,18 +158,36 @@ class DistGraph:
 
     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"]
+            if isinstance(value, str):
+                self._dists[key] = value
+                self._bounds[key] = self._extract_bounds(value)
             else:
                 self._dists[key] = value
 
+    # ------------------------------------------------------------------
+    # Bound extraction
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _extract_bounds(expr: str) -> dict[str, float]:
+        """Extract bound keyword args (min/max/lbound/rbound) from an expression."""
+        m = _NAME_RE.match(expr.strip())
+        if not m:
+            return {}
+        args_str = m.group(2)
+        bounds: dict[str, float] = {}
+        for arg in _split_args(args_str):
+            arg = arg.strip()
+            if "=" in arg:
+                key, val_str = arg.split("=", 1)
+                key = key.strip()
+                if key in _BOUND_KEYS:
+                    try:
+                        bounds[key] = float(_ast.literal_eval(val_str.strip()))
+                    except (ValueError, SyntaxError):
+                        pass
+        return bounds
+
     # ------------------------------------------------------------------
     # Dependency resolution
     # ------------------------------------------------------------------
@@ -257,9 +294,10 @@ class DistGraph:
     def keys(self) -> Any:
         return self._dists.keys()
 
-    def get_bounds(self, key: str) -> dict[str, tuple[float, float]] | None:
+    def get_bounds(self, key: str) -> dict[str, float] | None:
         """Return the bounds dict for *key*, or ``None`` if no bounds set."""
-        return self._bounds.get(key)
+        b = self._bounds.get(key)
+        return b if b else None
 
     @property
     def order(self) -> list[str]:

distparser-0.3.2/src/distparser/version.py

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

{distparser-0.3.1 → distparser-0.3.2/src/distparser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: distparser
-Version: 0.3.1
+Version: 0.3.2
 Summary: Parse function-call strings into frozen scipy.stats distributions
 Author-email: Juyoung Choi <njuyoung35@gmail.com>
 Maintainer-email: Juyoung Choi <njuyoung35@gmail.com>
@@ -79,7 +79,7 @@ print(result["measurement"])  # 5.0 + sample from N(0, 0.1)
 - **DistGraph** — automatic dependency resolution via topological sort
 - **Arithmetic expressions** — `"60 + 30 * uniform(0, 1)"` with `sin`, `cos`, `exp`, `sqrt`, `pi` and more
 - **Seed management** — global `seed()`, context manager `seed_context()`, per-instance `DistGraph(seed=...)`
-- **Bounds constraints** — annotate parameters with physical limits for downstream validation
+- **Bounds clipping** — clamp sampled values with `min`/`max` or `lbound`/`rbound`
 - **Extensible registry** — register custom distributions at runtime
 
 ## Docs

{distparser-0.3.1 → distparser-0.3.2}/tests/test_core.py

@@ -213,6 +213,17 @@ class TestParseDistAliases:
             parse_dist("not_an_alias(0, 1)")
 
 
+class TestParseDistBounds:
+    """Bound keys are stripped before passing to scipy."""
+
+    def test_bound_keys_are_stripped(self):
+        d = parse_dist("norm(loc=0, scale=1, min=-2, max=2)")
+        assert abs(d.kwds["loc"] - 0.0) < 1e-12
+        assert abs(d.kwds["scale"] - 1.0) < 1e-12
+        assert "min" not in d.kwds
+        assert "max" not in d.kwds
+
+
 # ---------------------------------------------------------------------------
 # parse_dist – error cases
 # ---------------------------------------------------------------------------

{distparser-0.3.1 → distparser-0.3.2}/tests/test_graph.py

@@ -158,45 +158,45 @@ class TestSeedManagement:
 
 
 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)},
-                }
-            }
-        )
+    def test_bounds_in_expression(self):
+        g = DistGraph({"x": "uniform(0, 1, min=0.1, max=0.9)"}, seed=42)
         result = g.resolve_all()
-        assert abs(result["wall"] - 0.25) < 0.2
+        # Clipped to [0.1, 0.9]
+        assert 0.1 <= result["x"] <= 0.9
 
     def test_get_bounds(self):
-        g = DistGraph({"x": {"dist": "uniform(0, 1)", "bounds": {"loc": (-1, 2)}}})
+        g = DistGraph({"x": "uniform(0, 1, min=0, max=2)"})
         bounds = g.get_bounds("x")
-        assert bounds == {"loc": (-1, 2)}
+        assert bounds == {"min": 0.0, "max": 2.0}
+
+    def test_get_bounds_lbound_rbound(self):
+        g = DistGraph({"x": "norm(0, 1, lbound=-1, rbound=1)"})
+        bounds = g.get_bounds("x")
+        assert bounds == {"lbound": -1.0, "rbound": 1.0}
 
     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,
-        )
+    def test_bounds_clip_sampling(self):
+        # Bounds ARE applied as clipping — value should be clamped
+        g = DistGraph({"x": "norm(loc=100, scale=0.01, max=50)"}, seed=42)
+        result = g.resolve_all()
+        assert result["x"] <= 50.0
+
+    def test_min_alternative(self):
+        g = DistGraph({"x": "uniform(0, 1, min=-10, max=-5)"}, seed=42)
+        result = g.resolve_all()
+        # Clipped to [-10, -5] — tightly constrained
+        assert -10 <= result["x"] <= -5
+
+    def test_nonliteral_bound_ignored_in_extract(self):
+        # min=a is not a literal — _extract_bounds ignores it gracefully
+        g = DistGraph({"a": 0.5, "x": "uniform(0, 1, min=a)"})
+        assert g.get_bounds("x") is None  # not a literal → not extracted
+        # But sampler still clips since 'a' is resolved as a variable
         result = g.resolve_all()
-        # Value is near loc=100, not clipped to bounds (0, 1)
-        assert abs(result["x"] - 100.0) < 1.0
+        assert result["x"] >= 0.5
 
 
 # ---------------------------------------------------------------------------

distparser-0.3.1/src/distparser/version.py

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