jarvisplot 1.0.1__py3-none-any.whl

jarvisplot/utils/interpolator.py

@@ -0,0 +1,377 @@
+# src/utils/interpolator.py
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Tuple, Literal
+
+
+BoundsMode = Literal["clamp", "extrapolate", "nan", "error"]
+
+
+@dataclass(frozen=True)
+class CSVSourceSpec:
+    """Where to read x/y pairs from."""
+    path: str           # relative to YAML dir or absolute
+    x: str              # column name (or index key later)
+    y: str              # column name
+    sort_by: Optional[str] = None
+    drop_duplicates: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class Interp1DSpec:
+    """Interpolation method + options."""
+    kind: str = "linear"
+    bounds: BoundsMode = "clamp"
+    fill_value: Optional[float] = None
+    assume_sorted: bool = False
+
+
+@dataclass(frozen=True)
+class InterpolatorSpec:
+    """Single named interpolator spec parsed from YAML."""
+    name: str
+    source: CSVSourceSpec
+    method: str = "interp1d"          # keep extensible: "interp1d", "pchip", ...
+    options: Interp1DSpec = Interp1DSpec()
+
+
+class LazyCallable:
+    """
+    A callable wrapper that builds the real function on first call.
+
+    IMPORTANT: This is what you inject into eval globals so Figure/layer code
+    doesn't need to know about lazy loading.
+    """
+    def __init__(self, name: str, builder: Callable[[], Callable], logger=None):
+        self._name = name
+        self._builder = builder
+        self._logger = logger
+        self._fn: Optional[Callable] = None
+
+    def _ensure(self) -> Callable:
+        if self._fn is None:
+            if self._logger:
+                self._logger.debug(f"LazyLoad: building interpolator '{self._name}'")
+            self._fn = self._builder()
+        return self._fn
+
+    def __call__(self, *args, **kwargs):
+        fn = self._ensure()
+        return fn(*args, **kwargs)
+
+
+class InterpolatorManager:
+    """
+    Parses YAML 'Functions' and provides lazy-callable interpolators.
+
+    - Parsing stage: stores specs only (no IO, no scipy work)
+    - Runtime stage: first call triggers CSV read + interpolator build
+    - Cache: built callables are cached for reuse in the same run
+
+    Suggested usage:
+      mgr = InterpolatorManager.from_yaml(cfg, yaml_dir, shared, logger)
+      funcs_dict = mgr.as_eval_funcs()     # inject into expression globals
+      # expression can call f_cut(x) directly
+    """
+
+    def __init__(self, yaml_dir: Path, shared=None, logger=None):
+        self._yaml_dir = Path(yaml_dir)
+        self._shared = shared
+        self._logger = logger
+
+        self._specs: Dict[str, InterpolatorSpec] = {}
+        self._lazy: Dict[str, LazyCallable] = {}
+        self._built: Dict[str, Callable] = {}
+
+    # -------------------------
+    # YAML parsing (no IO)
+    # -------------------------
+    @classmethod
+    def from_yaml(
+        cls,
+        config: Any,
+        yaml_dir: str | Path,
+        shared=None,
+        logger=None,
+        key: str = "Functions",
+    ) -> "InterpolatorManager":
+        """
+        Parse config[key] list into specs and register lazy wrappers.
+
+        Accepts either the full YAML config dict (with top-level key 'Functions'), or
+        directly a list (cfg['Functions']).
+        """
+        mgr = cls(yaml_dir=Path(yaml_dir), shared=shared, logger=logger)
+
+        # Accept either the full YAML config dict (preferred) or directly a list (cfg['Functions']).
+        if isinstance(config, list):
+            items = config
+        elif isinstance(config, dict):
+            items = config.get(key, []) or []
+        else:
+            items = []
+
+        for item in items:
+            spec = mgr._parse_one(item)
+            mgr.register(spec)
+        return mgr
+
+    def _parse_one(self, item: Dict[str, Any]) -> InterpolatorSpec:
+        """
+        Convert a single YAML dict -> InterpolatorSpec.
+
+        Expected YAML shape (example):
+          - name: f_cut
+            source: {type: csv, path: ./a.csv, x: x, y: y, sort_by: x, drop_duplicates: x}
+            method: interp1d
+            options: {kind: linear, bounds: clamp, fill_value: null, assume_sorted: false}
+
+        Top-level YAML key is 'Functions'.
+        """
+        # NOTE: only parse + validate keys here; do NOT read files.
+        if not isinstance(item, dict):
+            raise TypeError(f"Function spec must be a dict, got {type(item)}")
+
+        name = item.get("name", None)
+        if not name:
+            raise ValueError("Function spec missing required field 'name'")
+
+        source = item.get("source", None)
+        if not isinstance(source, dict):
+            raise ValueError(f"Function '{name}': missing/invalid 'source'")
+
+        stype = source.get("type", None)
+        if stype != "csv":
+            raise ValueError(f"Function '{name}': only source.type='csv' is supported (got {stype!r})")
+
+        path = source.get("path", None)
+        xcol = source.get("x", None)
+        ycol = source.get("y", None)
+        if not path or xcol is None or ycol is None:
+            raise ValueError(f"Function '{name}': source requires 'path', 'x', 'y'")
+
+        src = CSVSourceSpec(
+            path=str(path),
+            x=str(xcol),
+            y=str(ycol),
+            sort_by=source.get("sort_by", None),
+            drop_duplicates=source.get("drop_duplicates", None),
+        )
+
+        method = item.get("method", "interp1d")
+        if method != "interp1d":
+            raise ValueError(f"Function '{name}': only method='interp1d' is supported (got {method!r})")
+
+        opt0 = item.get("options", {}) or {}
+        if not isinstance(opt0, dict):
+            raise ValueError(f"Function '{name}': options must be a dict")
+
+        opt = Interp1DSpec(
+            kind=str(opt0.get("kind", "linear")),
+            bounds=str(opt0.get("bounds", "clamp")),
+            fill_value=opt0.get("fill_value", None),
+            assume_sorted=bool(opt0.get("assume_sorted", False)),
+        )
+
+        if opt.kind != "linear":
+            raise ValueError(f"Function '{name}': only options.kind='linear' is supported (got {opt.kind!r})")
+
+        return InterpolatorSpec(name=name, source=src, method=method, options=opt)
+
+    # -------------------------
+    # Registry
+    # -------------------------
+    def register(self, spec: InterpolatorSpec) -> None:
+        """
+        Register a spec and create a LazyCallable wrapper for it.
+        """
+        name = spec.name
+        if name in self._specs:
+            raise ValueError(f"Interpolator '{name}' already registered.")
+        self._specs[name] = spec
+
+        # wrap a builder closure; builder will do IO + build actual callable
+        self._lazy[name] = LazyCallable(name, builder=lambda n=name: self._build(n), logger=self._logger)
+
+    def get(self, name: str) -> Callable:
+        """
+        Return callable for this interpolator. (LazyCallable until built.)
+        """
+        if name in self._built:
+            return self._built[name]
+        if name in self._lazy:
+            return self._lazy[name]
+        raise KeyError(f"Unknown interpolator '{name}'")
+
+    def as_eval_funcs(self) -> Dict[str, Callable]:
+        """
+        Dict suitable for injection into expression evaluation globals.
+        Keys are interpolator names; values are LazyCallable instances.
+        """
+        return dict(self._lazy)
+
+    def summary(self) -> Dict[str, Any]:
+        """
+        Small diagnostic summary: registered / built status.
+        """
+        return {
+            "registered": sorted(self._specs.keys()),
+            "built": sorted(self._built.keys()),
+        }
+
+    # -------------------------
+    # Lazy build (IO + compute)
+    # -------------------------
+    def _build(self, name: str) -> Callable:
+        """
+        Build the real interpolator callable for `name`, cache it, and return it.
+
+        Responsibilities:
+          - read (x, y) from CSV (may use shared cache)
+          - construct interpolator according to method/options
+          - return a vectorized callable f(x) -> y
+        """
+        if name in self._built:
+            return self._built[name]
+        if name not in self._specs:
+            raise KeyError(f"Unknown interpolator '{name}'")
+
+        spec = self._specs[name]
+
+        # Load data
+        x, y = self._load_csv_xy(spec.source)
+
+        # Build callable
+        if spec.method != "interp1d":
+            raise ValueError(f"Function '{name}': unsupported method {spec.method!r}")
+
+        fn = self._make_interp1d(x, y, spec.options)
+        self._built[name] = fn
+        return fn
+
+    # -------------------------
+    # Helpers (placeholders)
+    # -------------------------
+    def _resolve_path(self, p: str) -> Path:
+        """
+        Resolve YAML-relative path or absolute path.
+        """
+        p = str(p)
+        if p.startswith("&JP/"):
+            # allow internal JP paths if needed; resolve relative to project root (yaml_dir's parent)
+            # but keep simple: treat as relative to yaml_dir for now.
+            p = p[4:]
+        path = Path(p).expanduser()
+        if not path.is_absolute():
+            path = (self._yaml_dir / path).resolve()
+        return path
+
+    def _load_csv_xy(self, spec: CSVSourceSpec) -> Tuple[Any, Any]:
+        """
+        Read/clean CSV and return arrays (x, y).
+        """
+        import pandas as _pd
+        import numpy as _np
+
+        csv_path = self._resolve_path(spec.path)
+        df = _pd.read_csv(csv_path)
+
+        # Optional sort/dedup on a specified column name
+        if spec.sort_by is not None and spec.sort_by in df.columns:
+            df = df.sort_values(by=spec.sort_by)
+
+        if spec.drop_duplicates is not None and spec.drop_duplicates in df.columns:
+            df = df.drop_duplicates(subset=spec.drop_duplicates, keep="first")
+
+        # Allow spec.x/spec.y to be either column names OR python expressions.
+        import math as _math
+        from ..inner_func import update_funcs as _update_funcs
+
+        local_vars = df.to_dict("series")
+        allowed_globals = _update_funcs({"np": _np, "math": _math})
+
+        def _eval_field(field: str):
+            if field in df.columns:
+                return _np.asarray(df[field].values, dtype=float)
+            # treat as expression
+            try:
+                arr = eval(field, allowed_globals, local_vars)
+                return _np.asarray(arr, dtype=float)
+            except Exception as e:
+                raise ValueError(
+                    f"CSV {csv_path}: cannot evaluate field '{field}'. "
+                    f"Not a column and eval failed: {e}"
+                )
+
+        x = _eval_field(spec.x)
+        y = _eval_field(spec.y)
+
+        if x.shape != y.shape:
+            raise ValueError(f"CSV {csv_path}: evaluated x/y have different shapes: {x.shape} vs {y.shape}")
+
+        # Ensure x is sorted for interpolation unless explicitly assumed sorted.
+        # Even if user sorted by another column, we still need monotonic x.
+        order = _np.argsort(x)
+        x = x[order]
+        y = y[order]
+
+        return x, y
+
+    def _make_interp1d(self, x, y, opt: Interp1DSpec) -> Callable:
+        """
+        Create interp1d-like callable based on opt.
+        """
+        import numpy as _np
+
+        x = _np.asarray(x, dtype=float)
+        y = _np.asarray(y, dtype=float)
+
+        if x.ndim != 1 or y.ndim != 1 or x.shape[0] < 2 or x.shape != y.shape:
+            raise ValueError("interp1d: x and y must be 1D arrays of the same length >= 2")
+
+        xmin = float(_np.min(x))
+        xmax = float(_np.max(x))
+
+        def _linear_extrap(xq: _np.ndarray) -> _np.ndarray:
+            # linear extrapolation using the first/last segments
+            yq = _np.interp(xq, x, y)
+            left = xq < xmin
+            right = xq > xmax
+            if left.any():
+                x0, x1 = x[0], x[1]
+                y0, y1 = y[0], y[1]
+                slope = (y1 - y0) / (x1 - x0)
+                yq[left] = y0 + slope * (xq[left] - x0)
+            if right.any():
+                x0, x1 = x[-2], x[-1]
+                y0, y1 = y[-2], y[-1]
+                slope = (y1 - y0) / (x1 - x0)
+                yq[right] = y1 + slope * (xq[right] - x1)
+            return yq
+
+        def f(xq):
+            xq = _np.asarray(xq, dtype=float)
+            if opt.bounds == "clamp":
+                xqc = _np.clip(xq, xmin, xmax)
+                return _np.interp(xqc, x, y)
+            elif opt.bounds == "extrapolate":
+                return _linear_extrap(xq)
+            elif opt.bounds == "nan":
+                yq = _np.interp(_np.clip(xq, xmin, xmax), x, y)
+                out = (xq < xmin) | (xq > xmax)
+                if out.any():
+                    yq = yq.astype(float, copy=False)
+                    yq[out] = _np.nan
+                return yq
+            elif opt.bounds == "error":
+                if _np.any((xq < xmin) | (xq > xmax)):
+                    raise ValueError("interp1d: query x is out of bounds")
+                return _np.interp(xq, x, y)
+            else:
+                # fallback
+                xqc = _np.clip(xq, xmin, xmax)
+                return _np.interp(xqc, x, y)
+
+        return f

jarvisplot-1.0.1.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: jarvisplot
+Version: 1.0.1
+Summary: JarvisPLOT: YAML-driven plotting engine
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: loguru
+Requires-Dist: pyyaml
+Requires-Dist: jsonschema
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+
+# JarvisPLOT
+
+JarvisPLOT is a lightweight, Python/Matplotlib-based plotting framework developed for **Jarvis-HEP**,  
+but it can also be used as a **standalone scientific plotting tool**.
+
+It provides a simple command-line interface (CLI) to generate publication-quality figures from YAML configuration files, with most layout and style decisions handled by predefined profiles and style cards.
+
+---
+
+## Command-Line Usage
+
+Display help information:
+
+```bash
+jplot -h
+```
+
+Run JarvisPLOT with one or more YAML configuration files:
+
+```bash
+jplot path/to/config.yaml
+```
+
+### Example: SUSYRun2 Ternary Plots
+
+```bash
+jplot ./bin/SUSYRun2_EWMSSM.yaml
+jplot ./bin/SUSYRun2_GEWMSSM.yaml
+```
+
+> **Note:** The data file paths inside the YAML files must be updated to match your local setup.
+
+---
+
+## Notes
+
+- Figures are saved automatically to the output paths defined in the YAML configuration.
+- Common output formats include PNG and PDF (backend-dependent).
+- JarvisPLOT works in headless environments (SSH, batch jobs) without any GUI backend.
+
+---
+
+## Requirements
+
+### Python
+- **Python ≥ 3.9** (tested on 3.9–3.12)
+
+### Required Packages
+- `numpy`
+- `pandas`
+- `matplotlib`
+- `pyyaml`
+- `jsonschema`
+- `scipy` — numerical utilities
+- `h5py` — required for loading HDF5 data files
+
+### Github Page
+[https://github.com/Pengxuan-Zhu-Phys/Jarvis-PLOT](https://github.com/Pengxuan-Zhu-Phys/Jarvis-PLOT)
+
+### Documentation
+[https://pengxuan-zhu-phys.github.io/Jarvis-Docs/](https://pengxuan-zhu-phys.github.io/Jarvis-Docs/)
+
+---
+
+## License
+
+MIT License

jarvisplot-1.0.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+jarvisplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvisplot/cli.py,sha256=QwVmR48yHPsGbGSWqNj8Pbo53nYaLSPrhMa3LPvsiNI,2543
+jarvisplot/client.py,sha256=vjcxT4Y9v8F0nfqId4ROSE0xbbZW7cv-rIxOwh2LzFk,115
+jarvisplot/config.py,sha256=edHNoumh4bDjzj7hP1dGM6chCz_El4qNPA_wL4M3LCQ,2282
+jarvisplot/core.py,sha256=7ekrBL9UejjUYYTub8zYh2aOvSiEyp7V4T8vjhuCHhM,8890
+jarvisplot/data_loader.py,sha256=QIN3NZPSl63xGSH_3C2upmj1-aTfkZrLY-oK6g8Lrz4,16740
+jarvisplot/inner_func.py,sha256=hQeoJzVeTVjIb8_qRbHPf0_5lj-y0QEdOZEy-Yowm88,4158
+jarvisplot/Figure/adapters.py,sha256=END12kkzmhnG_bJddfQ3CQy0P3DlrY5I6WRl2DfiKlU,28502
+jarvisplot/Figure/data_pipelines.py,sha256=4mOHyYEHkqUCsEvDL2X7l2hE9ya2HyE0rmVqJLJ6b9E,3348
+jarvisplot/Figure/figure.py,sha256=yPfKXiN-ahXuiR4x-xVAhzyRBoXdC41yofDAWF0S6a4,66593
+jarvisplot/Figure/helper.py,sha256=5CJtJrKhIn7h-uBe7QWL9s2BoMIU9-JLtLmSSs86F80,7424
+jarvisplot/Figure/load_data.py,sha256=U7dgJuHJJsLAonuFc0fMLbmWCJO5qnJsi4p6e3WrnSU,8997
+jarvisplot/Figure/cards/std_axes_adapter_config.json,sha256=lokkIg-QIBZQ-lJr28cRbFdlvGP9-cCd64UIF9mnpxg,478
+jarvisplot/cards/args.json,sha256=Rh4Qmd-Otsg4-IymPoMA5NqXLaPpajvNNezrdtliX_E,1439
+jarvisplot/cards/style_preference.json,sha256=WbkrIa4RwEaHuMmyP_QO3nkjaU8M6COAMjexOCr-AX8,901
+jarvisplot/cards/a4paper/1x1/ternary.json,sha256=kPz74R976P2HEl4e5yETFhukJIGHpekuH8LtkurXp94,69
+jarvisplot/cards/a4paper/2x1/rect.json,sha256=zZ4Yo7i0_b4qNZp30AFVnLsWMPk9jPBIYdaJQDoT1Pc,2767
+jarvisplot/cards/a4paper/2x1/rect5x1.json,sha256=uB4TcwxOIE2xnCeHLxCk_mS0M_ZMEP8pBuK_O6NX0a0,10318
+jarvisplot/cards/a4paper/2x1/rect_cmap.json,sha256=ZiWxYMbqJvwulfDLR4-njwzcZf_I3DfK7hhfePT-MIw,5125
+jarvisplot/cards/a4paper/2x1/ternary.json,sha256=hJl9B7o0Bg8Wl0InRo5PNyDc3FpPfdPmk7DmvQQNu6w,4051
+jarvisplot/cards/a4paper/2x1/ternary_cmap.json,sha256=Av6MuK9z3S2Vpfvmb0QyxS1b7y0bjsIUvc6elB1J3As,5335
+jarvisplot/cards/a4paper/4x1/rect.json,sha256=zZ4Yo7i0_b4qNZp30AFVnLsWMPk9jPBIYdaJQDoT1Pc,2767
+jarvisplot/cards/a4paper/4x1/rect_cmap.json,sha256=TuoT_D-D2HcsQGiab-3NFlP-XJUtP9qv0kPcyUiT7wI,4842
+jarvisplot/cards/a4paper/4x1/ternary.json,sha256=hJl9B7o0Bg8Wl0InRo5PNyDc3FpPfdPmk7DmvQQNu6w,4051
+jarvisplot/cards/a4paper/4x1/ternary_cmap.json,sha256=Av6MuK9z3S2Vpfvmb0QyxS1b7y0bjsIUvc6elB1J3As,5335
+jarvisplot/cards/colors/colormaps.json,sha256=mTiR9OmYjpYaby0F4jwddTbYNzfL86QkHECannTbYzQ,3839
+jarvisplot/cards/default/output.json,sha256=x562t9OPPG4p8fubUPJz2CEyw2GxQYVIEUMMQB_Klpg,135
+jarvisplot/cards/gambit/1x1/ternary.json,sha256=kPz74R976P2HEl4e5yETFhukJIGHpekuH8LtkurXp94,69
+jarvisplot/cards/gambit/2x1/rect_cmap.json,sha256=SrxBn3Z8vLWi4tnZvv8eXFYwzQKzZZ7V1Ea3DRjDsfI,5595
+jarvisplot/cards/gambit/2x1/ternary.json,sha256=hJl9B7o0Bg8Wl0InRo5PNyDc3FpPfdPmk7DmvQQNu6w,4051
+jarvisplot/cards/gambit/2x1/ternary_cmap.json,sha256=sBTeGq7DVUutRNalbzQqIlUQZXmzxC0Xobc3_Btdmhg,5871
+jarvisplot/cards/icons/JarvisHEP.png,sha256=iDXEeQhA6T7REjIoae6XEj619_z7IlWqhnY9JaLPAww,399549
+jarvisplot/cards/icons/gambit.png,sha256=z6BRjaVbnAMhtWzCEf53VCfEFPxoMbEYWsOT9ZNyfOE,246969
+jarvisplot/cards/icons/gambit_small.png,sha256=maQSLO4PPSn4_J9rqIqp0qvY4Rtpx9GiiPl7ONrieKk,83453
+jarvisplot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jarvisplot/utils/cmaps.py,sha256=2IKOUzsOZb8KReEggbNCNAdzS6IhWrcMMSUw03CunpM,9449
+jarvisplot/utils/interpolator.py,sha256=CG6Wi6BX2cAI-TdL0d51J9wXnjxawc4R_uPlNoXHfss,13126
+jarvisplot-1.0.1.dist-info/METADATA,sha256=wk9MzJuePhkdxrnd_bNLzAPNjYgsmF5uUOjGh0rjH34,1864
+jarvisplot-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jarvisplot-1.0.1.dist-info/entry_points.txt,sha256=1dvnP7V3PTjdtL3G8OIDEKopJlDFJccC0EzFKmvp4jM,49
+jarvisplot-1.0.1.dist-info/top_level.txt,sha256=Rvy30upSt2sE_reLghmQejiBTIo5t6HXLnMwIsiKWS8,11
+jarvisplot-1.0.1.dist-info/RECORD,,

jarvisplot-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jarvisplot-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jplot = jarvisplot.client:main

jarvisplot-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jarvisplot