pfb-model-spec 0.0.1__py3-none-any.whl

pfb_model_spec/__init__.py

@@ -0,0 +1,5 @@
+"""Model specification for pfb-imaging"""
+
+__version__ = "0.0.1"
+
+__all__ = ["__version__"]

pfb_model_spec/_container_image.py

@@ -0,0 +1 @@
+CONTAINER_IMAGE = "ghcr.io/landmanbester/pfb-model-spec:0.0.1"

pfb_model_spec/cabs/__init__.py

@@ -0,0 +1,27 @@
+"""Cab definitions for generated Stimela cabs."""
+
+from pathlib import Path
+
+CAB_DIR = Path(__file__).parent
+AVAILABLE_CABS = [p.stem for p in CAB_DIR.glob("*.yml")]
+
+
+def get_cab_path(name: str) -> Path:
+    """Get path to a cab definition.
+
+    Args:
+        name: Name of the cab (without .yml extension)
+
+    Returns:
+        Path to the cab YAML file
+
+    Raises:
+        FileNotFoundError: If the cab doesn't exist
+    """
+    cab_path = CAB_DIR / f"{name}.yml"
+    if not cab_path.exists():
+        raise FileNotFoundError(f"Cab not found: {name}")
+    return cab_path
+
+
+__all__ = ["CAB_DIR", "AVAILABLE_CABS", "get_cab_path"]

pfb_model_spec/cabs/onboard.yml

@@ -0,0 +1,10 @@
+cabs:
+  onboard:
+    flavour: python
+    command: pfb_model_spec.core.onboard.onboard
+    name: onboard
+    info:
+      Print setup instructions for CI/CD, PyPI publishing, and GitHub configuration.
+    image: ghcr.io/landmanbester/pfb-model-spec:0.0.1
+    inputs: {}
+    outputs: {}

pfb_model_spec/cli/__init__.py

@@ -0,0 +1,23 @@
+"""CLI for pfb-model-spec."""
+
+import typer
+
+app = typer.Typer(
+    name="pfbspec",
+    help="Model specification for pfb-imaging",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def callback() -> None:
+    """Model specification for pfb-imaging"""
+    pass
+
+
+# Register subcommands below. Imports go here (bottom) to avoid circular imports.
+from pfb_model_spec.cli.onboard import onboard  # noqa: E402
+
+app.command(name="onboard")(onboard)
+
+__all__ = ["app"]

pfb_model_spec/cli/onboard.py

@@ -0,0 +1,68 @@
+from typing import Annotated, Literal
+
+import typer
+from hip_cargo import StimelaMeta, stimela_cab
+
+
+@stimela_cab(
+    name="onboard",
+    info="Print setup instructions for CI/CD, PyPI publishing, and GitHub configuration.",
+)
+def onboard(
+    backend: Annotated[
+        Literal["auto", "native", "apptainer", "singularity", "docker", "podman"],
+        typer.Option(
+            help="Execution backend.",
+        ),
+        StimelaMeta(
+            skip=True,
+        ),
+    ] = "auto",
+    always_pull_images: Annotated[
+        bool,
+        typer.Option(
+            help="Always pull container images, even if cached locally.",
+        ),
+        StimelaMeta(
+            skip=True,
+        ),
+    ] = False,
+):
+    """
+    Print setup instructions for CI/CD, PyPI publishing, and GitHub configuration.
+    """
+    if backend == "native" or backend == "auto":
+        try:
+            # Pre-flight must_exist for remote URIs before dispatching.
+            from hip_cargo.utils.runner import preflight_remote_must_exist  # noqa: E402
+
+            preflight_remote_must_exist(
+                onboard,
+                dict(),
+            )
+
+            # Lazy import the core implementation
+            from pfb_model_spec.core.onboard import onboard as onboard_core  # noqa: E402
+
+            # Call the core function with all parameters
+            onboard_core()
+            return
+        except ImportError:
+            if backend == "native":
+                raise
+
+    # Resolve container image from installed package metadata
+    from hip_cargo.utils.config import get_container_image  # noqa: E402
+    from hip_cargo.utils.runner import run_in_container  # noqa: E402
+
+    image = get_container_image("pfb-model-spec")
+    if image is None:
+        raise RuntimeError("No Container URL in pfb-model-spec metadata.")
+
+    run_in_container(
+        onboard,
+        dict(),
+        image=image,
+        backend=backend,
+        always_pull_images=always_pull_images,
+    )

pfb_model_spec/core/__init__.py

@@ -0,0 +1 @@
+"""Core implementations for pfb-model-spec."""

pfb_model_spec/core/onboard.py

@@ -0,0 +1,181 @@
+def onboard():
+    """Print setup instructions for CI/CD, PyPI publishing, and GitHub configuration."""
+    print(
+        """
+================================================================================
+  pfb-model-spec — Setup Instructions
+================================================================================
+
+Follow these steps to complete the CI/CD and publishing setup for your project.
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 1: Create a GitHub Repository
+────────────────────────────────────────────────────────────────────────────────
+
+  First, install the GitHub CLI (gh) if you haven't already:
+
+    # macOS
+    brew install gh
+
+    # Ubuntu/Debian
+    sudo apt install gh
+
+    # Other platforms: https://github.com/cli/cli#installation
+
+  Then authenticate:
+
+    gh auth login
+
+  Push your project to GitHub:
+
+    gh repo create landmanbester/pfb-model-spec --public --source=. --push
+
+  Or create the repo manually at https://github.com/new and push:
+
+    git remote add origin git@github.com:landmanbester/pfb-model-spec.git
+    git push -u origin main
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 2: Set Up Trusted Publishing on PyPI
+────────────────────────────────────────────────────────────────────────────────
+
+  Use PyPI's "pending trusted publisher" feature to pre-authorize GitHub
+  Actions to publish your package. The PyPI project will be created
+  automatically on the first successful publish.
+
+  Go to: https://pypi.org/manage/account/publishing/
+
+  Scroll down to "Add a new pending publisher" and fill in:
+    PyPI project name: pfb-model-spec
+    Owner:             landmanbester
+    Repository:        pfb-model-spec
+    Workflow:          publish.yml
+    Environment:       pypi
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 3: Create GitHub Environment
+────────────────────────────────────────────────────────────────────────────────
+
+  The publish workflow requires a GitHub environment named "pypi".
+
+  Go to: https://github.com/landmanbester/pfb-model-spec/settings/environments
+
+  Click "New environment" and name it: pypi
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 4: Create a GitHub App (for Automated Cab Updates)
+────────────────────────────────────────────────────────────────────────────────
+
+  The update-cabs workflow needs to push commits to the repository. A GitHub
+  App is required so these commits can bypass branch protection rules.
+
+  a) Create the app:
+
+     Go to: https://github.com/settings/apps → "New GitHub App"
+
+     Settings:
+       Name:        pfb-model-spec-bot (or any name you like)
+       Homepage:    https://github.com/landmanbester/pfb-model-spec
+       Webhook:     Uncheck "Active" (not needed)
+       Permissions: Repository → Contents → Read & write
+       Where:       Only on this account
+
+  b) Generate a private key:
+
+     On the app page → "Generate a private key"
+     Save the downloaded .pem file.
+
+  c) Install the app on your repository:
+
+     On the app page → "Install App" → Select your repository.
+
+  d) Add secrets to your repository:
+
+     Go to: https://github.com/landmanbester/pfb-model-spec/settings/secrets/actions
+
+     Add two secrets:
+       APP_CLIENT_ID   → The Client ID shown on the app's settings page
+       APP_PRIVATE_KEY → The contents of the .pem file you downloaded
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 5: Set Up Branch Protection
+────────────────────────────────────────────────────────────────────────────────
+
+  Protect your default branch so all changes go through CI.
+
+  Go to: https://github.com/landmanbester/pfb-model-spec/settings/rules
+
+  Click "New ruleset" and configure:
+
+    Name:              Protect main
+    Enforcement:       Active
+    Target:            Default branch
+    Rules to enable:
+      - Require a pull request before merging
+      - Require status checks to pass (add: "Code Quality", "Tests")
+      - Block force pushes
+
+    Bypass list:
+      - Add your GitHub App (created in Step 4) so it can push
+        automated cab updates
+
+  Make sure to click "Create" to save the ruleset.
+
+────────────────────────────────────────────────────────────────────────────────
+  Step 6: Make Your First Release
+────────────────────────────────────────────────────────────────────────────────
+
+  When you're ready to publish to PyPI:
+
+    uv run tbump 0.0.0
+
+  This will:
+    1. Update version in pyproject.toml and __init__.py
+    2. Regenerate cab definitions with the release version
+    3. Commit, tag, and push
+    4. GitHub Actions will build and publish to PyPI and ghcr.io
+
+================================================================================
+  That's it! Your CI/CD pipeline is fully configured.
+================================================================================
+
+────────────────────────────────────────────────────────────────────────────────
+  Day-to-Day Development: Image Tag Workflow
+────────────────────────────────────────────────────────────────────────────────
+
+  The container image is stored in src/pfb_model_spec/_container_image.py
+  as the single source of truth for cab generation and container fallback
+  execution. The tag portion must stay in sync with your current context.
+
+  When you create a feature branch:
+
+    1. Edit src/pfb_model_spec/_container_image.py and change the tag:
+
+         CONTAINER_IMAGE = "ghcr.io/landmanbester/pfb-model-spec:my-feature"
+
+    2. Commit and develop as normal — pre-commit hooks will generate cab
+       definitions with the correct branch-specific image tag.
+
+  You do NOT need to reset the tag before merging. On merge to main,
+  the update-cabs workflow automatically:
+
+    - Resets the CONTAINER_IMAGE tag to "latest"
+    - Regenerates cab definitions
+    - Commits _container_image.py and cab YAML files
+
+  During releases, tbump updates the tag to the semantic version
+  (e.g. 0.1.0) via its before-commit hooks.
+
+────────────────────────────────────────────────────────────────────────────────
+
+NOTE: Once you've completed the setup steps above, you can safely delete the
+onboard command (cli/onboard.py and core/onboard.py) and remove it from
+cli/__init__.py.
+
+Add your own commands following the same pattern — define a CLI function
+with type hints and a @stimela_cab decorator, and Stimela cab definitions
+will be auto-generated from your CLI definitions via pre-commit hooks.
+
+For more details, see: https://github.com/landmanbester/hip-cargo#readme
+"""
+    )

pfb_model_spec/modelspec.py

@@ -0,0 +1,361 @@
+import numpy as np
+import sympy as sm
+import xarray as xr
+from scipy.interpolate import RegularGridInterpolator
+from sympy.parsing.sympy_parser import parse_expr
+from sympy.utilities.lambdify import lambdify
+
+specs = ["genesis", "exodus"]
+
+
+def fit_image_cube(time, freq, image, wgt=None, nbasist=None, nbasisf=None, method="poly", sigmasq=0):
+    """
+    Fit the time and frequency axes of an image cube where
+
+    time    - (ntime) time axis
+    freq    - (nband) frequency axis
+    image   - (ntime, nband, nx, ny) pixelated image
+    wgt     - (ntime, nband) optional per time and frequency weights
+    nbasist - number of time basis functions
+    nbasisf - number of frequency basis functions
+    method  - method to use for fitting (poly or Legendre)
+    sigmasq - optional regularisation term to add to the Hessian
+              to improve conditioning
+
+    method:
+    poly     - fit a monomials in time and frequency
+    Legendre - fit a Legendre polynomial in time and frequency
+
+    returns:
+    coeffs  - fitted coefficients
+    x_index, y_index  - pixel locations of non-zero pixels in the image
+    expr    - a string representing the symbolic expression describing the fit
+    params  - tuple of str, parameters to pass into function (excluding t and f)
+    tfunc   - function which scales the time domain appropriately for method
+    ffunc   - function which scales the frequency domain appropriately for method
+
+
+    The fit is performed in scaled coordinates (t=time/ref_time,f=freq/ref_freq)
+    """
+    ntime = time.size
+    nband = freq.size
+    ref_time = time[0]
+    ref_freq = freq[0]
+    import sympy as sm
+    from sympy.abc import a, f, t
+
+    if nbasist is None:
+        nbasist = ntime
+    else:
+        assert nbasist <= ntime
+    if nbasisf is None:
+        nbasisf = nband
+    else:
+        assert nbasisf <= nband
+
+    mask = np.any(image, axis=(0, 1))  # over t and f axes
+    x_index, y_index = np.where(mask)
+    ncomps = x_index.size
+
+    # components excluding zeros
+    beta = image[:, :, x_index, y_index].reshape(ntime * nband, ncomps)
+    if wgt is not None:
+        wgt = wgt.reshape(ntime * nband, 1)
+    else:
+        wgt = np.ones((ntime * nband, 1), dtype=float)
+
+    # nothing to fit
+    if ntime == 1 and nband == 1:
+        coeffs = beta
+        expr = a
+        params = (a,)
+    elif method == "poly":
+        wt = time / ref_time
+        tfunc = t / ref_time
+        xfit = np.tile(wt[:, None], (nband, nbasist)) ** np.arange(nbasist)
+        params = sm.symbols(f"t(0:{nbasist})")
+        expr = sum(co * t**i for i, co in enumerate(params))
+        # the costant offset will always be included since nbasist is at least one
+        if nband > 1:
+            wf = freq / ref_freq
+            ffunc = f / ref_freq
+            xf = np.tile(wf[:, None], (ntime, nbasisf - 1)) ** np.arange(1, nbasisf)
+            xfit = np.hstack((xfit, xf))
+            paramsf = sm.symbols(f"f(1:{nbasisf})")
+            expr += sum(co * f ** (i + 1) for i, co in enumerate(paramsf))
+            params += paramsf
+
+    elif method == "Legendre":
+        # scale to lie between -1,1 for stability
+        if ntime > 1:
+            tmax = time.max()
+            tmin = time.min()
+            wt = time - (tmax + tmin) / 2
+            wtmax = wt.max()
+            wt /= wtmax
+            # function to convert time to interp domain
+            tfunc = (t - (tmax + tmin) / 2) / wtmax
+        else:
+            wt = time
+            tfunc = t
+        xt = np.zeros((ntime, nbasist), dtype=float)
+        params = sm.symbols(f"t(0:{nbasist})")
+        if nbasist > 1:
+            expr = 0
+            for i in range(nbasist):
+                vals = np.polynomial.Legendre.basis(i)(wt)
+                xt[:, i] = vals
+                expr += sm.polys.orthopolys.legendre_poly(i, t) * params[i]
+        else:
+            xt[...] = 1.0
+            expr = params[0]
+        xfit = np.tile(xt, (nband, 1))
+        paramsf = sm.symbols(f"f(1:{nbasisf})")
+        if nband > 1:
+            xf = np.zeros((nband, nbasisf - 1))
+            fmax = freq.max()
+            fmin = freq.min()
+            wf = freq - (fmax + fmin) / 2
+            wfmax = wf.max()
+            wf /= wfmax
+            ffunc = (f - (fmax + fmin) / 2) / wfmax
+            for i in range(1, nbasisf):
+                vals = np.polynomial.Legendre.basis(i)(wf)
+                xf[:, i - 1] = vals
+                expr += sm.polys.orthopolys.legendre_poly(i, f) * paramsf[i - 1]
+            xf = np.tile(xf, (ntime, 1))
+            xfit = np.hstack((xfit, xf))
+            params += paramsf
+    else:
+        raise NotImplementedError(f"Method {method} not implemented")
+
+    dirty_coeffs = xfit.T.dot(wgt * beta)
+    hess_coeffs = xfit.T.dot(wgt * xfit)
+    # to improve conditioning
+    if sigmasq:
+        hess_coeffs += sigmasq * np.eye(hess_coeffs.shape[0])
+    coeffs = np.linalg.solve(hess_coeffs, dirty_coeffs)
+
+    return coeffs, x_index, y_index, str(expr), list(map(str, params)), str(tfunc), str(ffunc)
+
+
+def fit_image_fscube(freq, image, wgt=None, nbasisf=None, method="Legendre", sigmasq=0):
+    """
+    Fit the frequency axis of an image cube where
+
+    freq    - (nband,) frequency axis
+    image   - (nband, ncorr, nx, ny) pixelated image
+    wgt     - (nband, ncorr) optional per time and frequency weights
+    nbasisf - number of frequency basis functions
+    method  - method to use for fitting (poly or Legendre)
+    sigmasq - optional regularisation term to add to the Hessian
+              to improve conditioning
+
+    method:
+    poly     - fit a monomials to frequency axis
+    Legendre - fit a Legendre polynomial to frequency
+
+    returns:
+    coeffs  - (ncorr, nbasisf, ncomps) fitted coefficients
+    x_index, y_index  - (ncomps,) pixel locations of non-zero pixels in the image
+    expr    - a string representing the symbolic expression describing the fit
+    params  - tuple of str, parameters to pass into function (excluding t and f)
+    ffunc   - function which scales the frequency domain appropriately for method
+    """
+    nband = freq.size
+    ref_freq = freq[0]
+    import sympy as sm
+    from sympy.abc import f
+
+    if nbasisf is None:
+        nbasisf = nband
+    else:
+        assert nbasisf <= nband
+
+    nband, ncorr, nx, ny = image.shape
+    mask = np.any(image, axis=(0, 1))  # over freq and corr axes
+    x_index, y_index = np.where(mask)
+    ncomps = x_index.size
+
+    # components excluding zeros
+    beta = image[:, :, x_index, y_index].reshape(nband, ncorr, ncomps)
+    if wgt is not None:
+        wgt = wgt.reshape(nband, ncorr, 1)
+    else:
+        wgt = np.ones((nband, ncorr, 1), dtype=float)
+
+    params = sm.symbols(f"f(0:{nbasisf})")
+    if nband == 1:  # nothing to fit
+        coeffs = beta
+        expr = f
+        params = (f,)
+    elif method == "poly":
+        wf = freq / ref_freq
+        ffunc = f / ref_freq
+        xf = np.tile(wf[:, None], (1, nbasisf)) ** np.arange(nbasisf)
+        expr = sum(co * f**i for i, co in enumerate(params))
+
+    elif method == "Legendre":
+        xf = np.zeros((nband, nbasisf), dtype=float)
+        fmax = freq.max()
+        fmin = freq.min()
+        wf = freq - (fmax + fmin) / 2
+        wfmax = wf.max()
+        wf /= wfmax
+        ffunc = (f - (fmax + fmin) / 2) / wfmax
+        xf[:, 0] = 1.0
+        expr = params[0]
+        for i in range(1, nbasisf):
+            vals = np.polynomial.Legendre.basis(i)(wf)
+            xf[:, i] = vals
+            expr += sm.polys.orthopolys.legendre_poly(i, f) * params[i]
+    else:
+        raise NotImplementedError(f"Method {method} not implemented")
+
+    # fit each correlation separately
+    coeffs = np.zeros((ncorr, nbasisf, ncomps), dtype=beta.dtype)
+    for c in range(ncorr):
+        dirty_coeffs = xf.T.dot(wgt[:, c] * beta[:, c])
+        hess_coeffs = xf.T.dot(wgt[:, c] * xf)
+        # to improve conditioning
+        if sigmasq:
+            hess_coeffs += sigmasq * np.eye(hess_coeffs.shape[0])
+        coeffs[c] = np.linalg.solve(hess_coeffs, dirty_coeffs)
+
+    return coeffs, x_index, y_index, str(expr), list(map(str, params)), str(ffunc)
+
+
+def eval_coeffs_to_cube(time, freq, nx, ny, coeffs, x_index, y_index, expr, paramf, texpr, fexpr):
+    ntime = time.size
+    nfreq = freq.size
+
+    image = np.zeros((ntime, nfreq, nx, ny), dtype=float)
+    params = sm.symbols(("t", "f"))
+    params += sm.symbols(tuple(paramf))
+    symexpr = parse_expr(expr)
+    modelf = lambdify(params, symexpr)
+    texpr = parse_expr(texpr)
+    tfunc = lambdify(params[0], texpr)
+    fexpr = parse_expr(fexpr)
+    ffunc = lambdify(params[1], fexpr)
+    for i, tval in enumerate(time):
+        for j, fval in enumerate(freq):
+            image[i, j, x_index, y_index] = modelf(tfunc(tval), ffunc(fval), *coeffs)
+
+    return image
+
+
+def eval_coeffs_to_slice(
+    time,
+    freq,
+    coeffs,
+    x_index,
+    y_index,
+    expr,
+    paramf,
+    texpr,
+    fexpr,
+    nxi,
+    nyi,
+    cellxi,
+    cellyi,
+    x0i,
+    y0i,
+    nxo,
+    nyo,
+    cellxo,
+    cellyo,
+    x0o,
+    y0o,
+):
+    image_in = np.zeros((nxi, nyi), dtype=float)
+    params = sm.symbols(("t", "f"))
+    params += sm.symbols(tuple(paramf))
+    symexpr = parse_expr(expr)
+    modelf = lambdify(params, symexpr)
+    texpr = parse_expr(texpr)
+    tfunc = lambdify(params[0], texpr)
+    fexpr = parse_expr(fexpr)
+    ffunc = lambdify(params[1], fexpr)
+    image_in[x_index, y_index] = modelf(tfunc(time), ffunc(freq), *coeffs)
+
+    pix_area_in = cellxi * cellyi
+    pix_area_out = cellxo * cellyo
+    area_ratio = pix_area_out / pix_area_in
+
+    xin = (-(nxi // 2) + np.arange(nxi)) * cellxi + x0i
+    yin = (-(nyi // 2) + np.arange(nyi)) * cellyi + y0i
+    xo = (-(nxo // 2) + np.arange(nxo)) * cellxo + x0o
+    yo = (-(nyo // 2) + np.arange(nyo)) * cellyo + y0o
+
+    # how many pixels to pad by to extrapolate with zeros
+    xldiff = xin.min() - xo.min()
+    if xldiff > 0.0:
+        npadxl = int(np.ceil(xldiff / cellxi))
+    else:
+        npadxl = 0
+    yldiff = yin.min() - yo.min()
+    if yldiff > 0.0:
+        npadyl = int(np.ceil(yldiff / cellyi))
+    else:
+        npadyl = 0
+
+    xudiff = xo.max() - xin.max()
+    if xudiff > 0.0:
+        npadxu = int(np.ceil(xudiff / cellxi))
+    else:
+        npadxu = 0
+    yudiff = yo.max() - yin.max()
+    if yudiff > 0.0:
+        npadyu = int(np.ceil(yudiff / cellyi))
+    else:
+        npadyu = 0
+
+    do_pad = npadxl > 0
+    do_pad |= npadxu > 0
+    do_pad |= npadyl > 0
+    do_pad |= npadyu > 0
+    if do_pad:
+        image_in = np.pad(image_in, ((npadxl, npadxu), (npadyl, npadyu)), mode="constant")
+
+        xin = (-(nxi // 2 + npadxl) + np.arange(nxi + npadxl + npadxu)) * cellxi + x0i
+        nxi = nxi + npadxl + npadxu
+        yin = (-(nyi // 2 + npadyl) + np.arange(nyi + npadyl + npadyu)) * cellyi + y0i
+        nyi = nyi + npadyl + npadyu
+
+    do_interp = cellxi != cellxo
+    do_interp |= cellyi != cellyo
+    do_interp |= x0i != x0o
+    do_interp |= y0i != y0o
+    do_interp |= nxi != nxo
+    do_interp |= nyi != nyo
+    if do_interp:
+        interpo = RegularGridInterpolator((xin, yin), image_in, bounds_error=True, method="linear")
+        xx, yy = np.meshgrid(xo, yo, indexing="ij")
+        return interpo((xx, yy)) * area_ratio
+    else:
+        return image_in
+
+
+def model_from_mds(mds_name, freqs=None):
+    """
+    Evaluate component model at the original resolution
+    """
+    mds = xr.open_zarr(mds_name, chunks=None)
+    if freqs is None:
+        freqs = mds.freqs.values
+    else:
+        freqs = np.atleast_1d(freqs)
+    return eval_coeffs_to_cube(
+        mds.times.values,
+        freqs,
+        mds.npix_x,
+        mds.npix_y,
+        mds.coefficients.values,
+        mds.location_x.values,
+        mds.location_y.values,
+        mds.parametrisation,
+        mds.params.values,
+        mds.texpr,
+        mds.fexpr,
+    )

pfb_model_spec-0.0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: pfb-model-spec
+Version: 0.0.1
+Summary: Model specification for pfb-imaging
+Author: landmanbester
+Author-email: landmanbester <lbester@sarao.ac.za>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: hip-cargo>=0.2.0
+Requires-Dist: numpy ; extra == 'full'
+Requires-Dist: scipy ; extra == 'full'
+Requires-Dist: sympy ; extra == 'full'
+Requires-Dist: xarray ; extra == 'full'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/landmanbester/pfb-model-spec
+Project-URL: Repository, https://github.com/landmanbester/pfb-model-spec
+Project-URL: Bug Tracker, https://github.com/landmanbester/pfb-model-spec/issues
+Provides-Extra: full
+Description-Content-Type: text/markdown
+
+# pfb-model-spec
+
+Model specification for pfb-imaging
+
+## Installation
+
+```bash
+pip install pfb-model-spec
+```
+
+## Usage
+
+```bash
+pfbspec --help
+```

pfb_model_spec-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+pfb_model_spec/__init__.py,sha256=Z3wV_fwvYzgcGLu0NbF18YXJgq-fLbwidVT_UpFbAow,92
+pfb_model_spec/_container_image.py,sha256=tpecVjNH_3lboB2nF-jQsrDdg0_GBiZSMfmtgSbNF_A,63
+pfb_model_spec/cabs/__init__.py,sha256=7Jp91XKl-3QwF7sujSEetCay6gGwmv9EKFop6hVPpgw,634
+pfb_model_spec/cabs/onboard.yml,sha256=1QjyKeabkUpUvoeKrhzQvy8pW1eFhd7apyXQmSlXKvQ,284
+pfb_model_spec/cli/__init__.py,sha256=diaqF_mcnR69cdZHaQRhIGuCrYKQkv1vV6KgW65pfLo,459
+pfb_model_spec/cli/onboard.py,sha256=lnFPZGoCUmo457I8NqZf2Saol2DFZJENHHOSv8NXKYY,1987
+pfb_model_spec/core/__init__.py,sha256=lbBafo78iXfwsB4ndDWSh3VqDGw5dZArqqhXAe1MI2A,47
+pfb_model_spec/core/onboard.py,sha256=YK-HrYLrvg53YwMxkmkR7cVCsGw4Fu54lnoEo90Z2d0,9064
+pfb_model_spec/modelspec.py,sha256=v7xwUbKselmrn4YF_J_CxKGmwYamHEZ1wbkV_gS90lA,11796
+pfb_model_spec-0.0.1.dist-info/licenses/LICENSE,sha256=F-fIq4GmaOnJVwQL8rn7V2e1onkioYJzOciwvUQct8A,1070
+pfb_model_spec-0.0.1.dist-info/WHEEL,sha256=V5-3dKee3Zs8C4JP6swr6zdqriLsOpItBEQxe6_oWpY,81
+pfb_model_spec-0.0.1.dist-info/entry_points.txt,sha256=IJkT-MkLtukIS1LIMvqr4UfK8VIVkArGBOCJJstahY0,52
+pfb_model_spec-0.0.1.dist-info/METADATA,sha256=kPnSNqfnqbzHOUJsBCpANC57MTpaDyclYPG9vus1dis,1071
+pfb_model_spec-0.0.1.dist-info/RECORD,,

pfb_model_spec-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.18
+Root-Is-Purelib: true
+Tag: py3-none-any

pfb_model_spec-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pfbspec = pfb_model_spec.cli:app
+

pfb_model_spec-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 landmanbester
+
+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.