QuantifAI reconstructs radio interferometric images using scalable Bayesian uncertainty quantification relying on data-driven (learned) priors. It relies on the convex accelerated optimization algorithms in CRR (ascl:2401.016) and is built on top of PyTorch. QuantifAI also includes MCMC algorithms for posterior sampling.

QtClassify is a GUI that helps classify emission lines found in integral field spectroscopic data. Input needed is a datacube as well as a catalog with emission lines and a signal-to-noise cube, such at that created by LSDCat (ascl:1612.002). The main idea is to take each detected line and guess what line it could be (and thus the redshift of the object). You would expect to see other lines that might not have been detected but are visible in the cube if you know where to look, which is why parts of the spectrum are shown where other lines are expected. In addition, monochromatic layers of the datacube are displayed, making it easy to spot additional emission lines.

QSOSIM realistically simulates high-resolution quasar spectra using a set of basic parameters (magnitude, redshift, and spectral index). The simulated spectra include physical effects seen in the real data: the power-law quasar continuum, the narrow and broad emission lines, absorption by neutral hydrogen (HI) in the Lyman alpha forest, and heavy element transitions along the line of sight. The code uses empirical HI column density, redshift, and b-parameter distributions to simulate absorption in the Lyman alpha forest. All absorbers with column densities larger than log [N(HI)/cm²]>17 have heavy element absorption, for which the column densities are calculated using the plasma simulation code CLOUDY (ascl:9910.001) and the radiative transfer code CUBA. The code also simulates the clustering of the intergalactic medium along the line of sight, the proximity effect of the quasar, and the effect of the cosmic ultraviolet background. Each simulated spectrum is saved in a single FITS file in as a noiseless R=100000 spectrum, as well as a spectrum convolved with Sloan Digital Sky Survey resolution (R=10000) and realistic noise.

The QSOGEN collection of Python code models quasar colors, magnitudes and SEDs. It implements an empirically-motivated parametric model to efficiently account for the observed emission-line properties, host-galaxy contribution, dust reddening, hot dust emission, and IGM suppression in the rest-frame 900-30000A wavelength range for quasars with a wide range of redshift and luminosity. The code is packaged with a set of empirically-derived emission-line templates and an empirically-derived quasar dust extinction curve which are publicly released.

QSFit performs automatic analysis of Active Galactic Nuclei (AGN) optical spectra. It provides estimates of: AGN continuum luminosities and slopes at several restframe wavelengths; luminosities, widths and velocity offsets of 20 emission lines; luminosities of iron blended lines at optical and UV wavelengths; host galaxy luminosities. The whole fitting process is customizable for specific needs, and can be extended to analyze spectra from other data sources. The ultimate purpose of QSFit is to allow astronomers to run standardized recipes to analyze the AGN data, in a simple, replicable and shareable way.

qrpca uses QR-decomposition for fast principal component analysis. The software is particularly suited for large dimensional matrices. It makes use of torch for internal matrix computations and enables GPU acceleration, when available. Written in both R and python languages, qrpca provides functionalities similar to the prcomp (R) and sklearn (python) packages.

qp manipulates parametrizations of 1-dimensional probability distribution functions, as suitable for photo-z PDF compression. The code helps determine a parameterization for storing a catalog of photo-z PDFs that balances the available storage resources against the accuracy of the photo-z PDFs and science products reconstructed from the stored parameters.

qnm computes the Kerr quasinormal mode frequencies, angular separation constants, and spherical-spheroidal mixing coefficients. The qnm package includes a Leaver solver with the Cook-Zalutskiy spectral approach to the angular sector, and a caching mechanism to avoid repeating calculations. A large cache of low ℓ, m, n modes is available for download and can be installed with a single function call and interpolated to provide good initial guess for root-polishing at new values of spin.

Quadratic Monte Carlo generates ensembles of models and confines fitness landscapes without relying on linear stretch moves; it works very efficiently for ring potential and Rosenbrock density. The method is general and can be implemented into any existing MC software, requiring only a few lines of code.

Matching stars in astronomical images is an essential step in data reduction. This work includes some matching programs implemented by Python: simple matching, fast matching, and triangle matching. For two catalogs with m and n objects, the simple method has a time and space complexity of O(m*n) but is fast for fewer n or m. The time complexity of the fast method is O(mlogm+nlogn). The triangle method will work between rotated and scaled images. All methods are applied in pipelines and work well. This package is published to the PyPI with the name 'qmatch'.

QLF derives full posterior distributions for and analyzes luminosity functions models; it also models hydrogen and helium reionization. Used with the included homogenized data, the derived luminosity functions can be easily compared with theoretical models or future data sets.

Qhull computes the convex hull, Delaunay triangulation, Voronoi diagram, halfspace intersection about a point, furthest-site Delaunay triangulation, and furthest-site Voronoi diagram. The source code runs in 2-d, 3-d, 4-d, and higher dimensions. Qhull implements the Quickhull algorithm for computing the convex hull. It handles roundoff errors from floating point arithmetic. It computes volumes, surface areas, and approximations to the convex hull.

QFitsView is a FITS file viewer that can display one, two, and three-dimensional FITS files. It has three modes of operation, depending of what kind of data is being displayed. One-dimensional data are shown in an x-y plot. Two-dimensional images are shown in the main window. Three-dimensional data cubes can be displayed in a variety of ways, with the third dimension shown as a x-y plot at the bottom of the image display. QFitsView was written in C++ and uses the Qt widget library, which makes it available for all major platforms: Windows, MAC OS X, and many Unix variants.

Quantum ESPRESSO (opEn-Source Package for Research in Electronic Structure, Simulation, and Optimization) is an integrated suite of codes for electronic-structure calculations and materials modeling at the nanoscale. It is based on density-functional theory, plane waves, and pseudopotentials. QE performs ground-state calculations such as self-consistent total energies, forces, stresses and Kohn-Sham orbitals, Car-Parrinello and Born-Oppenheimer molecular dynamics, and quantum transport such as ballistic transport, coherent transport from maximally localized Wannier functions, and Kubo-Greenwood electrical conductivity. It can also determine spectroscopic properties and examine time-dependent density functional perturbations and electronic excitations, and has a wide range of other functions.

QDPHOT is a fast CCD stellar photometry task which quickly produces CCD stellar photometry from two CCD images of a star field. It was designed to be a data mining tool for finding high-quality stellar observations in the data archives of the National Virtual Observatory. QDPHOT typically takes just a few seconds to analyze two Hubble Space Telescope WFPC2 observations of Local Group star clusters. It is also suitable for real-time data-quality analysis of CCD observations; on-the-fly instrumental color-magnitude diagrams can be produced at the telescope console during the few seconds between CCD readouts.

QATS detects transiting extrasolar planets in time-series photometry. It relaxes the usual assumption of strictly periodic transits by permitting a variable, but bounded, interval between successive transits.

QAC (Quick Array Combinations) is a front end to CASA (ascl:1107.013) and calls tools and tasks to help in combining data from a single dish and interferometer. QAC hides some of the complexity of writing CASA scripts and provides a simple interface to array combination tools and tasks in CASA. This project was conceived alongside the TP2VIS (ascl:1904.021) project, where it was used to provide an easier way to call CASA and perform regression tests.

q3dfit performs PSF decomposition and spectral analysis for high dynamic range JWST IFU observations, allowing the user to create science-ready maps of relevant spectral features. The software takes advantage of the spectral differences between quasars and their host galaxies for maximal-contrast subtraction of the quasar point-spread function (PSF) to reveal and characterize the faint extended emission of the host galaxy. Host galaxy emission is carefully fit with a combination of stellar continuum, emission and absorption of dust and ices, and ionic and molecular emission lines.

Q3C (Quad Tree Cube) enables fast cone, ellipse and polygonal searches and cross-matches between large astronomical catalogs inside a PostgreSQL database. The package supports searches even if objects have proper motions.

pyZELDA analyzes data from Zernike wavefront sensors dedicated to high-contrast imaging applications. This modular software was originally designed to analyze data from the ZELDA wavefront sensor prototype installed in VLT/SPHERE; simple configuration files allow it to be extended to support several other instruments and testbeds. pyZELDA also includes simple simulation tools to measure the theoretical sensitivity of a sensor and to compare it to other sensors.

PyXspec is an object oriented Python interface to the XSPEC (ascl:9910.005) spectral-fitting program. It provides an alternative to Tcl, the sole scripting language for standard Xspec usage. With PyXspec loaded, a user can run Xspec with Python language scripts or interactively at a Python shell prompt; everything in PyXspec is accessible by importing the package xspec into your Python script. PyXspec can be utilized in a Python script or from the command line of the plain interactive Python interpreter. PyXspec does not implement its own command handler, so it is not intended to be run as the Python equivalent of a traditional interactive XSPEC session (which is really an enhanced interactive Tcl interpreter).

pyXSIM simulates X-ray observations from astrophysical sources. X-rays probe the high-energy universe, from hot galaxy clusters to compact objects such as neutron stars and black holes and many interesting sources in between. pyXSIM generates synthetic X-ray observations of these sources from a wide variety of models, whether from grid-based simulation codes such as FLASH (ascl:1010.082), Enzo (ascl:1010.072), and Athena (ascl:1010.014), to particle-based codes such as Gadget (ascl:0003.001) and AREPO (ascl:1909.010), and even from datasets that have been created “by hand”, such as from NumPy arrays. pyXSIM can also manipulate the synthetic observations it produces in various ways and export the simulated X-ray events to other software packages to simulate the end products of specific X-ray observatories. pyXSIM is an implementation of the PHOX (ascl:1112.004) algorithm and was initially the photon_simulator analysis module in yt (ascl:1011.022); it is dependent on yt.

Pyxel hosts and pipelines models (analytical, numerical, statistical) simulating different types of detector effects on images produced by Charge-Coupled Devices (CCD), Monolithic, and Hybrid CMOS imaging sensors. Users can provide one or more input images to Pyxel, set the detector and model parameters, and select which effects to simulate, such as cosmic rays, detector Point Spread Function (PSF), electronic noises, Charge Transfer Inefficiency (CTI), persistence, dark current, and charge diffusion, among others. The output is one or more images including the simulated detector effects combined. The Pyxel framework, written in Python, provides basic image analysis tools, an input image generator, and a parametric mode to perform parametric and sensitivity analysis. It also offers a model calibration mode to find optimal values of its parameters based on a target dataset the model should reproduce.

PyXel models astronomical X-ray imaging data; it provides a common set of image analysis tools for astronomers working with extended X-ray sources. PyXel can model surface brightness profiles from X-ray satellites using a variety of models and statistics. PyXel can, for example, fit a broken power-law model to a surface brightness profile, and fit a constant to the sky background level in the direction of the merging galaxy cluster.

PyWST performs statistical analyses of two-dimensional data with the Wavelet Scattering Transform (WST) and the Reduced Wavelet Scattering Transform (RWST). The WST/RWST provides convenient sets of coefficients for describing non-Gaussian data in a comprehensive way.

PyWPF (Waterfall Principal Component Analysis Folding) finds periodicity in one-dimensional timestream data sets; it is particularly designed for very high noise situations where traditional methods may fail. Given a timestream, with each point being the arrival times of a source, the software computes the estimated period. The core function of the package requires several initial parameters to run, and using the best known period of the source (T_init) is recommended.

PyWiFeS is a Python-based data reduction pipeline for the Wide Field Spectrograph (WiFeS). Its core data processing routines are built on standard scientific Python packages commonly used in astronomical applications. It includes an implementation of a global optical model of the spectrograph which provides wavelengths solutions accurate to ˜0.05 Å (RMS) across the entire detector. Through scripting, PyWiFeS can enable batch processing of large quantities of data.

PyWD2015 provides a modern graphical user interface (GUI) for the 2015 version of the Wilson-Devinney (WD) code (ascl:2004.004). The GUI is written in Python 2.7 and uses the Qt4 interface framework. At its core, PyWD2015 generates lcin and dcin files from user inputs and sends them to WD, then reads and visualizes the output in a user-friendly way. It also includes tools that make the technical aspects of the modeling process significantly easier.

PyVO provides access to remote data and services of the Virtual observatory (VO) using Python. It allows archive searches for data of a particular type or related to a particular topic and query submissions to obtain data to a particular archive to download selected data products. PyVO supports querying the VAO registry; simple data access services (DAL) to access images (SIA), source catalog records (Cone Search), spectra (SSA), and spectral line emission/absorption data (SLAP); and object name resolution (for converting names of objects in the sky into positions). PyVO requires both <a href="http://ascl.net/1304.002">AstroPy</a> (ascl:1304.002) and NumPy.

pyuvdata defines a pythonic interface to interferometric data sets; it supports the development of and interchange of data between calibration and foreground subtraction pipelines. It can read and write MIRIAD (ascl:1106.007), uvfits, and uvh5 files and reads CASA (ascl:1107.013) measurement sets and FHD (ascl:2205.014) visibility save files. Particular focus has been paid to supporting drift and phased array modes.

pyUPMASK is an unsupervised clustering method for stellar clusters that builds upon the original UPMASK (ascl:1504.001) package. Its general approach makes it applicable to analyses that deal with binary classes of any kind, as long as the fundamental hypotheses are met. The core of the algorithm follows the method developed in UPMASK but introducing several key enhancements that make it not only more general, they also improve its performance.

PyUltraLight computes non-relativistic ultralight dark matter dynamics in a static spacetime background. It uses pseudo-spectral methods to compute the evolution of a complex scalar field governed by the Schrödinger-Poisson system of coupled differential equations. Computations are performed on a fixed-grid with periodic boundary conditions, allowing for a decomposition of the field in momentum space by way of the discrete Fourier transform. The field is then evolved through a symmetrized split-step Fourier algorithm, in which nonlinear operators are applied in real space, while spatial derivatives are computed in Fourier space. Fourier transforms within PyUltraLight are handled using the pyFFTW pythonic wrapper around FFTW (ascl:1201.015).

PyTransport calculates the 2-point and 3-point function of inflationary perturbations produced during multi-field inflation. The core of PyTransport is C++ code which is automatically edited and compiled into a Python module once an inflationary potential is specified. This module can then be called to solve the background inflationary cosmology as well as the evolution of correlations of inflationary perturbations. PyTransport includes two additional modules written in Python, one to perform the editing and compilation, and one containing a suite of functions for common tasks such as looping over the core module to construct spectra and bispectra.

PyTransit implements optimized versions of the Giménez and Mandel & Agol transit models for exoplanet transit light-curves. The two models are implemented natively in Fortran with OpenMP parallelization, and are accessed by an object-oriented python interface. PyTransit facilitates the analysis of photometric time series of exoplanet transits consisting of hundreds of thousands of data points, and of multipassband transit light curves from spectrophotometric observations. It offers efficient model evaluation for multicolour observations and transmission spectroscopy, built-in supersampling to account for extended exposure times, and routines to calculate the projected planet-to-star distance for circular and eccentric orbits, transit durations, and more.

The Python wrapper pyTPCI couples newer versions of the hydrodynamics code PLUTO (ascl:1010.045) and the gas microphysics code CLOUDY (ascl:9910.001) to self-consistently simulate escaping atmospheres in 1D. Following TPCI (ascl:2506.012), on which pyTPCI is based, CLOUDY is modified to read in depth-dependent wind velocities, and to output useful physical quantities (including mass density, number density, and mean molecular weight as a function of depth).

PyTorchDIA is a Difference Image Analysis tool. It is built around the PyTorch machine learning framework and uses automatic differentiation and (optional) GPU support to perform fast optimizations of image models. The code offers quick results and is scalable and flexible.

Pytmosph3R computes transmission and emission spectra based on 3D atmospheric simulations, for example, performed with the LMDZ generic global climate model. It produces transmittance maps of the atmospheric limb at all wavelengths that can then be spatially integrated to yield the transmission spectrum. Pytmosph3R can use 3D time-varying atmospheric structures from a GCM as well as simpler, parameterized 1D or 2D structures, and can be used in notebooks or on the command line.

PyTICS intercalibrates photometric time-series data from multiple telescopes using a maximum likelihood ensemble photometry method. It takes as input arrays of observation dates, filter names, unique star identifiers, instrumental magnitudes and errors, and unique telescope identifiers for both comparison stars and the target, and returns intercalibrated light curves that account for telescope-dependent offsets. PyTICS can also derive empirical color-dependent corrections between instruments, and includes a Jupyter notebook and an installable library to apply these methods to general datasets.

PythonPhot is a simple Python translation of DAOPHOT-type (ascl:1104.011) photometry procedures from the IDL AstroLib (Landsman 1993), including aperture and PSF-fitting algorithms, with a few modest additions to increase functionality and ease of use. These codes allow fast, easy, and reliable photometric measurements and are currently used in the Pan-STARRS supernova pipeline and the HST CLASH/CANDELS supernova analysis.

Characterization of the frequency response of coherent radiometric receivers is a key element in estimating the flux of astrophysical emissions, since the measured signal depends on the convolution of the source spectral emission with the instrument band shape. Python-qucs automates the process of preparing input data, running simulations and exporting results of <a href="http://qucs.sourceforge.net/">QUCS</a> (Quasi Universal Circuit Simulator) simulations.

Python-CPL is a framework to configure and execute pipeline recipes written with the Common Pipeline Library (CPL) (ascl:1402.010) with Python2 or Python3. The input, calibration and output data can be specified as FITS files or as astropy.io.fits objects in memory. The package is used to implement the MUSE pipeline in the AstroWISE data management system.

The “sgp4” module is a Python wrapper around the C++ version of the standard SGP4 algorithm for propagating Earth satellite positions from the element sets published by organizations like SpaceTrak and Celestrak. The code is the most recent version, including all of the corrections and bug fixes described in the paper _Revisiting Spacetrack Report #3_ (AIAA 2006-6753) by Vallado, Crawford, Hujsak, and Kelso. The test suite verifies that the Python wrapper returns exactly the coordinates specified in the C++ test cases.

pyTANSPEC extracts XD-mode spectra automatically from data collected by the TIFR-ARIES Near Infrared Spectrometer (TANSPEC) on India's ground-based 3.6-m Devasthal Optical Telescope at Nainital, India. The TANSPEC offers three modes of observations, imaging with various filters, spectroscopy in the low-resolution prism mode with derived R~ 100-400 and the high-resolution cross-dispersed mode (XD-mode) with derived median R~ 2750 for a slit of width 0.5 arcsec. In the XD-mode, ten cross-dispersed orders are packed in the 2048 x 2048 pixels detector to cover the full wavelength regime. The XD-mode is most utilized; pyTANSPEC provides a dedicated pipeline for consistent data reduction for all orders and to reduces data reduction time. The code requires nominal human intervention only for the quality assurance of the reduced data. Two customized configuration files are used to guide the data reduction. The pipeline creates a log file for all the fits files in a given data directory from its header, identifies correct frames (science, continuum and calibration lamps) based on the user input, and offers an option to the user for eyeballing and accepting/removing of the frames, does the cleaning of raw science frames and yields final wavelength calibrated spectra of all orders simultaneously.

pysynphot is a synthetic photometry software package suitable for either library or interactive use. Intended as a modern-language successor to the IRAF/STSDAS synphot package, it provides improved algorithms that address known shortcomings in synphot, and its object-oriented design is more easily extensible than synphot's task-oriented approach. It runs under <a href="http://ascl.net/1207.011">PyRAF</a> (ascl:1207.011), and a backwards compatibility mode is provided that recognizes all spectral and throughput tables, obsmodes, and spectral expressions used by synphot, to facilitate the transition for legacy code.

pysymlog provides utilities for binning, normalizing colors, wrangling tick marks, and other tasks, in symmetric logarithm space. For numbers spanning positive and negative values, the code works in log scale with a transition through zero, down to some threshold. This is useful for representing data that span many scales such as standard log-space that include values of zero or even negative values. pysymlog provides convenient functions for creating 1D and 2D histograms and symmetric log bins, generating logspace-like arrays through zero and managing matplotlib major and minor ticks in symlog space, as well as bringing symmetric log scaling functionality to <a href="https://github.com/plotly/plotly.py">plotly</a>.

pySYD detects solar-like oscillations and measures global asteroseismic parameters. The code is a python-based implementation of the IDL-based SYD pipeline by Huber et al. (2009), which was extensively used to measure asteroseismic parameters for Kepler stars, and adapts the well-tested methodology from SYD and also improves these existing analyses. It also provides additional capabilities, including an automated best-fit background model selection, parallel processing, the ability to samples for further analyses, and an accessible and command-line friendly interface. PySYD provides best-fit values and uncertainties for the granulation background, frequency of maximum power, large frequency separation, and mean oscillation amplitudes.

pystortion provides support for distortion measurements in astronomical imagers. It includes classes to support fitting of bivariate polynomials of arbitrary degree and helper functions for crossmatching catalogs. The crossmatching uses an iterative approach in which a two-dimensional distortion model is fit at every iteration and used to continuously refine the position of extracted sources.

PyStarshade simulates high-contrast direct imaging of exoplanets with starshades. It models the optical performance of starshade-based missions by propagating complex electric fields through three planes (starshade, telescope aperture, and focal plane) using Fresnel or Fraunhofer diffraction computed with Bluestein FFTs. The toolkit computes diffracted fields and point-spread functions for a variety of starshade and telescope configurations to evaluate metrics such as core throughput, contrast, and inner working angle, and can simulate imaging for discretized exoplanet scenes while interfacing with HCIPy (ascl:2602.012) to generate telescope apertures.

pyStarburst99 is a Python version of the Starburst99 (ascl:1104.003) population synthesis code for star-forming galaxies. This Python version includes new evolutionary tracks and synthetic spectral energy distributions. pyStarburst99 provides wider coverage in metallicity, mass, and resolution, and includes evolutionary and spectral models of stars up to 300–500 M⊙.

PySSED (Python Stellar Spectral Energy Distributions) downloads and extracts data on multi-wavelength catalogs of astronomical objects and regions of interest and automatically proceses photometry into one or more stellar SEDs. It then fits those SEDs with stellar parameters. PySSED can be run directly from the command line or as a module within a Python environment. The package offers a wide variety plots, including Hertzsprung–Russell diagrams of analyzed objects, angular separation between sources in specific catalogs, and two-dimensional offset between cross-matches.

PySR performs Symbolic Regression; it uses machine learning to find an interpretable symbolic expression that optimizes some objective. Over a period of several years, PySR has been engineered from the ground up to be (1) as high-performance as possible, (2) as configurable as possible, and (3) easy to use. PySR is developed alongside the Julia library SymbolicRegression.jl, which forms the powerful search engine of PySR. Symbolic regression works best on low-dimensional datasets, but one can also extend these approaches to higher-dimensional spaces by using "Symbolic Distillation" of Neural Networks. Here, one essentially uses symbolic regression to convert a neural net to an analytic equation. Thus, these tools simultaneously present an explicit and powerful way to interpret deep neural networks.

pySPEDAS (Python-based Space Physics Environment Data Analysis Software) supports multi-mission, multi-instrument retrieval, analysis, and visualization of heliophysics time series data. A Python implementation of SPEDAS (ascl:2405.001), it supports most of the capabilities of SPEDAS; it can load heliophysics data sets from more than 30 space-based and ground-based missions, coordinate transforms, interpolation routines, and unit conversions, and provide interactive access to numerous data sets. pySPEDAS also creates multi-mission, multi-instrument figures, includes field and wave analysis tools, and performs magnetic field modeling, among other functions.

pySpectrum calculates the power spectrum and bispectrum for galaxies, halos, and dark matter.

PySpecKit is a Python spectroscopic analysis and reduction toolkit meant to be generally applicable to optical, infrared, and radio spectra. It is capable of reading FITS-standard and many non-standard file types including CLASS spectra. It contains procedures for line fitting including gaussian and voigt profile fitters, and baseline-subtraction routines. It is capable of more advanced line fitting using arbitrary model grids. Fitting can be done both in batch mode and interactively. PySpecKit also produces publication-quality plots with TeX axis labels and annotations. It is designed to be extensible, allowing user-written reader, writer, and fitting routines to be "plugged in." It is actively under development and currently in the 'alpha' phase, with plans for a beta release.

pysovo contains basic tools to work with VOEvents. Though written for specific needs, others interested in VOEvents may find it useful to examine.

The pYSOVAR code calculates properties for a stack of lightcurves, including simple descriptive statistics (mean, max, min, ...), timing (e.g. Lomb-Scargle periodograms), variability indixes (e.g. Stetson), and color properties (e.g. slope in the color-magnitude diagram). The code is written in python and is closely integrated with astropy tables. Initially, pYSOVAR was written specifically for the analysis of two clusters in the YSOVAR project, using the (not publicly released) YSOVAR database as an input. Additional functionality has been added and the code has become more general; it is now useful for other clusters in the YSOVAR dataset or for other projects that have similar data (lightcurves in one or more bands with a few hundred points for a few thousand objects), though may not work out-of-the-box for different datasets.

PYSOLATOR removes the orbital modulation from a binary pulsar and/or its companion. In essence, it subtracts the predicted Roemer delay for the given orbit and then resamples the time series so as to make the signal appear as if it were emitted from the barycenter of the binary system, making the search for pulses easier and faster.

PySME is a partial reimplementation of Spectroscopy Made Easy (SME, ascl:1202.013), which fits an observed spectrum of a star with a model spectrum. The IDL routines of SME used to call a dynamically linked library of compiled C++ and Fortran programs have been rewritten in Python. In addition, an object oriented paradigm and continuous integration practices, including build automation, self-testing, and frequent builds, have been added.

PySM generates full-sky simulations of Galactic foregrounds in intensity and polarization relevant for CMB experiments. The components simulated are thermal dust, synchrotron, AME, free-free, and CMB at a given Nside, with an option to integrate over a top hat bandpass, to add white instrument noise, and to smooth with a given beam. PySM is based on the large-scale Galactic part of Planck Sky Model code and uses some of its inputs.

pySIDES generates mock catalogs of galaxies in the (sub-)millimeter domain and associates spectral cubes (e.g., for intensity mapping experiments). It produces both continuum and CO, [CII], and [CI] line emissions. pySIDES is the Python version of the Simulated Infrared Dusty Extragalactic Sky (SIDES).

Pyshellspec models binary systems with circumstellar matter (e.g. accretion disk, jet, shell), computes the interferometric observables |V2|, arg T3, |T3|, |dV|, and arg dV, and performs comparisons of light curves, spectro-interferometry, spectra, and SED with observations, and both global and local optimization of system parameters. The code solves the inverse problem of finding the stellar and orbital parameters of the stars and circumstellar medium. Pyshellspec is based on the long-characteristic LTE radiation transfer code <a href="https://ascl.net/1108.017">Shellspec</a> (ascl:1108.017).

The statistical software package pySELFI implements the Simulator Expansion for Likelihood-Free Inference (SELFI) algorithm. SELFI is part of the family of simulation-based inference (SBI) methods, which replace the use of the likelihood function with a data-generating "black-box" simulator. pySELFI supports different black-box simulators, optimizes prior hyperparameters for primordial power spectrum inference, and check for model misspecification using the Mahalanobis distance. The code also scores compression and calculation of Fisher-Rao distances.

PySE finds and measures sources in radio telescope images. It is run with several options, such as the detection threshold (a multiple of the local noise), grid size, and the forced clean beam fit, followed by a list of input image files in standard FITS or CASA format. From these, PySe provides a list of found sources; information such as the calculated background image, source list in different formats (e.g. text, region files importable in DS9), and other data may be saved. PySe can be integrated into a pipeline; it was originally written as part of the LOFAR Transient Detection Pipeline (TraP, ascl:1412.011).

pySDR performs local gradient clustering-based sharpened dimensionality reduction (SDR). The library uses the C++ LGCDR_v1 code as its backend.

PySCo (Python Simulations for Cosmology) runs cosmological N-body simulations across various cosmological models, including Newtonian gravity, MOND gravity (quasi-linear formulation), and parametrized gravity (scale independent). It is a multi-threaded Particle-Mesh code and uses multigrid or fast Fourier transform (FFT) methods. PySCo includes an initial condition generator and power spectrum estimation, and computes the background and growth of density perturbations.

The Python Satellite Data Analysis Toolkit (pysat) provides a simple and flexible interface for downloading, loading, cleaning, managing, processing, and analyzing space science data. The toolkit supports in situ satellite observations and many different types of ground- and space-based measurements. Its analysis routines are independent of instrument and data source.

PySAP (Python Sparse data Analysis Package) provides a common API for astronomical and neuroimaging datasets and access to iSAP's (ascl:1303.029) Sparse2D executables with both wrappers and bindings. It also offers a graphical user interface for exploring the provided functions and access to application specific plugins.

The PySALT user package contains the primary reduction and analysis software tools for the SALT telescope. Currently, these tools include basic data reductions for RSS and SALTICAM in both imaging, spectroscopic, and slot modes. Basic analysis software for slot mode data is also provided. These tools are primarily written in python/<a href="http://ascl.net/1207.011">PyRAF</a> with some additional IRAF code.

pyRSD computes the theoretical predictions of the redshift-space power spectrum of galaxies. It also includes functionality for fitting data measurements and finding the optimal model parameters, using both MCMC and nonlinear optimization techniques.

pyRRG measures the 2nd and 4th order moments using a TinyTim model to correct for PSF distortions. The code is invariant to the number exposures and orientation of the drizzle images. pyRRG uses a machine learning algorithm to automatically classify stars and galaxies; this can also be done manually if greater accuracy is needed.

PyROA models quasar light curves where the variability is described using a running optimal average (ROA), and parameters are sampled using Markov Chain Monte Carlo (MCMC) techniques using emcee (ascl:1303.002). Using a Bayesian approach, priors can be used on the sampled parameters. Currently it has three main uses: 1.) Determining the time delay between lightcurves at different wavelengths; 2.) Intercalibrating light curves from multiple telescopes, merging them into a single lightcurve; and 3.) Determining the time delay between images of lensed quasars, where the microlensing effects are also modeled. PyROA also includes a noise model, where there is a parameter for each light curve that adds extra variance to the flux measurments, to account for underestimated errors; this can be turned off if required. Example jupyter notebooks that demonstrate each of the three main uses of the code are provided.

pyro is a simple python-based tutorial on computational methods for hydrodynamics. It includes 2-d solvers for advection, compressible, incompressible, and low Mach number hydrodynamics, diffusion, and multigrid. It is written with ease of understanding in mind. An extensive set of notes that is part of the <a href="http://open-astrophysics-bookshelf.github.io/">Open Astrophysics Bookshelf</a> project provides details of the algorithms.

Pyro is a flexible, scalable deep probabilistic programming library built on PyTorch. It can represent any computable probability distribution and scales to large data sets with little overhead compared to hand-written code. The library is implemented with a small core of powerful, composable abstractions. Its high-level abstractions express generative and inference models, but also allows experts to customize inference.

Pyriod provides basic period detection and fitting routines for astronomical time series. Written in Python and designed to be run interactively in a Jupyter notebook, it displays and allows the user to interact with time series data, fit frequency solutions, and save figures from the toolbar. It can display original or residuals time series, fold the time series on some frequency, add selected peaks from the periodogram to the model, and refine the fit by computing a least-squared fit of the model using Lmfit (ascl:1606.014).

A python interface to the JINA reaclib nuclear reaction database

PyRaTE (Python Radiative Transfer Emission) post-processes astrochemical simulations. This multilevel radiative transfer code uses the escape probablity method to calculate the population densities of the species under consideration. The code can handle all projection angles and geometries and can also be used to produce mock observations of the Goldreich-Kylafis effect. PyRaTE is written in Python; it uses a parallel strategy and relies on the YT analysis toolkit (ascl:1011.022), mpi4py and numba.

Pyrat Bay computes radiative-transfer spectra and fits exoplanet atmospheric properties, and is an efficient, user-friendly Python tool. The package offers transmission or emission spectra of exoplanet transit or eclipses respectively and forward-model or retrieval calculations. The radiative-transfer includes opacity sources from line-by-line molecular absorption, collision-induced absorption, Rayleigh scattering absorption, and more, including Gray aerosol opacities. Pyrat Bay's Bayesian (MCMC) posterior sampling of atmospheric parameters includes molecular abundances, temperature profile, pressure-radius, and Rayleigh and cloud properties.

PyRAF is a command language for running IRAF tasks that is based on the Python scripting language. It gives users the ability to run IRAF tasks in an environment that has all the power and flexibility of Python. PyRAF can be installed along with an existing IRAF installation; users can then choose to run either PyRAF or the IRAF CL.

pyraf-dbsp is a PyRAF-based (ascl:1207.011) reduction pipeline for optical spectra taken with the Palomar 200-inch Double Beam Spectrograph. The pipeline provides a simplified interface for basic reduction of single-object spectra with minimal overhead. It is suitable for quicklook classification of transients as well as moderate-precision (few km/s) radial velocity work.

The 1D radiation code PyRADS provides line-by-line spectral resolution. For Earth-like atmospheres, PyRADS currently uses HITRAN 2016 line lists and the MTCKD continuum model. A version for shortwave radiation (scattering) is also available.

pyqz computes the values of log(Q) [the ionization parameter] and 12+log(O/H) [the oxygen abundance, either total or in the gas phase] for a given set of strong emission lines fluxes from HII regions. The log(Q) and 12+log(O/H) values are interpolated from a finite set of diagnostic line ratio grids computed with the MAPPINGS V code (ascl:1807.005). The grids used by pyqz are chosen to be flat, without wraps, to decouple the influence of log(Q) and 12+log(O/H) on the emission line ratios.

The Python QSO fitting code (PyQSOFit) measures spectral properties of quasars. Based on Shen's IDL version, this code decomposes different components in the quasar spectrum, <i>e.g.</i>, host galaxy, power-law continuum, Fe II component, and emission lines. In addition, it can run Monte Carlo iterations using flux randomization to estimate the uncertainties.

PyPulse handles PSRFITS files and performs subsequent analyses on pulse profiles.

pyprofit is a python wrapper for libprofit (ascl:1612.003).

pyproffit performs photometric analysis of X-ray surface brightness profiles of galaxy clusters. The package provides functionality equivalent to and extending the capabilities of the original PROFFIT C++ code (ascl:1608.011). The package extracts brightness profiles in circular or elliptical annuli or arbitrary sectors, fits parametric and Bayesian models using χ², C-statistic, or MCMC methods, and includes PSF deconvolution. pyproffit also reconstructs count rates and luminosities, performs non-parametric deprojection to obtain gas-density and gas-mass profiles, and computes two-dimensional model images and fluctuation power spectra.

pyPplusS calculates the light curves for ringed, oblate or spherical exoplanets in both the uniform and limb darkened cases. It can constrain the oblateness of planets using photometric data only. This code can be used to model light curves of more complicated configurations, including multiple planets, oblate planets, moons, rings, and combinations of these, while properly and efficiently taking into account overlapping areas and limb darkening.

PyPLUTO loads, manipulates, and visualizes outputs from PLUTO (ascl:1010.045). It provides a GUI for quick checks of data during simulation runs, reads saved user defined variables, simplifies the generation of single-subplot figures, and enables further plotting of contours and velocity vectors on the surface plot. PyPLUTO also supports PLUTO's particle modules, and can load and visualize particles, including cosmic rays, Lagrangian, or dust particles from hybrid simulations.

The spectroscopy analysis pipeline pyPipe3D produces coherent and easy to distribute and compare parameters of stellar populations and ionized gas; it is suited in particular for data from the most recent optical IFS surveys. The pipeline is build using pyFIT3D, which is the main spectral fitting module included in this package.

PyPion reads in Silo (ascl:2103.025) data files from PION (ascl:2103.024) simulations and plots the data. This library works for 1D, 2D, and 3D data files and for any amount of nested-grid levels. The scripts contained in PyPion save the options entered into the command line when the python script is run, open the silo file and save all of the important header variables, open the directory in the silo (or vtk, or fits) file and save the requested variable data (eg. density, temp, etc.), and set up the plotting function and the figure.

PyPHER (Python-based PSF Homogenization kERnels) computes an homogenization kernel between two PSFs; the code is well-suited for PSF matching applications in both an astronomical or microscopy context. It can warp (rotation + resampling) the PSF images (if necessary), filter images in Fourier space using a regularized Wiener filter, and produce a homogenization kernel. PyPHER requires the pixel scale information to be present in the FITS files, which can if necessary be added by using the provided ADDPIXSCL method.

pyPETAL produces cross-correlation functions, discrete correlation functions, and mean time lags from multi-band AGN time-series data, combining multiple different codes (including pyCCF (ascl:1805.032), pyZDCF, PyROA (ascl:2107.012), and JAVELIN (ascl:1010.007)) used for active galactic nuclei (AGN) reverberation mapping (RM) analysis into a unified pipeline. This pipeline also implements outlier rejection using Damped Random Walk Gaussian process fitting, and detrending through the LinMix algorithm. pyPETAL implements a weighting scheme for all lag-producing modules, mitigating aliasing in peaks of time lag distributions between light curves. pyPETAL scales to any combination of internal code modules, supporting a variety of computational workflows.

PypeIt reduces data from echelle and low-resolution spectrometers; the code can be run in several modes of reduction that demark the level of sophistication (e.g. quick and dirty vs. MonteCarlo) and also the amount of output written to disk. It also generates numerous data products, including 1D and 2D spectra; calibration images, fits, and meta files; and quality assurance figures.

We present a module built into the PypeIt Python package to reduce high resolution Y, J, H, K, and L band spectra from the W. M. Keck Observatory NIRSPEC spectrograph. This data reduction pipeline is capable of spectral extraction, wavelength calibration, and telluric correction of data taken before and after the 2018 detector upgrade, all in a single package. The procedure for reducing data is thoroughly documented in an expansive tutorial.

PyPDR calculates the chemistry, thermal balance and molecular excitation of a slab of gas under FUV irradiation in a self-consistent way. The effect of FUV irradiation on the chemistry is that molecules get photodissociated and the gas is heated up to several 1000 K, mostly by the photoelectric effect on small dust grains or UV pumping of H2 followed by collision de-excitation. The gas is cooled by molecular and atomic lines, thus indirectly the chemical composition also affects the thermal structure through the abundance of molecules and atoms. To find a self-consistent solution between heating and cooling, the code iteratively calculates the chemistry, thermal-balance and molecular/atomic excitation.

PyOSE is a fully numerical orbital sampling effect (OSE) simulator that can model arbitrary inclinations of the transiting moon orbit. It can be used to search for exomoons in long-term stellar light curves such as those by Kepler and the upcoming PLATO mission.

PyORBIT handles several kinds of datasets, such as radial velocity (RV), activity indexes, and photometry, to simultaneously characterize the orbital parameters of exoplanets and the noise induced by the activity of the host star. RV computation is performed using either non-interacting Kepler orbits or n-body integration. Stellar activity can be modeled either with sinusoids at the rotational period and its harmonics or Gaussian process. In addition, the code can model offsets and systematics in measurements from several instruments. The PyORBIT code is modular; new methods for stellar activity modeling or parameter estimation can easily be incorporated into the code.

pyobs enables remote and fully autonomous observation control of astronomical telescopes. It provides an abstraction layer over existing drivers and a means of communication between different devices (called modules in pyobs). The code can also act as a hardware driver for all the devices used at an observatory. In addition, pyobs offers non-hardware-related modules for automating focusing, acquisition, guiding, and other routine tasks.

pynucastro interfaces to the nuclear reaction rate databases, including the JINA Reaclib nuclear reactions database. This set of Python interfaces enables interactive exploration of rates and collection of rates (networks) in Jupyter notebooks and easy creation of the righthand side routines for reaction network integration (the ODEs) for use in simulation codes.

PynPoint uses principal component analysis to detect and estimate the flux of exoplanets in two-dimensional imaging data. It processes many, typically several thousands, of frames to remove the light from the star so as to reveal the companion planet. The code has been significantly rewritten and expanded; please see ascl:1812.010.

PynPoint processes and analyzes high-contrast imaging data of exoplanets and circumstellar disks. The generic, end-to-end pipeline's modular architecture separates the core functionalities and the pipeline modules. These modules have specific tasks such as background subtraction, frame selection, centering, PSF subtraction with principal component analysis, estimation of detection limits, and photometric and astrometric analysis. All modules store their results in a central database. Management of the available hardware by the backend of the pipeline is in particular an advantage for data sets containing thousands of images, as is common in the mid-infrared wavelength regime. This version of PynPoint is a significant rewrite of the earlier PynPoint package (ascl:1501.001).