tessl/pypi-astroquery

Functions and classes to access online astronomical data resources

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Space Mission Archives

Name: tessl/pypi-astroquery
Author: tessl

Archives from space missions and satellites providing specialized astronomical data including gamma-ray, X-ray, infrared, ultraviolet, and optical observations. These archives offer unique datasets from space-based observatories with capabilities unavailable from ground-based telescopes.

Capabilities

ESA - European Space Agency Missions

ESA missions provide access to data from major space telescopes including James Webb Space Telescope, Hubble Space Telescope, XMM-Newton, and other ESA-operated missions.

from astroquery.esa.jwst import Jwst
from astroquery.esa.hubble import Hubble
from astroquery.esa.xmm_newton import XmmNewton

# James Webb Space Telescope
def query_object(name: str, radius: Union[Quantity, str] = None, **kwargs) -> Table:
    """
    Query JWST archive for observations of a specific object.
    
    Parameters:
    - name: Name of the astronomical object
    - radius: Search radius around object
    - **kwargs: Additional query parameters
    
    Returns:
    Table with JWST observation metadata
    """

def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None) -> Table:
    """
    Query JWST archive for observations in a sky region.
    
    Parameters:
    - coordinates: Center coordinates
    - radius: Search radius
    
    Returns:
    Table with JWST observations in the region
    """

# Hubble Space Telescope
def query_object(name: str, radius: Union[Quantity, str] = None) -> Table:
    """
    Query Hubble archive via ESA for observations of an object.
    
    Parameters:
    - name: Object name
    - radius: Search radius
    
    Returns:
    Table with Hubble observation records
    """

# XMM-Newton
def query_object(name: str, radius: Union[Quantity, str] = None) -> Table:
    """
    Query XMM-Newton archive for X-ray observations.
    
    Parameters:
    - name: Object name  
    - radius: Search radius
    
    Returns:
    Table with XMM-Newton observation metadata
    """

# Configuration
from astroquery.esa import conf
conf.server: str              # ESA archive server
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.esa.jwst import Jwst
from astroquery.esa.hubble import Hubble
import astropy.units as u
from astropy.coordinates import SkyCoord

# Query JWST observations
jwst_obs = Jwst.query_object('NGC 628', radius=2*u.arcmin)
print(f"Found {len(jwst_obs)} JWST observations")

# Query Hubble archive through ESA
hubble_obs = Hubble.query_object('M51', radius=5*u.arcmin)
print(f"Found {len(hubble_obs)} Hubble observations")

# Region query for multiple missions
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
jwst_region = Jwst.query_region(coords, radius=30*u.arcsec)

Fermi - Fermi Gamma-ray Space Telescope

Fermi LAT (Large Area Telescope) provides access to gamma-ray observations of the sky, including both survey data and targeted observations of gamma-ray sources.

from astroquery.fermi import Fermi

def query_object(object_name: str, energyrange_MeV: Tuple[float, float] = (100, 100000),
                obsdates: str = None, timesys: str = 'MET') -> Table:
    """
    Query Fermi LAT for gamma-ray observations of an object.
    
    Parameters:
    - object_name: Name of the astronomical object
    - energyrange_MeV: Energy range in MeV as (min, max) tuple
    - obsdates: Observation date range
    - timesys: Time system ('MET', 'UTC')
    
    Returns:
    Table with Fermi LAT observation information
    """

def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
                energyrange_MeV: Tuple[float, float] = (100, 100000)) -> Table:
    """
    Query Fermi LAT for gamma-ray data in a sky region.
    
    Parameters:
    - coordinates: Center coordinates
    - radius: Search radius
    - energyrange_MeV: Energy range in MeV
    
    Returns:
    Table with Fermi LAT data in the specified region
    """

def get_lightcurve(ra: float, dec: float, energyrange_MeV: Tuple[float, float] = (100, 100000),
                  binsize_days: float = 7.0) -> Table:
    """
    Get gamma-ray light curve for a position.
    
    Parameters:
    - ra: Right ascension in degrees
    - dec: Declination in degrees
    - energyrange_MeV: Energy range in MeV
    - binsize_days: Time bin size in days
    
    Returns:
    Table with light curve data
    """

# Configuration
from astroquery.fermi import conf
conf.server: str              # Fermi server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.fermi import Fermi
import astropy.units as u
from astropy.coordinates import SkyCoord

# Query gamma-ray observations of a blazar
result = Fermi.query_object('3C 279', energyrange_MeV=(1000, 10000))
print(f"Found {len(result)} Fermi observations")

# Region query for gamma-ray sources
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
gamma_sources = Fermi.query_region(coords, radius=1*u.deg, 
                                  energyrange_MeV=(100, 100000))

# Get light curve for Crab pulsar
lightcurve = Fermi.get_lightcurve(83.6331, 22.0145, 
                                 energyrange_MeV=(100, 100000),
                                 binsize_days=30.0)
print(f"Light curve has {len(lightcurve)} time bins")

ESASky - ESA Sky Service

ESASky provides access to multi-mission data from ESA and partner missions with an integrated view of astronomical observations across multiple wavelengths.

from astroquery.esasky import ESASky

def query_object_catalogs(object_name: str, catalogs: List[str] = None,
                         radius: Union[Quantity, str] = None) -> Dict[str, Table]:
    """
    Query ESASky catalogs for sources around an object.
    
    Parameters:
    - object_name: Name of the astronomical object
    - catalogs: List of catalog names to search
    - radius: Search radius
    
    Returns:
    Dictionary with catalog names as keys and Tables as values
    """

def query_region_catalogs(coordinates: Union[SkyCoord, str], 
                         radius: Union[Quantity, str] = None,
                         catalogs: List[str] = None) -> Dict[str, Table]:
    """
    Query ESASky catalogs in a sky region.
    
    Parameters:
    - coordinates: Center coordinates
    - radius: Search radius
    - catalogs: Catalog names to search
    
    Returns:
    Dictionary with catalog results
    """

def get_images(position: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
              missions: List[str] = None) -> Dict[str, List]:
    """
    Download images from ESA missions.
    
    Parameters:
    - position: Target position
    - radius: Image size/radius
    - missions: List of mission names
    
    Returns:
    Dictionary with mission names and corresponding image data
    """

# Configuration
from astroquery.esasky import conf
conf.server: str              # ESASky server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.esasky import ESASky
import astropy.units as u
from astropy.coordinates import SkyCoord

# Query multiple catalogs around an object
catalogs = ESASky.query_object_catalogs('M31', 
                                       radius=10*u.arcmin,
                                       catalogs=['Gaia', '2MASS'])
for cat_name, table in catalogs.items():
    print(f"{cat_name}: {len(table)} sources")

# Get images from multiple missions
coords = SkyCoord('00h42m44s', '+41d16m09s', frame='icrs')
images = ESASky.get_images(coords, radius=5*u.arcmin, 
                          missions=['Hubble', 'Spitzer'])
for mission, img_list in images.items():
    print(f"{mission}: {len(img_list)} images")

HEASARC - High Energy Astrophysics Science Archive

HEASARC provides access to data from high-energy astrophysics missions including X-ray, gamma-ray, and extreme ultraviolet observations from missions like RXTE, Swift, NuSTAR, and others.

from astroquery.heasarc import Heasarc

def query_object(object_name: str, mission: str, 
                time: str = None, radius: Union[Quantity, str] = None) -> Table:
    """
    Query HEASARC for high-energy observations of an object.
    
    Parameters:
    - object_name: Name of the astronomical object
    - mission: Mission name (e.g., 'swift', 'rxte', 'nustar')
    - time: Time constraint
    - radius: Search radius
    
    Returns:
    Table with high-energy observation records
    """

def query_region(coordinates: Union[SkyCoord, str], mission: str,
                radius: Union[Quantity, str] = None, time: str = None) -> Table:
    """
    Query HEASARC for observations in a sky region.
    
    Parameters:
    - coordinates: Center coordinates
    - mission: Mission name
    - radius: Search radius
    - time: Time constraint
    
    Returns:
    Table with observations in the specified region
    """

def get_tables() -> List[str]:
    """
    Get list of available HEASARC tables/missions.
    
    Returns:
    List of available table names
    """

# Configuration
from astroquery.heasarc import conf
conf.server: str              # HEASARC server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.heasarc import Heasarc
import astropy.units as u
from astropy.coordinates import SkyCoord

# Query Swift observations of a source
swift_obs = Heasarc.query_object('Cygnus X-1', mission='swift')
print(f"Found {len(swift_obs)} Swift observations")

# Region query for NuSTAR observations
coords = SkyCoord('19h58m21.68s', '+35d12m05.8s', frame='icrs')
nustar_obs = Heasarc.query_region(coords, mission='nustar', 
                                  radius=2*u.arcmin)

# Get available missions/tables
tables = Heasarc.get_tables()
print(f"Available tables: {len(tables)}")
x_ray_tables = [t for t in tables if 'xray' in t.lower()]

Common Types

from astropy.table import Table
from astropy.coordinates import SkyCoord
from astropy.units import Quantity
from typing import Union, List, Dict, Tuple, Optional

# Input types
coordinates: Union[SkyCoord, str]           # Sky coordinates
object_name: str                            # Astronomical object name
radius: Union[Quantity, str, None]          # Search radius
mission: str                                # Mission/instrument name

# Energy/wavelength parameters
energyrange_MeV: Tuple[float, float]       # Energy range for gamma-ray
time: str                                   # Time constraints
binsize_days: float                         # Time bin size

# Return types
Table                                       # Single table result
Dict[str, Table]                           # Multiple catalog results
Dict[str, List]                            # Mission image data
List[str]                                  # Available tables/missions

Install with Tessl CLI