orblet 0.1.0__tar.gz

orblet-0.1.0/LICENSE

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

orblet-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: orblet
+Version: 0.1.0
+Summary: Atoms for Keplerian orbit analysis: forward models, likelihoods, design matrices and linear solves, period search, element conversion. Arrays in, results out.
+Author-email: Sahar Shahaf <sahar.shahaf@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/saharsh1/orblet
+Project-URL: Issues, https://github.com/saharsh1/orblet/issues
+Keywords: astronomy,binary-stars,orbits,astrometry,radial-velocity,kepler
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=2
+Requires-Dist: scipy<2,>=1.14
+Requires-Dist: astropy<8,>=7
+Requires-Dist: matplotlib<4,>=3.8
+Provides-Extra: sampling
+Requires-Dist: emcee<4,>=3.1; extra == "sampling"
+Provides-Extra: plots
+Requires-Dist: corner<3,>=2.2; extra == "plots"
+Provides-Extra: tables
+Requires-Dist: pandas<4,>=2; extra == "tables"
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.60; extra == "progress"
+Provides-Extra: all
+Requires-Dist: emcee<4,>=3.1; extra == "all"
+Requires-Dist: corner<3,>=2.2; extra == "all"
+Requires-Dist: pandas<4,>=2; extra == "all"
+Requires-Dist: tqdm>=4.60; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Dynamic: license-file
+
+# orblet <img src="https://raw.githubusercontent.com/saharsh1/orblet/main/docs/assets/orblet.png" alt="orblet" height="44" align="right">
+
+Atoms for Keplerian orbit analysis. Forward models, likelihoods, design
+matrices and linear solves, period search, element conversion, plotting —
+each a function that takes arrays and returns a result, with its units,
+frames and assumptions stated in its docstring.
+
+orblet is **not a solver**. It does not know what a Gaia epoch is, does not
+read files, and does not contact the network. You build the pipeline; orblet
+supplies the pieces.
+
+```python
+from orblet import ti_design_matrix, linear_solve_ti, ti_to_kepler
+
+X = ti_design_matrix(t_mjd, psi_rad, parallax_factor_al, P_days, e, tau, epoch_ref_mjd)
+fit = linear_solve_ti(along_scan_mas, sigma_mas, X)
+elements = ti_to_kepler({"A": fit.beta[0], "B": fit.beta[1], "F": fit.beta[2], "G": fit.beta[3]})
+```
+
+## Install
+
+orblet is not on PyPI yet. Install it from the repository:
+
+```
+pip install "orblet[all] @ git+https://github.com/saharsh1/orblet.git"
+```
+
+or from a local clone, which is the right choice while you are editing it:
+
+```
+git clone https://github.com/saharsh1/orblet.git
+pip install -e "./orblet[all]"
+```
+
+Drop `[all]` for the four core dependencies only — numpy, scipy, astropy,
+matplotlib — which is all a fresh install needs to run the atoms and the
+quickstarts. The extras (`emcee`, `corner`, `pandas`, `tqdm`; also available
+one at a time as `[sampling]`, `[plots]`, `[tables]`, `[progress]`) are each
+imported inside the one function that uses them, so a missing extra fails
+that call with a message naming it and leaves everything else working.
+
+## What is here
+
+| | |
+|---|---|
+| `orblet.model` | forward models: RV curve, along-scan astrometry, Thiele-Innes and Campbell photocentre orbits |
+| `orblet.likelihood` | Gaussian log-likelihoods with jitter, per channel |
+| `orblet.kepler` | the Kepler-equation solver |
+| `orblet.design` / `orblet.solve` | design-matrix builders and the generalised-least-squares linear solves for RV and astrometry |
+| `orblet.search` / `orblet.periodogram` | the Thiele-Innes frequency scan; Lomb-Scargle and phase-distance-correlation periodograms |
+| `orblet.elements` | Thiele-Innes → Campbell, NSS convention, element extraction from chains |
+| `orblet.priors` | prior classes and the log-prior composer |
+| `orblet.sampling` / `orblet.chain_stats` | emcee helpers; quantiles and circular summaries of chains |
+| `orblet.interpret` | companion mass and the astrometric mass-ratio function |
+| `orblet.simulate` | a synthetic-orbit simulator and a parallax-consistent cadence, for tests and tutorials |
+| `orblet.parallax` | per-direction parallax factors from a DE432s ephemeris |
+| `orblet.plotting` | orbit, residual, sky-overlay and corner plots |
+
+The front door — `from orblet import <name>` — exposes 35 names and imports
+nothing heavy: `import orblet` pulls in no scipy, no matplotlib, no astropy.
+Each name resolves on first use.
+
+## Conventions
+
+Every public function states them in its docstring. The ones that bite:
+
+- radial velocity: positive is receding; `omega` is the **primary's** argument of periastron
+- period in **days** at the public surface (Keplerian years only inside the Kepler solver)
+- `tau` is the periastron phase in `[0, 1)`; `tp = tau * P + epoch_ref_mjd`
+- astrometric amplitudes `A, B, F, G` are **photocentre** amplitudes in mas, positive-amplitude convention; the parallax term enters as `parallax_mas * parallax_factor_al`, additive
+- Gaia's `pmra` is already `mu_alpha*` — never apply `cos(dec)` again
+- **a seed is initialisation, never a prior**: a starting point for a sampler carries no evidence
+
+## Four laws, each a test
+
+1. A public name **is** the object it claims to be — no silent wrappers.
+2. The numerical core does not move: byte-identity baselines pin the forward
+   models, the likelihoods and the design columns.
+3. Conventions hold: RV sign, primary-frame ω, τ → tp, time scales.
+4. orblet imports nothing outside itself, the four dependencies and the
+   standard library.
+
+## Status
+
+Grew inside the `gaia-orbits` repository until 2026-09-24; developed here
+since, and consumed there as an installed dependency.
+
+Three simulator presets ship. `OrbitSimulator.bh1_like()` is the one the
+quickstarts use, through `load_simulated_inputs(scenario="bh1")`: an
+illustrative orbit on an invented sky position, with a cadence whose parallax
+factor is coupled to that position, so injecting and removing the parallax
+signal use the same array and closure is exact. `toy_orbit()` is a compact
+short-period orbit for quick smoke tests. `bh3_like()` carries orbital numbers
+rounded from a published system and is useful for a realistic-looking truth;
+pair it with `DemoParallaxConsistentCadence` for anything closure-grade. The
+`scenario=` parameter and the `bh1`/`toy` naming are slated to be simplified.
+
+## Licence
+
+MIT.

orblet-0.1.0/README.md

@@ -0,0 +1,100 @@
+# orblet <img src="https://raw.githubusercontent.com/saharsh1/orblet/main/docs/assets/orblet.png" alt="orblet" height="44" align="right">
+
+Atoms for Keplerian orbit analysis. Forward models, likelihoods, design
+matrices and linear solves, period search, element conversion, plotting —
+each a function that takes arrays and returns a result, with its units,
+frames and assumptions stated in its docstring.
+
+orblet is **not a solver**. It does not know what a Gaia epoch is, does not
+read files, and does not contact the network. You build the pipeline; orblet
+supplies the pieces.
+
+```python
+from orblet import ti_design_matrix, linear_solve_ti, ti_to_kepler
+
+X = ti_design_matrix(t_mjd, psi_rad, parallax_factor_al, P_days, e, tau, epoch_ref_mjd)
+fit = linear_solve_ti(along_scan_mas, sigma_mas, X)
+elements = ti_to_kepler({"A": fit.beta[0], "B": fit.beta[1], "F": fit.beta[2], "G": fit.beta[3]})
+```
+
+## Install
+
+orblet is not on PyPI yet. Install it from the repository:
+
+```
+pip install "orblet[all] @ git+https://github.com/saharsh1/orblet.git"
+```
+
+or from a local clone, which is the right choice while you are editing it:
+
+```
+git clone https://github.com/saharsh1/orblet.git
+pip install -e "./orblet[all]"
+```
+
+Drop `[all]` for the four core dependencies only — numpy, scipy, astropy,
+matplotlib — which is all a fresh install needs to run the atoms and the
+quickstarts. The extras (`emcee`, `corner`, `pandas`, `tqdm`; also available
+one at a time as `[sampling]`, `[plots]`, `[tables]`, `[progress]`) are each
+imported inside the one function that uses them, so a missing extra fails
+that call with a message naming it and leaves everything else working.
+
+## What is here
+
+| | |
+|---|---|
+| `orblet.model` | forward models: RV curve, along-scan astrometry, Thiele-Innes and Campbell photocentre orbits |
+| `orblet.likelihood` | Gaussian log-likelihoods with jitter, per channel |
+| `orblet.kepler` | the Kepler-equation solver |
+| `orblet.design` / `orblet.solve` | design-matrix builders and the generalised-least-squares linear solves for RV and astrometry |
+| `orblet.search` / `orblet.periodogram` | the Thiele-Innes frequency scan; Lomb-Scargle and phase-distance-correlation periodograms |
+| `orblet.elements` | Thiele-Innes → Campbell, NSS convention, element extraction from chains |
+| `orblet.priors` | prior classes and the log-prior composer |
+| `orblet.sampling` / `orblet.chain_stats` | emcee helpers; quantiles and circular summaries of chains |
+| `orblet.interpret` | companion mass and the astrometric mass-ratio function |
+| `orblet.simulate` | a synthetic-orbit simulator and a parallax-consistent cadence, for tests and tutorials |
+| `orblet.parallax` | per-direction parallax factors from a DE432s ephemeris |
+| `orblet.plotting` | orbit, residual, sky-overlay and corner plots |
+
+The front door — `from orblet import <name>` — exposes 35 names and imports
+nothing heavy: `import orblet` pulls in no scipy, no matplotlib, no astropy.
+Each name resolves on first use.
+
+## Conventions
+
+Every public function states them in its docstring. The ones that bite:
+
+- radial velocity: positive is receding; `omega` is the **primary's** argument of periastron
+- period in **days** at the public surface (Keplerian years only inside the Kepler solver)
+- `tau` is the periastron phase in `[0, 1)`; `tp = tau * P + epoch_ref_mjd`
+- astrometric amplitudes `A, B, F, G` are **photocentre** amplitudes in mas, positive-amplitude convention; the parallax term enters as `parallax_mas * parallax_factor_al`, additive
+- Gaia's `pmra` is already `mu_alpha*` — never apply `cos(dec)` again
+- **a seed is initialisation, never a prior**: a starting point for a sampler carries no evidence
+
+## Four laws, each a test
+
+1. A public name **is** the object it claims to be — no silent wrappers.
+2. The numerical core does not move: byte-identity baselines pin the forward
+   models, the likelihoods and the design columns.
+3. Conventions hold: RV sign, primary-frame ω, τ → tp, time scales.
+4. orblet imports nothing outside itself, the four dependencies and the
+   standard library.
+
+## Status
+
+Grew inside the `gaia-orbits` repository until 2026-09-24; developed here
+since, and consumed there as an installed dependency.
+
+Three simulator presets ship. `OrbitSimulator.bh1_like()` is the one the
+quickstarts use, through `load_simulated_inputs(scenario="bh1")`: an
+illustrative orbit on an invented sky position, with a cadence whose parallax
+factor is coupled to that position, so injecting and removing the parallax
+signal use the same array and closure is exact. `toy_orbit()` is a compact
+short-period orbit for quick smoke tests. `bh3_like()` carries orbital numbers
+rounded from a published system and is useful for a realistic-looking truth;
+pair it with `DemoParallaxConsistentCadence` for anything closure-grade. The
+`scenario=` parameter and the `bh1`/`toy` naming are slated to be simplified.
+
+## Licence
+
+MIT.

orblet-0.1.0/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "orblet"
+dynamic = ["version"]   # read from orblet.__version__, the single source
+description = "Atoms for Keplerian orbit analysis: forward models, likelihoods, design matrices and linear solves, period search, element conversion. Arrays in, results out."
+authors = [{name = "Sahar Shahaf", email = "sahar.shahaf@gmail.com"}]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11,<3.13"
+keywords = ["astronomy", "binary-stars", "orbits", "astrometry", "radial-velocity", "kepler"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Astronomy",
+]
+
+# The four. Everything in orblet imports at module scope from these and the
+# standard library only; tests/test_orblet_optional_dependencies.py enforces it.
+dependencies = [
+    "numpy>=2,<3",
+    "scipy>=1.14,<2",
+    "astropy>=7,<8",
+    "matplotlib>=3.8,<4",
+]
+
+[project.urls]
+Repository = "https://github.com/saharsh1/orblet"
+Issues = "https://github.com/saharsh1/orblet/issues"
+
+# Optional, each imported inside the one function that needs it, so the
+# package imports and its core paths run without any of them installed.
+[project.optional-dependencies]
+sampling = ["emcee>=3.1,<4"]        # orblet.sampling.run_emcee_chains
+plots = ["corner>=2.2,<3"]          # orblet.plotting.plot_orbit_corner
+tables = ["pandas>=2,<4"]           # orblet.chain_stats.chain_summary_table
+progress = ["tqdm>=4.60"]           # a progress bar over batch periodograms
+all = [
+    "emcee>=3.1,<4",
+    "corner>=2.2,<3",
+    "pandas>=2,<4",
+    "tqdm>=4.60",
+]
+dev = [
+    "pytest>=7",
+    "build>=1.0",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "orblet.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["orblet*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# Same opt-in contract as the parent project: plain `pytest` runs the fast
+# synthetic suite; `pytest -m slow` and `pytest -m benchmark` are explicit.
+addopts = "-m 'not slow and not benchmark'"
+markers = [
+    "slow: synthetic MCMC and closure tests; opt-in",
+    "coverage: calibration gates over many noise seeds; a subset of slow",
+    "benchmark: synthetic-data closure tests; opt-in",
+]

orblet-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

orblet-0.1.0/src/orblet/__init__.py

@@ -0,0 +1,207 @@
+"""orblet — a standalone orbit fitter: arrays in, orbital elements out.
+
+No mission, no data files, no network. orblet is a CONSUMER of data and never
+a producer: you hand it epochs, measurements and uncertainties, and it hands
+back a model, a likelihood, a solution. Where those arrays came from, and
+whether you are allowed to have them, is not orblet's business.
+
+Work the open way
+-----------------
+orblet ships ATOMS, not a black box. A Kepler solver, forward models, design
+matrices, the two linear cores, proposed likelihoods, default priors, a
+frequency search, the element conversions, the plots. You assemble the
+optimiser or sampler you actually want and plug your own target function into
+it; the default recipes are written out in the manuals and the example
+notebooks rather than hidden inside a wrapper.
+
+That is a deliberate trade. A one-line `fit()` is quicker to call and harder
+to trust: when it disagrees with your expectation you cannot see which step
+disagreed. Here every step is a function you can call, print and plot on its
+own.
+
+The shape of the thing
+----------------------
+    model       the forward models: elements and epochs -> observables
+    design      the design matrices, one column per linear parameter
+    solve       the linear cores — fix the geometry, solve the rest exactly
+    search      the frequency scan and the periodograms
+    likelihood  proposed likelihoods (Gaussian with jitter), not mandates
+    priors      prior classes, defaults, and the spec parser
+    prepare     epoch and time-scale handling
+    sampling    MCMC atoms: chains, stacking, R-hat, ESS, dead chains
+    elements    conversions between parameter conventions
+    residuals   the 5-parameter residual routine
+    parallax    observer position -> on-sky parallax factors
+    interpret   what a fitted orbit implies: masses, limits, flux ratios
+    plotting    the orbit, the corner, the sky plane
+    simulate    synthetic data with known truth, for testing and teaching
+
+Why the split matters: the geometry of a Keplerian orbit is non-linear, but
+once it is fixed the amplitudes enter LINEARLY and have a closed-form best
+fit. `solve` is that closed form. A sampler over a handful of non-linear
+parameters, with `solve` as its inner step, beats one over all of them.
+
+Import cost
+-----------
+Nothing heavy is imported when you `import orblet`. Every name below is
+resolved on first attribute access (PEP 562), so scipy, emcee and matplotlib
+arrive only if you touch something that needs them.
+
+**This package is under construction.** It is being assembled in place inside
+the gaia-orbits monorepo, one dependency layer at a time, before being
+extracted to its own repository. The modules arrive by relocation, unchanged.
+
+State of the move:  `docs/plans/2026-09-23-orblet-b1-chunks.md`
+Plan of record:     `docs/plans/2026-09-23-orblet-extraction-plan.md`
+Machine-checked:    `tests/_orblet_move_map.py`
+"""
+
+from __future__ import annotations
+
+import importlib
+
+# public name -> (module, attribute). One mechanism, one table, grouped by
+# what the name is FOR rather than by which file it happens to live in.
+#: The package version. The ONLY place it is written: the build reads it from
+#: here (``[tool.setuptools.dynamic]`` in orblet's pyproject), and the packaging
+#: test pins that the installed metadata agrees. A plain literal on purpose —
+#: setuptools parses it from the source without importing the package.
+__version__ = "0.1.0"
+
+_LAZY_EXPORTS: dict[str, tuple[str, str]] = {
+    # ── Design matrices: one column per linear parameter ───────────────
+    "rv_design_matrix": ("orblet.design.columns", "rv_design_matrix"),
+    "ti_design_matrix": ("orblet.design.columns", "ti_design_matrix"),
+    "acceleration_columns": ("orblet.design.columns", "acceleration_columns"),
+    "astrometric_5param_design_matrix": (
+        "orblet.solve.astrometry",
+        "astrometric_5param_design_matrix",
+    ),
+
+    # ── Linear cores: geometry fixed, amplitudes solved exactly ────────
+    "linear_solve_rv": ("orblet.solve.rv", "linear_solve_rv"),
+    "linear_solve_ti": ("orblet.solve.astrometry", "linear_solve_ti"),
+    "best_linear_params_rv": ("orblet.solve.rv", "best_linear_params_rv"),
+    "best_linear_params_ti": (
+        "orblet.solve.astrometry",
+        "best_linear_params_ti",
+    ),
+    "fit_astrometric_5param": (
+        "orblet.solve.astrometry",
+        "fit_astrometric_5param",
+    ),
+    "recover_K": ("orblet.solve.rv", "recover_K"),
+    "recover_omega": ("orblet.solve.rv", "recover_omega"),
+    "semi_amplitude_kms": ("orblet.model", "semi_amplitude_kms"),
+
+    # ── Searching for the period ───────────────────────────────────────
+    "scan_ti_frequency": ("orblet.search", "scan_ti_frequency"),
+
+    # ── Seeds: turning one solution into a starting point for the next ─
+    "compose_rv_seed": ("orblet.solve.rv", "compose_rv_seed"),
+    "compose_ti_seed": ("orblet.search", "compose_ti_seed"),
+    "ti_amplitude_chains": ("orblet.solve.astrometry", "ti_amplitude_chains"),
+    "mirror_inclination": ("orblet.elements", "mirror_inclination"),
+
+    # ── Epochs and time scales ─────────────────────────────────────────
+    "prepare_rv_for_orbit": ("orblet.prepare", "prepare_rv_for_orbit"),
+    "resolve_epochs_mjd": ("orblet.prepare", "resolve_epochs_mjd"),
+
+    # ── Where the observer is, as on-sky parallax factors ──────────────
+    "per_direction_parallax_factors": (
+        "orblet.parallax",
+        "per_direction_parallax_factors",
+    ),
+    "OBSERVER_GEOCENTRE": ("orblet.parallax", "OBSERVER_GEOCENTRE"),
+    "OBSERVER_L2": ("orblet.parallax", "OBSERVER_L2"),
+    "L2_OFFSET_AU": ("orblet.parallax", "L2_OFFSET_AU"),
+
+    # ── Element conversions and derived curves ─────────────────────────
+    "extract_orbital_elements": (
+        "orblet.elements",
+        "extract_orbital_elements",
+    ),
+    "ti_to_kepler": ("orblet.elements", "ti_to_kepler"),
+    "to_nss_convention": ("orblet.elements", "to_nss_convention"),
+    "compute_rv_model_curve": ("orblet.elements", "compute_rv_model_curve"),
+    "compute_residuals": ("orblet.elements", "compute_residuals"),
+
+    # ── Carrying one channel's chain into the other's prior ────────────
+    "a1_sini_from_rv_chain": ("orblet.rv_chain", "a1_sini_from_rv_chain"),
+    "astrometric_priors_from_rv_chain": (
+        "orblet.rv_chain",
+        "astrometric_priors_from_rv_chain",
+    ),
+    "predicted_k_kms_from_astrometric_chain": (
+        "orblet.rv_chain",
+        "predicted_k_kms_from_astrometric_chain",
+    ),
+
+    # ── Plots (matplotlib arrives here, not before) ────────────────────
+    "plot_orbit_fit": ("orblet.plotting", "plot_orbit_fit"),
+    "plot_orbit_corner": ("orblet.plotting", "plot_orbit_corner"),
+    "plot_astrometric_orbit": ("orblet.plotting", "plot_astrometric_orbit"),
+    "plot_astrometric_sky_overlay": (
+        "orblet.plotting",
+        "plot_astrometric_sky_overlay",
+    ),
+}
+
+
+def __getattr__(name: str):
+    """Resolve a public name on first access (PEP 562).
+
+    Keeps ``import orblet`` cheap: nothing below the front door is executed
+    until something is actually asked for.
+    """
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(
+            f"module {__name__!r} has no attribute {name!r}"
+        )
+    module_name, attr = target
+    return getattr(importlib.import_module(module_name), attr)
+
+
+def __dir__() -> list[str]:
+    return sorted(__all__)
+
+
+# Kept as a literal, same names as the table above.
+__all__ = [
+    "rv_design_matrix",
+    "ti_design_matrix",
+    "acceleration_columns",
+    "astrometric_5param_design_matrix",
+    "linear_solve_rv",
+    "linear_solve_ti",
+    "best_linear_params_rv",
+    "best_linear_params_ti",
+    "fit_astrometric_5param",
+    "recover_K",
+    "recover_omega",
+    "semi_amplitude_kms",
+    "scan_ti_frequency",
+    "compose_rv_seed",
+    "compose_ti_seed",
+    "ti_amplitude_chains",
+    "mirror_inclination",
+    "prepare_rv_for_orbit",
+    "resolve_epochs_mjd",
+    "per_direction_parallax_factors",
+    "OBSERVER_GEOCENTRE",
+    "OBSERVER_L2",
+    "L2_OFFSET_AU",
+    "extract_orbital_elements",
+    "ti_to_kepler",
+    "to_nss_convention",
+    "compute_rv_model_curve",
+    "compute_residuals",
+    "a1_sini_from_rv_chain",
+    "astrometric_priors_from_rv_chain",
+    "predicted_k_kms_from_astrometric_chain",
+    "plot_orbit_fit",
+    "plot_orbit_corner",
+    "plot_astrometric_orbit",
+    "plot_astrometric_sky_overlay",
+]