lunar-toolkit 0.1.0__tar.gz → 0.1.0.dev1__tar.gz

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lunar-toolkit
-Version: 0.1.0
+Version: 0.1.0.dev1
 Summary: Find, download and process lunar orbital imagery (LROC, ShadowCam, Kaguya TC) and build stereo and shape-from-shading DEMs with ISIS + ASP
 License-Expression: BSD-3-Clause
 Keywords: moon,lroc,shadowcam,kaguya,isis,ames-stereo-pipeline,shape-from-shading,dem

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/asp.py

@@ -51,7 +51,7 @@ def bundle_adjust(
     onto become ``--mapprojected-data``, which finds matches between images of
     very different illumination.  Returns *out_prefix*.
 
-    Raises :class:`~lunar_toolkit.tools.ToolError` when the run writes no fresh
+    Raises [`ToolError`][lunar_toolkit.tools.ToolError] when the run writes no fresh
     ``.adjust`` file for some image: ASP exits 0 even when it finds nothing to
     optimize ("No points to optimize ... Cannot continue").
     """

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/cli/_jobs.py

@@ -66,7 +66,7 @@ class Job:
         return self._cancel.is_set()
 
     def check(self) -> None:
-        """Raise :class:`Cancelled` if the job was cancelled."""
+        """Raise `Cancelled` if the job was cancelled."""
         if self._cancel.is_set():
             raise Cancelled()
 
@@ -101,7 +101,8 @@ class Job:
         )  # fmt: skip
 
     def on_bytes(self, name: str, done: int, total: int | None) -> None:
-        """Download progress callback (:data:`lunar_toolkit.downloader.Progress`)."""
+        """Download progress callback
+        ([`lunar_toolkit.downloader.Progress`][lunar_toolkit.downloader.Progress])."""
         self.check()
         if done < 0:
             self.update(stage="Waiting: the host asked us to slow down", rate=None, eta=None)
@@ -213,7 +214,7 @@ class JobManager:
             return job
 
     def wait(self, version: int, timeout: float) -> int:
-        """Block until :attr:`version` differs from *version* (or *timeout* / close); the new version."""
+        """Block until `version` differs from *version* (or *timeout* / close); the new version."""
         with self._cond:
             self._cond.wait_for(lambda: self.version != version or self.closed, timeout)
             return self.version

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/cli/_status.py

@@ -330,7 +330,7 @@ def redact(obj: Any) -> Any:
 
 
 class StatusCache:
-    """``/api/status`` documents, rebuilt at most every :data:`CACHE_SECONDS` (or on refresh)."""
+    """``/api/status`` documents, rebuilt at most every `CACHE_SECONDS` (or on refresh)."""
 
     def __init__(self, dirs: StatusDirs) -> None:
         self.dirs = dirs

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/cli/_utils.py

@@ -82,7 +82,8 @@ def region_args(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def ode_filters(args: argparse.Namespace) -> dict[str, Any]:
-    """:meth:`OdeClient.search` filters from ``--inc`` / ``--emi`` / ``--phase`` / ``--time``."""
+    """[`OdeClient.search`][lunar_toolkit.ode.OdeClient.search] filters from ``--inc`` / ``--emi`` /
+    ``--phase`` / ``--time``."""
     return {
         "incidence": tuple(args.inc) if args.inc else None,
         "emission": tuple(args.emi) if args.emi else None,

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/cli/serve.py

@@ -238,7 +238,7 @@ def _local_host_header(host: str) -> bool:
 
 @dataclass
 class ServerConfig:
-    """What a :class:`LunarServer` serves and where its jobs write."""
+    """What a `LunarServer` serves and where its jobs write."""
 
     data_dir: Path
     explicit_dir: Path | None = None
@@ -651,7 +651,7 @@ def _regions() -> dict[str, Any]:
 
 
 def make_server(args: argparse.Namespace) -> tuple[LunarServer, ServerConfig]:
-    """Bind a :class:`LunarServer` from the shared options (ValueError for a bad option)."""
+    """Bind a `LunarServer` from the shared options (ValueError for a bad option)."""
     import os
 
     from ..config import RUNS_DIR_ENV

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/config.py

@@ -35,9 +35,10 @@ class ConfigError(ValueError):
 
 @dataclass
 class RunConfig:
-    """Everything a ``lunar sfs`` run needs: inputs, region and the :class:`SfsConfig`.
+    """Everything a ``lunar sfs`` run needs: inputs, region and the
+    [`SfsConfig`][lunar_toolkit.sfs.SfsConfig].
 
-    In YAML the run keys below and the :class:`SfsConfig` fields share one flat
+    In YAML the run keys below and the [`SfsConfig`][lunar_toolkit.sfs.SfsConfig] fields share one flat
     mapping.  Relative paths are relative to the current directory.
 
     Parameters
@@ -52,11 +53,11 @@ class RunConfig:
         Prior DEM path, or ``"pgda"`` for the region's PGDA LOLA 5 m DEM (the
         default with a *region*).
     region : str or int, optional
-        Artemis III region (:func:`lunar_toolkit.reference.get_region`): sets
+        Artemis III region ([`lunar_toolkit.reference.get_region`][lunar_toolkit.reference.get_region]): sets
         the ``projwin`` (its ROI, or a *crop_km* window), ``region_id`` and the
         image search AOI.
     crop_km : float, optional
-        Side of a square window at the region centre (:func:`~lunar_toolkit.reference.crop_window`).
+        Side of a square window at the region centre ([`crop_window`][lunar_toolkit.reference.crop_window]).
     crop_center : (lat, lon), optional
         Centre of that window (default: the ROI centre).
     aoi : str, optional
@@ -71,7 +72,7 @@ class RunConfig:
         stereo convergence for registration, and ``max_sfs_slew`` keeps them out of SfS.
     max_images : int, optional
         Cap on the searched images before download (stereo pairs + illumination coverage;
-        :func:`lunar_toolkit.sfs.cap_candidates`).
+        [`lunar_toolkit.sfs.cap_candidates`][lunar_toolkit.sfs.cap_candidates]).
     pgda_dir : Path, optional
         Where PGDA files are downloaded (default: the reference cache).
     data_dir : Path, optional
@@ -157,7 +158,7 @@ def _coerce(key: str, value: Any, hint: Any) -> Any:
 
 
 def from_dict(data: Mapping[str, Any], source: str = "config") -> RunConfig:
-    """A validated :class:`RunConfig` from a flat mapping (keys as in :data:`KEYS`).
+    """A validated [`RunConfig`][lunar_toolkit.config.RunConfig] from a flat mapping (keys as in `KEYS`).
 
     Raises
     ------
@@ -245,7 +246,7 @@ def dump_config(cfg: RunConfig, path: Path | None = None) -> str:
 
 
 def config_hash(cfg: RunConfig) -> str:
-    """SHA-256 of the settings (canonical JSON of :func:`to_dict`)."""
+    """SHA-256 of the settings (canonical JSON of [`to_dict`][lunar_toolkit.config.to_dict])."""
     return hashlib.sha256(json.dumps(to_dict(cfg), sort_keys=True).encode()).hexdigest()
 
 

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/constants.py

@@ -145,7 +145,8 @@ def get_data_dir() -> Path:
 
 
 def find_parquet(name: str, data_dir: Path | None = None) -> Path:
-    """Path of Parquet database *name* in *data_dir* (default: :func:`get_data_dir`)."""
+    """Path of Parquet database *name* in *data_dir* (default:
+    [`get_data_dir`][lunar_toolkit.constants.get_data_dir])."""
     return Path(data_dir or get_data_dir()) / name
 
 

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/downloader.py

@@ -37,7 +37,8 @@ _PROGRESS: contextvars.ContextVar[Progress | None] = contextvars.ContextVar("dow
 
 @contextlib.contextmanager
 def report_progress(callback: Progress) -> Iterator[None]:
-    """Send the progress of every :func:`download_file` in this thread / context to *callback*."""
+    """Send the progress of every [`download_file`][lunar_toolkit.downloader.download_file] in this thread /
+    context to *callback*."""
     token = _PROGRESS.set(callback)
     try:
         yield
@@ -127,8 +128,9 @@ class PdsDownloader:
     ) -> dict[str, Path | None]:
         """Download a plain list of URLs in parallel.
 
-        Existing files are reused unless *force* (see :meth:`download`).
-        Returns a dict mapping each URL to its local path (or None on error).
+        Existing files are reused unless *force* (see
+        [`download`][lunar_toolkit.downloader.PdsDownloader.download]). Returns a dict mapping each URL to its
+        local path (or None on error).
         """
         path_map: dict[str, Path | None] = {}
         for url, (path, err) in self._download_all(urls, output_dir, show_progress, force).items():
@@ -189,7 +191,7 @@ class _Host:
     """One host's download slots, request pacing and throttling cooldown.
 
     The cooldown is wall-clock time shared by every worker in this process and saved
-    to :data:`COOLDOWN_FILE`, so a restarted run honours a server's earlier
+    to `COOLDOWN_FILE`, so a restarted run honours a server's earlier
     ``Retry-After`` instead of tripping its rate limit again.
     """
 
@@ -286,10 +288,10 @@ def download_file(
     count as failures; they give up only after *max_wait* seconds in total (default
     ``$LUNAR_MAX_WAIT``, else 6 h).  Other *retry_codes* (5xx), connection errors and
     interrupted transfers are retried *retries* times with back-off.  Each retry resumes
-    the ``.part`` file; checksum mismatches are not retried.  See :func:`_download_once`.
+    the ``.part`` file; checksum mismatches are not retried.  See `_download_once`.
 
-    *progress* (default: the :func:`report_progress` callback, if any) gets the bytes
-    done after each chunk; an exception it raises stops the download and keeps the
+    *progress* (default: the [`report_progress`][lunar_toolkit.downloader.report_progress] callback, if any)
+    gets the bytes done after each chunk; an exception it raises stops the download and keeps the
     ``.part`` file for a later resume.
     """
     progress = progress or _PROGRESS.get()
@@ -365,7 +367,7 @@ def _download_once(
       is already complete.
     * When *expected_md5* is given the finished file is verified before the
       atomic rename; on mismatch the part file is deleted and
-      :class:`ChecksumError` is raised.
+      [`ChecksumError`][lunar_toolkit.downloader.ChecksumError] is raised.
     * On network errors the ``.part`` file is kept so the next call resumes.
     """
     from tqdm import tqdm

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/geometry.py

@@ -103,7 +103,8 @@ def _ps_bbox_of_box(
 
 
 def region_bbox(region: dict) -> tuple[float, float, float, float]:
-    """``(west, south, east, north)`` of a :func:`query_region` (east may be < west)."""
+    """``(west, south, east, north)`` of a [`query_region`][lunar_toolkit.geometry.query_region] (east may be
+    < west)."""
     s, n = region["lat"]
     if region["span"] >= 360.0:
         return 0.0, s, 360.0, n
@@ -173,7 +174,7 @@ def load_aoi(source: AoiLike, densify_deg: float | None = 1.0) -> Aoi:
         mapping, a region dict ``{"point": (lat, lon), "radius_km": r}``
         (spherical cap) or ``{"lat": (south, north), "lon": (west, east)}``
         (``west > east`` crosses 0/360; omit ``lon`` for all longitudes), or
-        an existing :class:`Aoi` (returned unchanged).  Only
+        an existing [`Aoi`][lunar_toolkit.geometry.Aoi] (returned unchanged).  Only
         Polygon / MultiPolygon parts are used (also inside
         GeometryCollections); coordinates are lon/lat degrees, positive east,
         in either −180..180 or 0..360.  Polygons may cross the 0/360 (or
@@ -363,11 +364,11 @@ def _covering_arc(arcs: list[tuple[float, float]]) -> tuple[float, float]:
 
 
 def aoi_region(aoi: AoiLike) -> dict:
-    """Bounding region of an AOI, in :func:`query_region` form.
+    """Bounding region of an AOI, in [`query_region`][lunar_toolkit.geometry.query_region] form.
 
     Returns ``{"lat": (s, n), "west", "span", "ps"}`` so the bbox prefilter
     used for boxes and circles applies unchanged; refine the prefiltered
-    rows with :func:`filter_aoi`.
+    rows with [`filter_aoi`][lunar_toolkit.geometry.filter_aoi].
     """
     aoi = load_aoi(aoi)
     lats = [la for poly in aoi.polygons for la in (p[1] for p in poly[0])]
@@ -409,7 +410,8 @@ def _polar_hemi(region: dict) -> str | None:
 
 
 def ps_projection(hemi: str) -> Projection:
-    """Ring projection to polar stereographic (:func:`ps_xy`) for hemisphere *hemi*."""
+    """Ring projection to polar stereographic ([`ps_xy`][lunar_toolkit.geometry.ps_xy]) for hemisphere
+    *hemi*."""
     # Clamp away from the opposite pole, where the projection diverges
     lim = 89.0
     return lambda ring: [ps_xy(min(la, lim) if hemi == "S" else max(la, -lim), lo, hemi) for lo, la in ring]
@@ -449,7 +451,7 @@ def aoi_geometry(aoi: AoiLike, proj: Projection | None = None):
 def footprint_geometry(rings_list: list[list[Ring]], proj: Projection | None):
     """Footprint polygons (per polygon: lon/lat exterior, *holes) as shapely geometry.
 
-    Rings are projected by *proj* (e.g. :func:`ps_projection`), else kept in
+    Rings are projected by *proj* (e.g. [`ps_projection`][lunar_toolkit.geometry.ps_projection]), else kept in
     lon/lat (pole-enclosing rings closed via the pole) starting in 0..360.
     """
     parts = []
@@ -515,7 +517,8 @@ def footprint_rings(row: dict, wkt_column: str | None = None) -> list[list[Ring]
 
 
 def row_footprint(row: dict, wkt_column: str | None = None, proj: Projection | None = None):
-    """Shapely footprint (:func:`footprint_geometry`) of a result row, or ``None``."""
+    """Shapely footprint ([`footprint_geometry`][lunar_toolkit.geometry.footprint_geometry]) of a result row,
+    or ``None``."""
     rings = footprint_rings(row, wkt_column)
     return None if rings is None else footprint_geometry(rings, proj)
 
@@ -528,9 +531,9 @@ def aoi_mask(df: pd.DataFrame, aoi: AoiLike, wkt_column: str | None = None) -> l
     corner lat/lon columns, else the ``FP_*`` / ``min_lat``…``lon_east``
     bounding box.  Rows with no geometry at all are kept.
 
-    *aoi* is anything :func:`load_aoi` accepts.  Regions entirely poleward
+    *aoi* is anything [`load_aoi`][lunar_toolkit.geometry.load_aoi] accepts.  Regions entirely poleward
     of ±60° (``POLAR_LAT_THRESHOLD``) are intersected in polar
-    stereographic (:func:`ps_xy`, footprint edges straight in the
+    stereographic ([`ps_xy`][lunar_toolkit.geometry.ps_xy], footprint edges straight in the
     projection); others in lon/lat with the AOI replicated at ±360° so
     footprints across the 0/360 seam match.
     """
@@ -550,7 +553,8 @@ def aoi_mask(df: pd.DataFrame, aoi: AoiLike, wkt_column: str | None = None) -> l
 
 
 def filter_aoi(df: pd.DataFrame, aoi: AoiLike, wkt_column: str | None = None) -> pd.DataFrame:
-    """Keep only rows whose footprint intersects the AOI (see :func:`aoi_mask`)."""
+    """Keep only rows whose footprint intersects the AOI (see
+    [`aoi_mask`][lunar_toolkit.geometry.aoi_mask])."""
     if df is None or len(df) == 0:
         return df
     return df[aoi_mask(df, aoi, wkt_column=wkt_column)].reset_index(drop=True)

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/isis.py

@@ -48,7 +48,7 @@ def spiceinit(from_cub: Path, spksmithed: bool = True, web: bool = True, **param
 def system_shape_available() -> bool:
     """Whether ``$ISISDATA`` (as the ISIS tools see it) has the default lunar shape model.
 
-    True when ``spiceinit`` cannot be found or under :func:`~lunar_toolkit.tools.dry_run`
+    True when ``spiceinit`` cannot be found or under [`dry_run`][lunar_toolkit.tools.dry_run]
     (nothing to decide then).
     """
     tool = find_tool("spiceinit")
@@ -202,8 +202,9 @@ def prepare_lronac(
     """Calibrated cube and optional CSM camera for one NAC image.
 
     A ``.cub`` *src* is used as is; anything else (an EDR ``.IMG``) goes through
-    :func:`calibrate_lronac` into *out_dir*.  With *csm*, ``<id>.json`` is written
-    in *out_dir* by :func:`isd_generate`.  Existing outputs are reused unless *force*.
+    [`calibrate_lronac`][lunar_toolkit.isis.calibrate_lronac] into *out_dir*.  With *csm*, ``<id>.json`` is
+    written in *out_dir* by [`isd_generate`][lunar_toolkit.isis.isd_generate].  Existing outputs are reused
+    unless *force*.
 
     Returns
     -------

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/kaguya/mi.py

@@ -79,7 +79,7 @@ def select_mi_files(files: Iterable[dict], product_id: str | None = None) -> MiP
     """Pick the data and label files of an MI product from its ODE ``files`` list.
 
     MI products have the TC layout (detached ``.lbl`` + ``.img.gz``), so
-    this follows :func:`~lunar_toolkit.kaguya.tc.select_tc_files`.
+    this follows [`select_tc_files`][lunar_toolkit.kaguya.tc.select_tc_files].
 
     Returns
     -------
@@ -112,7 +112,8 @@ def mi_products(df: pd.DataFrame) -> list[MiProduct]:
 
 
 def lookup_mi_products(product_ids: Iterable[str], client: OdeClient | None = None) -> pd.DataFrame:
-    """Query ODE by product ID and return the observation DataFrame (see :meth:`OdeClient.lookup`)."""
+    """Query ODE by product ID and return the observation DataFrame (see
+    [`OdeClient.lookup`][lunar_toolkit.ode.OdeClient.lookup])."""
     from ..ode import OdeClient
 
     return (client or OdeClient()).lookup(product_ids, instrument_label="Kaguya MI")
@@ -127,7 +128,7 @@ def download_mi_product(
 ) -> Path:
     """Download (and gunzip) one product's label and image; returns the label path.
 
-    See :func:`~lunar_toolkit.kaguya.tc.download_product`.
+    See [`download_product`][lunar_toolkit.kaguya.tc.download_product].
     """
     tc = TcProduct(product.product_id, product.image_url, product.label_url, product.image_kbytes)
     return download_product(tc, output_dir, force=force, keep_gz=keep_gz, show_progress=show_progress)
@@ -162,8 +163,8 @@ class MiProcessor:
     force : bool
         Redo every step even when its output exists.
     kaguyami2isis_params, spiceinit_params : dict, optional
-        Overrides merged into :data:`KAGUYAMI2ISIS_PARAMS` /
-        :data:`SPICEINIT_PARAMS`.
+        Overrides merged into `KAGUYAMI2ISIS_PARAMS` /
+        `SPICEINIT_PARAMS`.
     """
 
     def __init__(
@@ -194,7 +195,7 @@ class MiProcessor:
     def process(self, source: MiProduct | str | Path) -> MiOutputs:
         """Download (if needed) and import one product.
 
-        *source* is a :class:`MiProduct`, a local ``.lbl`` path or a product
+        *source* is a [`MiProduct`][lunar_toolkit.kaguya.mi.MiProduct], a local ``.lbl`` path or a product
         ID (looked up on ODE).
         """
         if isinstance(source, MiProduct):
@@ -269,6 +270,7 @@ class MiProcessor:
 
 
 def import_mi(label: Path, output_dir: Path | None = None, **kwargs: Any) -> MiOutputs:
-    """Import one downloaded MI product; see :class:`MiProcessor` for *kwargs*."""
+    """Import one downloaded MI product; see [`MiProcessor`][lunar_toolkit.kaguya.mi.MiProcessor] for
+    *kwargs*."""
     label = Path(label)
     return MiProcessor(output_dir or label.parent, **kwargs).import_label(label)

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/kaguya/tc.py

@@ -150,7 +150,8 @@ def lookup_products(
     product_ids: Iterable[str],
     client: OdeClient | None = None,
 ) -> pd.DataFrame:
-    """Query ODE by product ID and return the observation DataFrame (see :meth:`OdeClient.lookup`)."""
+    """Query ODE by product ID and return the observation DataFrame (see
+    [`OdeClient.lookup`][lunar_toolkit.ode.OdeClient.lookup])."""
     from ..ode import OdeClient
 
     return (client or OdeClient()).lookup(product_ids, instrument_label="Kaguya TC")
@@ -212,9 +213,9 @@ class TcProcessor:
 
     Each product ends up in *output_dir* as ``<id>.cub`` (spiceinit'ed),
     ``<id>.json`` (CSM camera, when *csm*) and, when *mapproject*,
-    ``<id>.tif`` (:data:`~lunar_toolkit.constants.GEOTIFF_OPTIONS`), the
+    ``<id>.tif`` (`GEOTIFF_OPTIONS`), the
     same flat layout and resume / *keep* / *force* behaviour as
-    :class:`~lunar_toolkit.lroc.nac.NacProcessor`.  Steps whose output
+    [`NacProcessor`][lunar_toolkit.lroc.nac.NacProcessor].  Steps whose output
     exists are skipped unless *force*.
 
     Parameters
@@ -240,8 +241,8 @@ class TcProcessor:
     force : bool
         Redo every step even when its output exists.
     kaguyatc2isis_params, spiceinit_params : dict, optional
-        Overrides merged into :data:`KAGUYATC2ISIS_PARAMS` /
-        :data:`SPICEINIT_PARAMS`.
+        Overrides merged into `KAGUYATC2ISIS_PARAMS` /
+        `SPICEINIT_PARAMS`.
     """
 
     def __init__(
@@ -274,7 +275,7 @@ class TcProcessor:
     def process(self, source: TcProduct | str | Path) -> TcOutputs:
         """Download (if needed) and import one product.
 
-        *source* is a :class:`TcProduct`, a local ``.lbl`` path or a product
+        *source* is a [`TcProduct`][lunar_toolkit.kaguya.tc.TcProduct], a local ``.lbl`` path or a product
         ID (looked up on ODE).
         """
         if isinstance(source, TcProduct):
@@ -361,7 +362,8 @@ class TcProcessor:
 
 
 def import_tc(label: Path, output_dir: Path | None = None, **kwargs: Any) -> TcOutputs:
-    """Import one downloaded TC product; see :class:`TcProcessor` for *kwargs*."""
+    """Import one downloaded TC product; see [`TcProcessor`][lunar_toolkit.kaguya.tc.TcProcessor] for
+    *kwargs*."""
     label = Path(label)
     return TcProcessor(output_dir or label.parent, **kwargs).import_label(label)
 

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/lroc/cumindex.py

@@ -322,7 +322,7 @@ class CumIndex:
             than the sidecar's ``release`` (or ``max(VOLUME_ID)`` in the
             Parquet when no sidecar exists).
         on_stage : callable, optional
-            As in :meth:`build_db`.
+            As in [`build_db`][lunar_toolkit.lroc.cumindex.CumIndex.build_db].
 
         Returns
         -------
@@ -476,7 +476,7 @@ class CumIndex:
         −180..180 or 0..360, omitted ``lon`` = all longitudes), a circle
         (``point=(lat, lon)``, ``radius_km``) or an area of interest
         (``aoi=``: GeoJSON / WKT path, WKT string or
-        :class:`~lunar_toolkit.geometry.Aoi`).
+        [`Aoi`][lunar_toolkit.geometry.Aoi]).
 
         Matching is bounding-box based and conservative (may include a few
         false positives, never drops a true hit for convex-ish footprints):
@@ -647,7 +647,7 @@ def build_parquet(
 
     Parameters
     ----------
-    sources : list of ``(tab_path, lbl_columns)``
+    sources : list of (tab_path, lbl_columns)
         Each TAB is parsed with its own label layout (record lengths differ
         between volumes) and the results are combined ``UNION ALL BY NAME``.
     base_parquet : Path, optional
@@ -960,7 +960,8 @@ def footprint_wkt_sql(names: Iterable[str], west_expr: str = "FP_LON_WEST") -> s
 
 # Search regions
 def region_sql(region: dict) -> str:
-    """WHERE clause matching ``FP_*`` columns against a :func:`query_region`."""
+    """WHERE clause matching ``FP_*`` columns against a
+    [`query_region`][lunar_toolkit.geometry.query_region]."""
     s, n = region["lat"]
     conds = [f"FP_MAX_LAT >= {s!r}", f"FP_MIN_LAT <= {n!r}"]
     if region["span"] < 360.0:

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/lroc/nac.py

@@ -104,7 +104,7 @@ def _raw(value: Any) -> Any:
 
 
 class IndexColumn(Generic[_V]):
-    """Read-only :class:`NacImage` attribute holding one CUMINDEX column.
+    """Read-only [`NacImage`][lunar_toolkit.lroc.nac.NacImage] attribute holding one CUMINDEX column.
 
     The value is converted by *cast*; ``None`` when the column is missing
     or null.
@@ -408,7 +408,7 @@ class NacImage:
     def process(self, output_dir: Path, **kwargs: Any) -> Path:
         """Run the ISIS + GDAL pipeline on the EDR, returning the GeoTIFF.
 
-        *kwargs* are :class:`NacProcessor` options (``projection``,
+        *kwargs* are [`NacProcessor`][lunar_toolkit.lroc.nac.NacProcessor] options (``projection``,
         ``resolution``, ``web``, ``keep``, ``force``).
         """
         url = self.edr_url
@@ -418,7 +418,8 @@ class NacImage:
 
     # Quick view
     def to_png(self, output_dir: Path, input_path: Path) -> Path:
-        """Convert an image (e.g. a GeoTIFF from :meth:`process`) to ``<output_dir>/<id>.png``."""
+        """Convert an image (e.g. a GeoTIFF from [`process`][lunar_toolkit.lroc.nac.NacImage.process]) to
+        ``<output_dir>/<id>.png``."""
         return to_png(input_path, Path(output_dir) / f"{self._product_id}.png")
 
     def show(self, input_path: Path) -> None:
@@ -556,7 +557,7 @@ class NacImageCollection:
     def process(self, output_dir: Path, workers: int = 4, **kwargs: Any) -> dict[str, Path | None]:
         """Run the ISIS + GDAL pipeline on all EDRs in parallel.
 
-        *kwargs* are :class:`NacProcessor` options.  Returns a dict mapping
+        *kwargs* are [`NacProcessor`][lunar_toolkit.lroc.nac.NacProcessor] options.  Returns a dict mapping
         product_id → GeoTIFF Path (or None on failure).
         """
         urls = {img.product_id: img.edr_url for img in self._images}
@@ -598,7 +599,7 @@ class NacProcessor:
     """Download, calibrate and map-project LROC NAC EDRs into GeoTIFFs.
 
     Each image ends up in *output_dir* as ``<id>.tif`` (map-projected I/F,
-    :data:`~lunar_toolkit.constants.GEOTIFF_OPTIONS`).  Intermediates
+    `GEOTIFF_OPTIONS`).  Intermediates
     (a downloaded ``<id>.IMG``, ``<id>.cal.echo.cub``, ``<id>.map.cub``) are
     written beside it and removed after success unless *keep*; after a
     failure they stay, so a re-run resumes.  Steps whose output exists are

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/observation.py

@@ -80,7 +80,7 @@ def normalize_observations(records: list[dict]) -> pd.DataFrame:
 
 
 def observations_from_cumindex(df: pd.DataFrame, dataset: str | None = "edr") -> pd.DataFrame:
-    """Map enriched ``CumIndex`` query results to :data:`OBSERVATION_COLUMNS`."""
+    """Map enriched ``CumIndex`` query results to `OBSERVATION_COLUMNS`."""
     import pandas as pd
 
     if df is None or df.empty:

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/ode.py

@@ -106,7 +106,7 @@ class OdeError(RuntimeError):
 
 
 class OdeClient:
-    """Query ODE REST and return :data:`OBSERVATION_COLUMNS` DataFrames.
+    """Query ODE REST and return `OBSERVATION_COLUMNS` DataFrames.
 
     Parameters
     ----------
@@ -151,8 +151,8 @@ class OdeClient:
     ) -> dict[str, str]:
         """Translate search arguments into ODE query parameters.
 
-        An ``aoi`` (see :func:`lunar_toolkit.geometry.load_aoi`) is sent as
-        its bounding box; :meth:`search` refines the results exactly.
+        An ``aoi`` (see [`lunar_toolkit.geometry.load_aoi`][lunar_toolkit.geometry.load_aoi]) is sent as
+        its bounding box; [`search`][lunar_toolkit.ode.OdeClient.search] refines the results exactly.
         """
         _, entry, pt = resolve_instrument(instrument, product_type)
         params: dict[str, str] = {
@@ -232,13 +232,13 @@ class OdeClient:
     ) -> pd.DataFrame:
         """Search ODE and return the common observation schema.
 
-        Region arguments follow :meth:`CumIndex.search`: ``lat=(min, max)``
-        and ``lon=(west, east)`` (``west > east`` crosses 0/360), or
+        Region arguments follow [`CumIndex.search`][lunar_toolkit.lroc.cumindex.CumIndex.search]:
+        ``lat=(min, max)`` and ``lon=(west, east)`` (``west > east`` crosses 0/360), or
         ``point=(lat, lon)`` with ``radius_km`` (converted to a bounding box;
         circles reaching a pole become a full-longitude cap).  ODE matches the
         box against product footprints (``loc=f``, its default).  With
         ``aoi`` (GeoJSON / WKT path, WKT string or
-        :class:`~lunar_toolkit.geometry.Aoi`) the AOI's
+        [`Aoi`][lunar_toolkit.geometry.Aoi]) the AOI's
         bounding box is queried and each ``footprint_wkt`` is then
         intersected with the polygon; paging continues until
         ``max_results`` products survive that refinement.
@@ -458,7 +458,8 @@ def to_dataframe(records: list[dict]) -> pd.DataFrame:
 
 
 def select_file_urls(df: pd.DataFrame, kind: str = "product", match: str | None = None) -> list[str]:
-    """Pick file URLs from the ``files`` column (see :meth:`OdeClient.download`)."""
+    """Pick file URLs from the ``files`` column (see
+    [`OdeClient.download`][lunar_toolkit.ode.OdeClient.download])."""
     kind = kind.lower()
     urls: list[str] = []
     for files in df.get("files", []):

{lunar_toolkit-0.1.0 → lunar_toolkit-0.1.0.dev1}/lunar_toolkit/provenance.py

@@ -62,7 +62,7 @@ def tool_versions() -> dict[str, str | None]:
 
 
 def isis_paths() -> dict[str, str | None]:
-    """``ISISROOT`` / ``ISISDATA`` as the tools see them (:func:`~lunar_toolkit.tools.tool_env`)."""
+    """``ISISROOT`` / ``ISISDATA`` as the tools see them ([`tool_env`][lunar_toolkit.tools.tool_env])."""
     tool = find_tool("spiceinit") or find_tool("sfs")
     env = tool_env(tool) if tool else dict(os.environ)
     return {k: env.get(k) for k in ("ISISROOT", "ISISDATA")}
@@ -188,7 +188,7 @@ class Provenance:
 
     @contextlib.contextmanager
     def step(self, name: str) -> Iterator[dict[str, Any]]:
-        """Record a step: times, the commands :func:`~lunar_toolkit.tools.run` executes and status.
+        """Record a step: times, the commands [`run`][lunar_toolkit.tools.run] executes and status.
 
         Set ``entry["result"]`` inside the block to list its existing output files.
         """