spacecoords 0.1.2__tar.gz

spacecoords-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Daniel Kastinen]
+
+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.

spacecoords-0.1.2/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: spacecoords
+Version: 0.1.2
+Summary: A collection of coordinate transforms for convenient use
+Author-email: Daniel Kastinen <daniel.kastinen@irf.se>
+Maintainer-email: Daniel Kastinen <daniel.kastinen@irf.se>
+License: MIT License
+        
+        Copyright (c) [2025] [Daniel Kastinen]
+        
+        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.
+        
+Project-URL: Documentation, https://danielk.developer.irf.se/spacecoords/
+Project-URL: Repository, https://github.com/danielk333/spacecoords
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2
+Provides-Extra: all
+Requires-Dist: astropy>=6; extra == "all"
+Requires-Dist: spiceypy>=8.0.0; extra == "all"
+Requires-Dist: jplephem>=2.23; extra == "all"
+Requires-Dist: requests>=2.20; extra == "all"
+Provides-Extra: develop
+Requires-Dist: pytest; extra == "develop"
+Requires-Dist: pytest-cov; extra == "develop"
+Requires-Dist: flake8; extra == "develop"
+Requires-Dist: wheel; extra == "develop"
+Requires-Dist: build; extra == "develop"
+Requires-Dist: twine; extra == "develop"
+Requires-Dist: auditwheel; extra == "develop"
+Requires-Dist: numpydoc; extra == "develop"
+Requires-Dist: black; extra == "develop"
+Requires-Dist: matplotlib; extra == "develop"
+Requires-Dist: ipykernel; extra == "develop"
+Requires-Dist: mkdocs-material; extra == "develop"
+Requires-Dist: mkdocstrings[python]; extra == "develop"
+Requires-Dist: mkdocs-jupyter; extra == "develop"
+Requires-Dist: mkdocs-gen-files; extra == "develop"
+Requires-Dist: mkdocs-literate-nav; extra == "develop"
+Requires-Dist: mkdocs-section-index; extra == "develop"
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Dynamic: license-file
+
+# spacecoords
+
+A collection of coordinate transforms for convenient use across our applications to avoid
+duplication

spacecoords-0.1.2/README.md

@@ -0,0 +1,4 @@
+# spacecoords
+
+A collection of coordinate transforms for convenient use across our applications to avoid
+duplication

spacecoords-0.1.2/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spacecoords"
+version = "0.1.2"
+description = "A collection of coordinate transforms for convenient use"
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [{ name = "Daniel Kastinen", email = "daniel.kastinen@irf.se" }]
+maintainers = [{ name = "Daniel Kastinen", email = "daniel.kastinen@irf.se" }]
+license = { file = "LICENSE" }
+classifiers = [
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Physics",
+  "Operating System :: OS Independent",
+  "License :: OSI Approved :: MIT License",
+]
+requires-python = ">=3.10"
+dependencies = ["numpy >= 2"]
+
+[project.urls]
+Documentation = "https://danielk.developer.irf.se/spacecoords/"
+Repository = "https://github.com/danielk333/spacecoords"
+
+
+[project.optional-dependencies]
+all = ["astropy>=6", "spiceypy>=8.0.0", "jplephem>=2.23", "requests>=2.20"]
+develop = [
+  "pytest",
+  "pytest-cov",
+  "flake8",
+  "wheel",
+  "build",
+  "twine",
+  "auditwheel",
+  "numpydoc",
+  "black",
+  "matplotlib",
+  "ipykernel",
+  "mkdocs-material",
+  "mkdocstrings[python]",
+  "mkdocs-jupyter",
+  "mkdocs-gen-files",
+  "mkdocs-literate-nav",
+  "mkdocs-section-index",
+]
+tests = ["pytest", "pytest-cov"]
+
+
+[tool.setuptools]
+include-package-data = true
+license-files = ["LICENSE"]
+
+[project.scripts]
+spacecoords = "spacecoords.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 110
+
+
+[tool.pytest.ini_options]
+addopts = "-v --cov=spacecoords"
+testpaths = ["tests"]
+
+[tool.coverage.report]
+exclude_also = [
+  # Don't complain if tests don't hit defensive assertion code:
+  "raise AssertionError",
+  "raise NotImplementedError",
+
+  # Don't complain if non-runnable code isn't run:
+  "if 0:",
+  "if __name__ == .__main__.:",
+
+  # Don't complain about abstract methods, they aren't run:
+  "@(abc\\.)?abstractmethod",
+]

spacecoords-0.1.2/setup.cfg

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

spacecoords-0.1.2/src/spacecoords/__init__.py

@@ -0,0 +1,45 @@
+"""General purpose convenience functions for different coordinate systems and linear algebra
+functions
+"""
+
+from types import ModuleType
+import importlib.util
+from .version import __version__
+
+from . import linalg
+from . import spherical
+from . import constants
+from . import projection
+
+
+def _make_missing_module(name: str, dep: str):
+    class _MissingModule(ModuleType):
+        def __getattr__(self, key):
+            raise ImportError(
+                f"The optional dependency `{dep}` for is missing.\n"
+                f"Install it with `pip install spacecoords[all]` or `pip install {dep}`."
+            )
+
+    return _MissingModule(name)
+
+
+# Optional modules
+if importlib.util.find_spec("astropy") is not None:
+    from . import celestial
+else:
+    astropy = _make_missing_module("celestial", "astropy")
+
+if importlib.util.find_spec("jplephem") is not None:
+    from . import spk_basic
+else:
+    naif_ephemeris = _make_missing_module("spk_basic", "jplephem")
+
+if importlib.util.find_spec("spice") is not None:
+    from . import spice
+else:
+    naif_spice = _make_missing_module("spice", "spiceypy")
+
+if importlib.util.find_spec("requests") is not None:
+    from . import download
+else:
+    download = _make_missing_module("download", "requests")

spacecoords-0.1.2/src/spacecoords/celestial.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python
+
+"""Coordinate frame transformations and related functions.
+Main usage is the `convert` function that wraps Astropy frame transformations.
+"""
+from typing import Type, Any
+from pathlib import Path
+import numpy as np
+from astropy.time import Time
+import astropy.coordinates as coord
+import astropy.units as units
+import astropy.config as config
+
+from .types import (
+    NDArray_N,
+    NDArray_3,
+    NDArray_6,
+    NDArray_3xN,
+    NDArray_6xN,
+    T,
+)
+
+"""List of astropy frames
+"""
+ASTROPY_FRAMES = {
+    "TEME": "TEME",
+    "ITRS": "ITRS",
+    "ITRF": "ITRS",
+    "ICRS": "ICRS",
+    "ICRF": "ICRS",
+    "GCRS": "GCRS",
+    "GCRF": "GCRS",
+    "HCRS": "HCRS",
+    "HCRF": "HCRS",
+    "HeliocentricMeanEcliptic".upper(): "HeliocentricMeanEcliptic",
+    "GeocentricMeanEcliptic".upper(): "GeocentricMeanEcliptic",
+    "HeliocentricTrueEcliptic".upper(): "HeliocentricTrueEcliptic",
+    "GeocentricTrueEcliptic".upper(): "GeocentricTrueEcliptic",
+    "BarycentricMeanEcliptic".upper(): "BarycentricMeanEcliptic",
+    "BarycentricTrueEcliptic".upper(): "BarycentricTrueEcliptic",
+    "SPICEJ2000": "ICRS",
+}
+
+"""List of frames that are not time-dependant
+"""
+ASTROPY_NOT_OBSTIME = [
+    "ICRS",
+    "BarycentricMeanEcliptic",
+    "BarycentricTrueEcliptic",
+]
+
+
+def get_solarsystem_body_state(
+    body: str,
+    time: Time,
+    kernel_dir: Path,
+    ephemeris: str = "jpl",
+) -> NDArray_6xN | NDArray_6:
+    """
+
+    This is to not have to remember how to do this astropy config stuff
+    # https://docs.astropy.org/en/stable/api/astropy.coordinates.solar_system_ephemeris.html
+    """
+    with config.set_temp_cache(path=str(kernel_dir), delete=False):
+        pos, vel = coord.get_body_barycentric_posvel(body, time, ephemeris=ephemeris)
+
+    size = len(time)
+    shape: tuple[int, ...] = (6, size) if size > 0 else (6,)
+    state = np.empty(shape, dtype=np.float64)
+    state[:3, ...] = pos.xyz.to(units.m).value
+    state[3:, ...] = vel.d_xyz.to(units.m / units.s).value
+    return state
+
+
+def not_geocentric(frame: str) -> bool:
+    """Check if the given frame name is one of the non-geocentric frames."""
+    frame = frame.upper()
+    return frame in ["ICRS", "ICRF", "HCRS", "HCRF"] or frame.startswith("Heliocentric".upper())
+
+
+def is_geocentric(frame: str) -> bool:
+    """Check if the frame name is a supported geocentric frame"""
+    return not not_geocentric(frame)
+
+
+def convert(
+    t: NDArray_N,
+    states: NDArray_6xN,
+    in_frame: str,
+    out_frame: str,
+    frame_kwargs: dict[str, Any],
+) -> NDArray_6xN:
+    """Perform predefined coordinate transformations using Astropy.
+    Always returns a copy of the array.
+
+    Parameters
+    ----------
+    t
+        Absolute time corresponding to the input states.
+    states
+        Size `(6,n)` matrix of states in SI units where rows 1-3
+        are position and 4-6 are velocity.
+    in_frame
+        Name of the frame the input states are currently in.
+    out_frame
+        Name of the state to transform to.
+    frame_kwargs
+        Any arguments needed for the specific transform detailed by `astropy`
+        in their documentation
+
+    Returns
+    -------
+        Size `(6,n)` matrix of states in SI units where rows
+        1-3 are position and 4-6 are velocity.
+
+    """
+
+    in_frame = in_frame.upper()
+    out_frame = out_frame.upper()
+
+    if in_frame == out_frame:
+        return states.copy()
+
+    if in_frame in ASTROPY_FRAMES:
+        in_frame_ = ASTROPY_FRAMES[in_frame]
+        in_frame_cls = getattr(coord, in_frame_)
+    else:
+        err_str = [
+            f"In frame '{in_frame}' not recognized, ",
+            "please check spelling or perform manual transformation",
+        ]
+        raise ValueError("".join(err_str))
+
+    kw = {}
+    kw.update(frame_kwargs)
+    if in_frame_ not in ASTROPY_NOT_OBSTIME:
+        kw["obstime"] = t
+
+    astropy_states = _convert_to_astropy(states, in_frame_cls, kw)
+
+    if out_frame in ASTROPY_FRAMES:
+        out_frame_ = ASTROPY_FRAMES[out_frame]
+        out_frame_cls = getattr(coord, out_frame_)
+    else:
+        err_str = [
+            f"Out frame '{out_frame}' not recognized, ",
+            "please check spelling or perform manual transformation",
+        ]
+        raise ValueError("".join(err_str))
+
+    kw = {}
+    kw.update(frame_kwargs)
+    if out_frame_ not in ASTROPY_NOT_OBSTIME:
+        kw["obstime"] = t
+
+    out_states = astropy_states.transform_to(out_frame_cls(**kw))
+
+    rets = states.copy()
+    rets[:3, ...] = out_states.cartesian.xyz.to(units.m).value
+    rets[3:, ...] = out_states.velocity.d_xyz.to(units.m / units.s).value
+
+    return rets
+
+
+def _convert_to_astropy(
+    states: NDArray_6xN | NDArray_6,
+    frame: Type[T],
+    frame_kwargs: dict[str, Any],
+) -> T:
+    state_p = coord.CartesianRepresentation(states[:3, ...] * units.m)
+    state_v = coord.CartesianDifferential(states[3:, ...] * units.m / units.s)
+    astropy_states = frame(state_p.with_differentials(state_v), **frame_kwargs)  # type: ignore
+    return astropy_states
+
+
+def geodetic_to_ITRS(
+    lat: NDArray_N | float,
+    lon: NDArray_N | float,
+    alt: NDArray_N | float,
+    degrees: bool = True,
+) -> NDArray_3xN | NDArray_3:
+    """Use `astropy.coordinates.WGS84GeodeticRepresentation` to transform from WGS84 to ITRS."""
+    ang_unit = units.deg if degrees else units.rad
+
+    wgs_cord = coord.WGS84GeodeticRepresentation(
+        lon=lon * ang_unit,
+        lat=lat * ang_unit,
+        height=alt * units.m,
+    )
+    itrs_cord = coord.ITRS(wgs_cord)
+
+    if isinstance(lat, np.ndarray):
+        size = lat.size
+    else:
+        size = 0
+
+    shape: tuple[int, ...] = (6, size) if size > 0 else (6,)
+    state = np.empty(shape, dtype=np.float64)
+    state[:3, ...] = itrs_cord.cartesian.xyz.to(units.m).value
+    state[3:, ...] = itrs_cord.velocity.d_xyz.to(units.m / units.s).value
+
+    return state
+
+
+def ITRS_to_geodetic(
+    state: NDArray_3xN | NDArray_N,
+    degrees: bool = True,
+) -> tuple[NDArray_N | float, NDArray_N | float, NDArray_N | float]:
+    """Use `astropy.coordinates.WGS84GeodeticRepresentation` to transform from ITRS to WGS84."""
+    ang_unit = units.deg if degrees else units.rad
+
+    itrs_cord = _convert_to_astropy(state, coord.ITRS, {})
+    wgs_cord = coord.WGS84GeodeticRepresentation(itrs_cord)
+    return (
+        wgs_cord.lat.to(ang_unit).value,
+        wgs_cord.lon.to(ang_unit).value,
+        wgs_cord.height.to(units.m).value,
+    )

spacecoords-0.1.2/src/spacecoords/cli.py

@@ -0,0 +1,22 @@
+import argparse
+
+
+def main():
+    import spacecoords as sc
+
+    parser = argparse.ArgumentParser(description="Download files")
+    subparsers = parser.add_subparsers(help="Available download interfaces", dest="command")
+
+    naif_parser = subparsers.add_parser("naif_kernel", help="Download NAIF Kernels")
+    naif_parser.add_argument(
+        "kernel_type",
+        choices=list(sc.download.KERNEL_PATHS.keys()),
+        help="Type of kernel (determines location on server)",
+    )
+    naif_parser.add_argument("kernel_name", help="Kernel filename")
+    naif_parser.add_argument("output_file", help="Path to output file")
+
+    args = parser.parse_args()
+
+    if args.command == "naif_kernel":
+        sc.download.naif_kernel_main(args)

spacecoords-0.1.2/src/spacecoords/constants.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+
+"""Constants useful for different coordinate systems"""
+
+
+G: float = 6.67430e-11
+"""Newtonian constant of gravitation (m^3 kg^-1 s^-2), CODATA Recommended Values of the Fundamental
+Physical Constants 2022.
+"""
+
+
+class WGS84:
+    """World Geodetic System 1984 constants."""
+
+    a: float = 6378.137 * 1e3
+    """float: semi-major axis parameter in meters of the World Geodetic System 1984 (WGS84)
+    """
+
+    b: float = 6356.7523142 * 1e3
+    """float: semi-minor axis parameter in meters of the World Geodetic System 1984 (WGS84)
+    """
+
+    esq: float = 6.69437999014 * 0.001
+    """float: `esq` parameter in meters of the World Geodetic System 1984 (WGS84)
+    """
+
+    e1sq: float = 6.73949674228 * 0.001
+    """float: `e1sq` parameter in meters of the World Geodetic System 1984 (WGS84)
+    """
+
+    f: float = 1 / 298.257223563
+    """float: `f` parameter of the World Geodetic System 1984 (WGS84)
+    """
+
+
+R_earth: float = 6371.0088e3
+"""float: Radius of the Earth using the International
+Union of Geodesy and Geophysics (IUGG) definition
+"""
+
+
+class WGS72:
+    """World Geodetic System 1972 constants."""
+
+    MU_earth: float = 398600.8 * 1e9
+    """float: Standard gravitational parameter of the Earth using the WGS72 convention.
+    """
+
+    M_earth: float = MU_earth / G
+    """float: Mass of the Earth using the WGS72 convention.
+    """

spacecoords-0.1.2/src/spacecoords/download.py

@@ -0,0 +1,59 @@
+import sys
+import os
+from pathlib import Path
+import requests
+
+NAIF_URL = "https://naif.jpl.nasa.gov/pub/naif/"
+
+KERNEL_PATHS = {
+    "planetary": "generic_kernels/spk/planets/",
+}
+
+
+def naif_kernel(
+    kernel_path: str,
+    output_file: Path,
+    progress: bool = True,
+    chunk_size: int = 8192,
+):
+    url = NAIF_URL + kernel_path
+    with requests.get(url, stream=True) as r:
+        r.raise_for_status()
+        total_length = r.headers.get("content-length")
+        downloaded = 0
+        if total_length is None:
+            with open(output_file, "wb") as fh:
+                for chunk in r.iter_content(chunk_size=chunk_size):
+                    fh.write(chunk)
+                    if progress:
+                        downloaded += len(chunk)
+                        sys.stdout.write(f"{downloaded / 1024:.1f} KB")
+                        sys.stdout.flush()
+            if progress:
+                print()
+        else:
+            total_length = int(total_length)
+            prog_width = min(os.get_terminal_size()[0] - 10, 100)
+            with open(output_file, "wb") as fh:
+                for chunk in r.iter_content(chunk_size=chunk_size):
+                    if not chunk:
+                        continue
+                    fh.write(chunk)
+                    if progress:
+                        downloaded += len(chunk)
+                        done = int(prog_width * downloaded / total_length)
+                        sys.stdout.write(
+                            f"\r[{'=' * done}{' ' * (prog_width - done)}] "
+                            f"{downloaded / 1024:.1f} KB / {total_length / 1024:.1f} KB"
+                        )
+                        sys.stdout.flush()
+            if progress:
+                print()
+
+
+def naif_kernel_main(args):
+    naif_kernel(
+        kernel_path=KERNEL_PATHS[args.kernel_type] + args.kernel_name,
+        output_file=args.output_file,
+        progress=True,
+    )