integrate_module 0.99.6__tar.gz → 0.99.9__tar.gz

{integrate_module-0.99.6/integrate_module.egg-info → integrate_module-0.99.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: integrate_module
-Version: 0.99.6
+Version: 0.99.9
 Summary: Localized probabilistic data integration
 Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
 License: MIT
@@ -21,6 +21,7 @@ Requires-Dist: psutil
 Requires-Dist: tqdm
 Requires-Dist: requests
 Requires-Dist: geoprior1d>=0.9
+Requires-Dist: shapely
 Requires-Dist: ga-aem-forward-win; platform_system == "Windows"
 Requires-Dist: jupyter>=1.0.0
 Requires-Dist: jupytext
@@ -28,9 +29,12 @@ Requires-Dist: ipykernel
 Requires-Dist: pandas
 Requires-Dist: pyvista
 Requires-Dist: litellm
-Requires-Dist: streamlit
 Requires-Dist: libaarhusxyz
 Requires-Dist: jax
+Requires-Dist: uvicorn[standard]
+Requires-Dist: python-fasthtml
+Requires-Dist: openpyxl
+Requires-Dist: httpx
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"
@@ -43,15 +47,15 @@ Requires-Dist: geopandas; extra == "examples"
 Requires-Dist: shapely; extra == "examples"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: nbsphinx; extra == "docs"
 Requires-Dist: sphinx-gallery; extra == "docs"
 Requires-Dist: pandoc; extra == "docs"
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: furo; extra == "docs"
+Requires-Dist: ghp-import; extra == "docs"
 Requires-Dist: tomli; python_version < "3.11" and extra == "docs"
 Provides-Extra: jax-cuda
-Requires-Dist: jax[cuda12]; extra == "jax-cuda"
+Requires-Dist: jax[cuda13]; extra == "jax-cuda"
 Dynamic: license-file
 
 # INTEGRATE Python Module
@@ -221,6 +225,23 @@ First install Homebrew, then run:
     pip install .
 
 
+## Alternative EM forward backends (anemone, SimPEG)
+
+GA-AEM is the default TDEM forward modeller. Two pure-Python alternatives can be
+selected with `method=` in `ig.forward_em()` / `ig.prior_data_em()` (or via the
+`EM_FORWARD_METHOD` environment variable):
+
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='ga-aem')    # default
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='anemone')   # PyTorch, GPU-capable
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='simpeg')    # SimPEG 1D layered TDEM
+
+* **anemone** (`pip install "integrate[anemone]"`): see `ANEMONE_VS_GAAEM_VS_AI.md`.
+* **SimPEG** (`pip install "integrate[simpeg]"`, or `uv pip install -e ../simpeg` from a
+  checkout): `ig.forward_simpeg()` / `ig.prior_data_simpeg()`. The `.gex` low-pass filters
+  and gate integration are applied by INTEGRATE on top of SimPEG's
+  `Simulation1DLayered`; agreement with GA-AEM is ~1 % (LM) / ~0.2 % (HM) on Daugaard tTEM,
+  see `SIMPEG_VS_GAAEM.md`.
+
 ## Development
 
 The `main` branch is the most stable, with less frequent updates but larger changes.

{integrate_module-0.99.6 → integrate_module-0.99.9}/README.md

@@ -165,6 +165,23 @@ First install Homebrew, then run:
     pip install .
 
 
+## Alternative EM forward backends (anemone, SimPEG)
+
+GA-AEM is the default TDEM forward modeller. Two pure-Python alternatives can be
+selected with `method=` in `ig.forward_em()` / `ig.prior_data_em()` (or via the
+`EM_FORWARD_METHOD` environment variable):
+
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='ga-aem')    # default
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='anemone')   # PyTorch, GPU-capable
+    ig.prior_data_em(f_prior_h5, file_gex=gex, method='simpeg')    # SimPEG 1D layered TDEM
+
+* **anemone** (`pip install "integrate[anemone]"`): see `ANEMONE_VS_GAAEM_VS_AI.md`.
+* **SimPEG** (`pip install "integrate[simpeg]"`, or `uv pip install -e ../simpeg` from a
+  checkout): `ig.forward_simpeg()` / `ig.prior_data_simpeg()`. The `.gex` low-pass filters
+  and gate integration are applied by INTEGRATE on top of SimPEG's
+  `Simulation1DLayered`; agreement with GA-AEM is ~1 % (LM) / ~0.2 % (HM) on Daugaard tTEM,
+  see `SIMPEG_VS_GAAEM.md`.
+
 ## Development
 
 The `main` branch is the most stable, with less frequent updates but larger changes.

integrate_module-0.99.9/frontend/__init__.py

@@ -0,0 +1,10 @@
+"""INTEGRATE — a FastHTML front end for the ``integrate`` module.
+
+Self-contained: nothing here is imported by the core ``integrate`` package,
+and every heavy computation is delegated to ``integrate`` via
+``frontend.services.integrate_api``. See ``frontend/FRONTEND.md`` for the
+full plan and TODO checklist.
+"""
+
+__all__ = ["__version__"]
+__version__ = "0.0.1"

integrate_module-0.99.9/frontend/__main__.py

@@ -0,0 +1,4 @@
+from frontend.app import main
+
+if __name__ == "__main__":
+    main()

integrate_module-0.99.9/frontend/app.py

@@ -0,0 +1,61 @@
+"""FastHTML application factory + ``integrate`` entry point."""
+
+from __future__ import annotations
+
+import secrets
+
+from fasthtml.common import FastHTML, Link, Meta, Script
+from starlette.staticfiles import StaticFiles
+
+from frontend.config import (
+    APP_TITLE, DEFAULT_HOST, DEFAULT_PORT, STATIC_DIR, get_workspace, set_workspace,
+)
+from frontend.pages import register_all
+
+_HDRS = (
+    Meta(charset="utf-8"),
+    Meta(name="viewport", content="width=device-width, initial-scale=1"),
+    Link(rel="stylesheet", href="/static/modernist.css"),
+    Link(rel="stylesheet", href="/static/app.css"),
+    Script(src="/static/htmx.min.js"),
+    Script(src="/static/picker.js", defer=True),
+)
+
+
+def create_app() -> FastHTML:
+    app = FastHTML(
+        hdrs=_HDRS,
+        default_hdrs=False,
+        pico=False,
+        surreal=False,
+        htmx=False,
+        title=APP_TITLE,
+        secret_key=secrets.token_hex(16),
+    )
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    register_all(app.route)
+    return app
+
+
+app = create_app()
+
+
+def main(argv: list[str] | None = None) -> None:
+    import argparse
+
+    import uvicorn
+
+    p = argparse.ArgumentParser(prog="integrate", description=APP_TITLE)
+    p.add_argument("--host", default=DEFAULT_HOST)
+    p.add_argument("--port", type=int, default=DEFAULT_PORT)
+    p.add_argument("--workspace", default=None, help="Folder with the project .h5 files (default: CWD).")
+    args = p.parse_args(argv)
+
+    set_workspace(args.workspace)
+    print(f"{APP_TITLE}  —  workspace: {get_workspace()}")
+    print(f"  http://{args.host}:{args.port}")
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

integrate_module-0.99.9/frontend/components.py

@@ -0,0 +1,256 @@
+"""Design-system component helpers.
+
+Thin wrappers that emit the classes defined in ``static/modernist.css``
+(and a little chrome from ``static/app.css``; the look mirrors the React UI
+in ``ui/``). Pages compose these; they do
+not hand-write class strings.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fasthtml.common import (
+    A, B, Button, Div, Form, H2, H4, Img, Input, Label, Main, Nav, Option, P,
+    Script, Select, Span, Table, Tbody, Td, Th, Thead, Title, Tr,
+)
+
+from frontend.config import APP_TITLE, get_workspace
+
+# (slug, number, label, children) — order defines the nav and the URL map.
+# `children` = ((slug, label), …); a parent with children is a section label,
+# not itself a link.
+PAGES: list[tuple[str, str, str, tuple]] = [
+    ("files", "01", "Data files", ()),
+    ("workflow", "00", "Workflow", (("workflow", "Simple Workflow"),)),
+    ("prior", "02", "Prior model",
+     (("prior", "Generic"), ("prior-wb", "WB"), ("geoprior", "geoprior1d"))),
+    ("forward", "03", "Forward", (("forward", "GA-AEM"), ("forward-bh", "Boreholes"))),
+    ("inversion", "04", "Inversion", ()),
+    ("results", "05", "Results", ()),
+    ("plotting", "06", "Plotting", (("plotting", "Library"), ("profile", "Profile line"))),
+    ("query", "—", "Query", ()),
+]
+
+# every reachable leaf slug -> (number, header label)
+_SLUG_META: dict[str, tuple[str, str]] = {}
+for _slug, _num, _label, _children in PAGES:
+    if _children:
+        for _cslug, _clabel in _children:
+            _SLUG_META[_cslug] = (_num, f"{_label} — {_clabel}")
+    else:
+        _SLUG_META[_slug] = (_num, _label)
+
+
+def leaf_slugs() -> list[str]:
+    out: list[str] = []
+    for slug, _num, _label, children in PAGES:
+        out.extend(c[0] for c in children) if children else out.append(slug)
+    return out
+
+
+def _href(slug: str) -> str:
+    return "/" if slug == "files" else f"/{slug}"
+
+
+def nav(active: str):
+    items = []
+    for slug, num, label, children in PAGES:
+        if not children:
+            items.append(A(Span(num, cls="num"), Span(label), href=_href(slug),
+                           cls="active" if slug == active else None))
+            continue
+        active_here = any(active == c[0] for c in children)
+        items.append(Div(
+            Div(Span(num, cls="num"), Span(label),
+                cls="wb-navgroup" + (" open" if active_here else "")),
+            *[A(Span(clabel), href=_href(cslug),
+                cls="wb-navchild" + (" active" if active == cslug else ""))
+              for cslug, clabel in children],
+        ))
+    return Nav(
+        Div(Div("ig", cls="logo-tile"),
+            Div(Div("INTEGRATE", cls="logo-name"),
+                Div("probabilistic integration", cls="logo-sub")),
+            cls="wordmark"),
+        *items,
+        Div(cls="spacer"),
+        Span(str(get_workspace()), cls="ws", title=str(get_workspace())),
+        cls="wb-nav",
+    )
+
+
+def _subdirs(path: Path) -> list[Path]:
+    try:
+        return sorted(
+            (d for d in path.iterdir() if d.is_dir() and not d.name.startswith(".")),
+            key=lambda d: d.name.lower(),
+        )[:16]
+    except OSError:
+        return []
+
+
+def _has_h5(path: Path) -> bool:
+    try:
+        return any(p.suffix.lower() == ".h5" for p in path.iterdir())
+    except OSError:
+        return False
+
+
+def workspace_bar(*, editing: bool = False, error: str | None = None):
+    """Top strip: current working folder + a Change control.
+
+    Not editing -> path + "Change…". Editing -> a plain POST form to
+    ``/workspace`` (full reload on success) with a text field and quick-pick
+    buttons for the parent and sub-folders.
+    """
+    cur = get_workspace()
+
+    if not editing:
+        return Div(
+            Span("WORKING FOLDER", cls="wb-eyebrow"),
+            Span(str(cur), cls="path"),
+            btn("Change…", kind="ghost",
+                hx_get="/workspace/edit", hx_target="#wb-ws-bar", hx_swap="outerHTML"),
+            id="wb-ws-bar", cls="wb-wsbar",
+        )
+
+    picks = []
+    parent = cur.parent
+    if parent != cur:
+        picks.append(Button("../  " + parent.name, name="path", value=str(parent),
+                            type="submit", cls="pick", title=str(parent)))
+    for d in _subdirs(cur):
+        mark = " ●" if _has_h5(d) else ""
+        picks.append(Button(d.name + mark, name="path", value=str(d),
+                            type="submit", cls="pick", title=str(d)))
+
+    return Div(
+        Form(
+            Span("WORKING FOLDER", cls="wb-eyebrow"),
+            Input(name="path_text", value=str(cur), cls="input", type="text",
+                  placeholder="/absolute/path/to/folder"),
+            btn("Use folder", kind="primary", type="submit"),
+            btn("Cancel", kind="secondary",
+                hx_get="/workspace/cancel", hx_target="#wb-ws-bar", hx_swap="outerHTML"),
+            (error_box(error) if error else Span()),
+            Div(*picks, cls="picks") if picks else Span(),
+            method="post", action="/workspace",
+            hx_post="/workspace", hx_target="#wb-ws-bar", hx_swap="outerHTML",
+        ),
+        id="wb-ws-bar", cls="wb-wsbar editing",
+    )
+
+
+def page_header(slug: str):
+    num, label = _SLUG_META.get(slug, ("—", slug.title()))
+    counter = label if num == "—" else f"{num} — {label}"
+    return Div(
+        Span("INTEGRATE", cls="mark"),
+        Span(counter, cls="counter"),
+        cls="wb-head",
+    )
+
+
+def shell(active: str, *body):
+    """Full page: (Title, shell div). Return this from a GET route."""
+    _slug_num, label = _SLUG_META.get(active, ("—", active.title()))
+    return (
+        Title(f"{label} · {APP_TITLE}"),
+        Div(
+            nav(active),
+            Main(workspace_bar(), page_header(active), *body, cls="wb-main"),
+            cls="wb-shell",
+        ),
+    )
+
+
+# --------------------------------------------------------------------------- #
+# atoms
+# --------------------------------------------------------------------------- #
+def btn(label, *, kind: str = "secondary", block: bool = False, **kw):
+    cls = f"btn btn-{kind}" + (" btn-block" if block else "")
+    return Button(label, cls=cls, type=kw.pop("type", "button"), **kw)
+
+
+def tag(text: str):
+    kind = {
+        "DATA": "tag-warn",
+        "PRIOR": "tag-info",
+        "POSTERIOR": "tag-accent",
+        "UNKNOWN": "tag-neutral",
+        "UNREADABLE": "tag-danger",
+    }.get(str(text).upper(), "tag-neutral")
+    return Span(text, cls=f"tag {kind}")
+
+
+def field(label: str, control):
+    return Div(Label(label), control, cls="field")
+
+
+def text_input(name: str, value: str = "", **kw):
+    return Input(name=name, value=value, cls="input", type="text", **kw)
+
+
+def select(name: str, options, value: str | None = None, **kw):
+    opts = [
+        Option(o, value=o, selected=(o == value)) if not isinstance(o, tuple)
+        else Option(o[1], value=o[0], selected=(o[0] == value))
+        for o in options
+    ]
+    return Select(*opts, name=name, cls="input", **kw)
+
+
+def seg(name: str, options: list[tuple[str, str]], value: str, **kw):
+    """Segmented control. ``options`` = [(value, label), ...]."""
+    parts = []
+    for val, lbl in options:
+        parts.append(
+            Label(
+                Input(type="radio", name=name, value=val, checked=(val == value)),
+                Span(lbl),
+                cls="seg-opt",
+            )
+        )
+    return Div(*parts, cls="seg", **kw)
+
+
+def stat(label: str, value):
+    return Div(Div(label, cls="l"), Div(str(value), cls="v"), cls="wb-stat")
+
+
+def stat_grid(*stats, cols: int | None = None):
+    n = cols or len(stats) or 1
+    return Div(*stats, cls="wb-stats",
+               style=f"grid-template-columns:repeat({n},minmax(0,1fr));")
+
+
+def eyebrow(text: str):
+    return Div(text, cls="wb-eyebrow")
+
+
+def figure_panel(eyebrow_text: str, img_url: str | None, placeholder: str, action=None, *, tall: bool = False):
+    head = Div(
+        eyebrow(eyebrow_text),
+        action if action is not None else Span(),
+        style="display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px;",
+    )
+    from fasthtml.common import Img
+
+    # `tall`: show the image at its natural size (scrolls) rather than fitting
+    # a fixed 260px box — for multi-panel plots like plot_profile.
+    body = Img(src=img_url, alt=eyebrow_text) if img_url else Span(placeholder, cls="wb-empty")
+    return Div(head, Div(body, cls="wb-figure-tall" if tall else "wb-figure"), cls="wb-panel")
+
+
+def error_box(message: str):
+    return Div(message, cls="wb-err")
+
+
+__all__ = [
+    "PAGES", "shell", "page_header", "nav", "workspace_bar", "btn", "tag", "field",
+    "text_input", "select", "seg", "stat", "stat_grid", "eyebrow", "figure_panel", "error_box",
+    # re-export common FT for pages
+    "Div", "Span", "P", "H2", "H4", "Form", "Table", "Thead", "Tbody", "Tr",
+    "Th", "Td", "A", "Script",
+]

integrate_module-0.99.9/frontend/config.py

@@ -0,0 +1,48 @@
+"""Paths and runtime configuration for the frontend.
+
+The one knob that matters is the *workspace* — the directory holding the
+project's ``.h5`` (and ``.gex`` / ``.xlsx``) files. Everything the UI reads or
+writes is resolved relative to it.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+PKG_DIR = Path(__file__).resolve().parent
+STATIC_DIR = PKG_DIR / "static"
+FIGURES_DIR = STATIC_DIR / "figures"
+# Scratch area for throwaway artefacts (geoprior1d live-preview .xlsx / .h5).
+# Never the workspace — previews must not touch the user's real files.
+SCRATCH_DIR = PKG_DIR / "_scratch"
+
+APP_TITLE = "INTEGRATE"
+DEFAULT_PORT = 8051
+DEFAULT_HOST = "127.0.0.1"
+
+
+def resolve_workspace(explicit: str | os.PathLike | None = None) -> Path:
+    """Resolve the workspace directory.
+
+    Priority: explicit argument > ``WB_WORKSPACE`` > ``INTEGRATE_WORKSPACE`` >
+    current working directory.
+    """
+    for cand in (explicit, os.environ.get("WB_WORKSPACE"), os.environ.get("INTEGRATE_WORKSPACE")):
+        if cand:
+            return Path(cand).expanduser().resolve()
+    return Path.cwd().resolve()
+
+
+# Set once by app.main() / create_app(); read via get_workspace().
+_WORKSPACE: Path | None = None
+
+
+def set_workspace(path: str | os.PathLike | None) -> Path:
+    global _WORKSPACE
+    _WORKSPACE = resolve_workspace(path)
+    return _WORKSPACE
+
+
+def get_workspace() -> Path:
+    return _WORKSPACE if _WORKSPACE is not None else resolve_workspace(None)

integrate_module-0.99.9/frontend/pages/__init__.py

@@ -0,0 +1,33 @@
+"""Page modules. Each exposes ``register(rt)`` which adds its routes.
+
+Order and slugs are defined by ``frontend.components.PAGES``.
+"""
+
+from __future__ import annotations
+
+from frontend.pages import (
+    borehole, files, forward, geoprior, inversion, plotting, prior, profile,
+    query, results, stubs, workflow, workspace_ui,
+)
+
+# slugs with a real page module (stubs.py covers the rest)
+IMPLEMENTED = {
+    "files", "prior", "prior-wb", "geoprior", "forward", "forward-bh", "inversion",
+    "results", "plotting", "profile", "query", "workflow",
+}
+
+
+def register_all(rt) -> None:
+    workspace_ui.register(rt)
+    files.register(rt)
+    prior.register(rt)
+    geoprior.register(rt)
+    forward.register(rt)
+    borehole.register(rt)
+    inversion.register(rt)
+    results.register(rt)
+    plotting.register(rt)
+    profile.register(rt)
+    query.register(rt)
+    workflow.register(rt)
+    stubs.register(rt, skip=IMPLEMENTED)

integrate_module-0.99.9/frontend/pages/_forms.py

@@ -0,0 +1,72 @@
+"""Tiny declarative parameter-form helper shared by the job pages.
+
+``F(name, label, kind, default)`` where ``kind`` is one of:
+  "int" | "float" | "str" | "bool" | ("select", [options]) | ("h5", [classes]) | "gex"
+``field_grid`` renders a ``.wb-fields`` grid; ``cast`` coerces one submitted value.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fasthtml.common import Div, Input, Label, Span
+
+from frontend.components import field, select, text_input
+from frontend.services import integrate_api as api
+
+
+@dataclass(frozen=True)
+class F:
+    name: str
+    label: str
+    kind: object
+    default: str = ""
+
+
+def _control(f: F, value: str):
+    k = f.kind
+    if isinstance(k, tuple) and k[0] == "select":
+        return select(f.name, list(k[1]), value=value)
+    if isinstance(k, tuple) and k[0] == "h5":
+        opts = api.list_h5_by_class(*k[1]) or ["(none)"]
+        return select(f.name, opts, value=value or opts[0])
+    if k in ("gex", "system", "json", "priordata"):
+        opts = {
+            "gex": api.list_gex,
+            "system": api.list_system_files,
+            "json": api.list_json,
+            "priordata": api.list_prior_with_data,
+        }[k]() or ["(none)"]
+        return select(f.name, opts, value=value or opts[0])
+    if k == "bool":
+        checked = str(value).lower() in ("1", "true", "on", "yes")
+        return Label(
+            Input(type="checkbox", name=f.name, value="1", checked=checked),
+            Span(cls="dot"),
+            " " + f.label, cls="radio",
+        )
+    return text_input(f.name, value)
+
+
+def field_grid(specs: list[F], values: dict | None = None):
+    values = values or {}
+    cells = []
+    for f in specs:
+        v = values.get(f.name, f.default)
+        if f.kind == "bool":
+            cells.append(Div(_control(f, v), cls="wb-boolfield"))
+        else:
+            cells.append(field(f.label, _control(f, v)))
+    return Div(*cells, cls="wb-fields")
+
+
+def cast(f: F, raw) -> object:
+    s = str(raw).strip()
+    try:
+        if f.kind == "int":
+            return int(float(s or f.default or "0"))
+        if f.kind == "float":
+            return float(s or f.default or "0")
+    except ValueError:
+        return f.default
+    return s