Saravanan666/pypi-org huggingface dataset:
Package: astroabc
Approximate Bayesian computation (ABC) and so
called “likelihood free” Markov chain Monte Carlo
techniques are popular methods for tackling parameter
inference in scenarios where the likelihood is intractable or unknown.
These methods are called likelihood free as they are free from
the usual assumptions about the form of the likelihood e.g. Gaussian,
as ABC aims to simulate samples from the parameter posterior distribution directly.astroABCis a python package that implements
an Approximate Bayesian Computation Sequential Monte Carlo (ABC SMC) sampler
as a python class. It is extremely flexible and applicable to a large suite of problems.astroABCrequiresNumPy,``SciPy`` andsklearn.mpi4pyandmultiprocessingare optional.
Package: astroalign
ASTROALIGNis a python module that will try to align two stellar astronomical images, especially when there is no WCS information available.It does so by finding similar 3-point asterisms (triangles) in both images and deducing the affine transformation between them.Generic registration routines try to match feature points, using corner
detection routines to make the point correspondence.
These generally fail for stellar astronomical images, since stars have very
little stable structure and so, in general, indistinguishable from each other.
Asterism matching is more robust, and closer to the human way of matching stellar images.Astroalign can match images of very different field of view, point-spread function, seeing and atmospheric conditions.It may not work, or work with special care, on images of extended objects with few point-like sources or in very crowded fields.You can find a Jupyter notebook example with the main features athttp://quatrope.github.io/astroalign/.Full documentation:https://astroalign.readthedocs.io/InstallationUsing setuptools:$pipinstallastroalignor from this distribution with$pythonsetup.pyinstallPerformance: OptionalThis library is optionally compatible withbottleneckand may offer performance improvements in some cases.
Install bottleneck in your project as a peer to astroalign using:pipinstallbottleneckAstroalignwill pick this optional dependency up and use it's performance improved functions for computing transforms.Running Testspythontests/test_align.pyUsage example>>> import astroalign as aa
>>> aligned_image, footprint = aa.register(source_image, target_image)In this examplesource_imagewill be interpolated by a transformation to coincide pixel to pixel withtarget_imageand stored inaligned_image.If we are only interested in knowing the transformation and the correspondence of control points in both images, usefind_transformwill return the transformation in aScikit-ImageSimilarityTransformobject and a list of stars in source with the corresponding stars in target.>>> transf, (s_list, t_list) = aa.find_transform(source, target)sourceandtargetcan each either be the numpy array of the image (grayscale or color),
or an iterable of (x, y) pairs of star positions on the image.The returnedtransfobject is a scikit-imageSimilarityTranformobject that contains the transformation matrix along with the scale, rotation and translation parameters.s_listandt_listare numpy arrays of (x, y) point correspondence betweensourceandtarget.transfapplied tos_listwill approximately rendert_list.Related SoftwareThere are other related software that may offer similar functionality as astroalign.
This list is not exhaustive and may be others.astrometry.netreprojectWatney Astrometry EngineStellar SolverMontageCitationIf you use astroalign in a scientific publication, we would appreciate citations to the followingpaper:Astroalign: A Python module for astronomical image registration.
Beroiz, M., Cabral, J. B., & Sanchez, B.
Astronomy & Computing, Volume 32, July 2020, 100384.TOROS Dev Teammartinberoiz@gmail.com
Package: astro-brutus
# brutus
#### _**Et tu, Brute?**_brutusis a Pure Python package whose core modules involve using
“brute force” Bayesian inference to derive distances, reddenings, and
stellar properties from photometry using a grid of stellar models.The package is designed to be highly modular, with current modules including
utilities for modeling individual stars, star clusters, and
stellar-based 3-D dust mapping.### DocumentationCurrently nonexistent.### DataVarious files needed to run different `brutus` modules can be downloaded
[here](https://www.dropbox.com/sh/ozq9tk8iyy8fhte/AAC_G0wA9eQ8shHbZzAKwLe-a?dl=0).Various components of these are described below.#### Stellar Models
Note that whilebrutuscan (in theory) be run over an arbitrary set of
stellar models, it is configured for two by default:
[MIST](http://waps.cfa.harvard.edu/MIST/)
and [Bayestar](https://arxiv.org/abs/1401.1508).#### Zero-points
Zero-point offsets in several bands have been estimated using Gaia data
and can be included during runtime.These are currently not thoroughly vetted, so use at your own risk.#### Dust Mapbrutusis able to incorporate a 3-D dust prior. The current prior is
based on the “Bayestar19” dust map from
[Green et al. (2019)](https://arxiv.org/abs/1905.02734).#### Generating SEDsbrutuscontains built-in SED generation utilities based on the MIST
stellar models, modeled off of
[minesweeper](https://github.com/pacargile/MINESweeper).
These are optimized for either generating photometry from stellar mass
tracks or for a single-age stellar isochrone based on
artificial neural networks trained on bolometric correction tables.Empirical corrections to the MIST models derived using several clusters are
implemented by default, which improves main sequence behavior
down to ~0.5 solar masses.
These can be easily disabled by users using the appropriate flag.These are currently not thoroughly vetted.Please contact Phil Cargile (pcargile@cfa.harvard.edu) and Josh Speagle
(jspeagle@cfa.harvard.edu) for more information on the provided data files.### Installationbrutuscan be installed by running` python setup.py install `from inside the repository.### Demos
Several Jupyter notebooks currently outline very basic usage of the code.
Please contact Josh Speagle (jspeagle@cfa.harvard.edu) with any questions.
Package: astrocalculator
AstroCalculator, a Calculator for Astronomers and PhysicistsAboutAstroCalculator is a calculator for astronomers and physicists written in Python.Author: Chong-Chong He (che1234@umd.edu)InstallationYou can install astrocalculator fromPyPI:pipinstallastrocalculatorastrocalculatoris supported on Python 3.6 and above.How to useStart the program withcalc. You will see a command line interface where you can type in your inputs. A input can be 1) a single variable or constant likek_B, 2) an expression likem_e c^2, or 3) a list of variable assignments followed by a final expression to evaluate, e.g.M = 1.4 M_sun, R = 10 km, sqrt(2 G M / R).Another way is to use it as a Python module in your script or interactively in iPython. Put the following in your code:fromcalcimport*Now you can use all the physical constants defined inastrocalculatoras listed inhere.Example inputs and outputsInput[1]: m_p

Parsed input = m_p
Result (SI)  = 
  Name   = Proton mass
  Value  = 1.67262192369e-27
  Uncertainty  = 5.1e-37
  Unit  = kg
  Reference = CODATA 2018
Result (cgs) = 1.6726e-24 g

Input[2]: m_e c^2

Parsed input = c**2*m_e
Result (SI)  = 8.1871e-14 m N
Result (cgs) = 8.1871e-07 erg

Input[3]: in MeV

0.51100 MeV

Input[4]: M = 1.4 M_sun, R = 10 km, sqrt(2 G M / R)

Parsed input = sqrt(2*G*M*1/R)
Result (SI)  = 1.9277e+08 m / s
Result (cgs) = 1.9277e+10 cm / s

Input[5]: in km/s

1.9277e+05 km / sTodosparse keyword 'in' at the last line and automatically change User Unit.Add latex previewReferenceshttps://docs.astropy.org/en/stable/units/https://docs.astropy.org/en/stable/constants/https://www.lidavidm.me/blog/posts/2013-09-15-implicit-parsing-in-sympy.htmlhttps://stackoverflow.com/questions/62507535/python-suppress-expansion-of-exponential-notation-in-parse-expr-sympy
Package: astrocats
# Astrocats: Open Astronomy Catalogs #[![Build Status](https://img.shields.io/travis/astrocatalogs/astrocats.svg)](https://travis-ci.org/astrocatalogs/astrocats)
[![Coverage Status](https://coveralls.io/repos/github/astrocatalogs/astrocats/badge.svg?branch=master)](https://coveralls.io/github/astrocatalogs/astrocats?branch=master)
[![Python Version](https://img.shields.io/badge/python-2.7%2C%203.4%2C%203.5%2C%203.6-blue.svg)](https://www.python.org)
[![Python Version](https://img.shields.io/badge/arXiv-1605.01054-green.svg?style=flat)](http://arxiv.org/abs/1605.01054)The Astrocats package enables astronomers to construct their own curated catalogs of astronomical data with the intention of producing shareable catalogs of that data in human-readable formats. Astrocats is used by several existing open astronomy catalogs, including:[The Open Supernova Catalog](https://sne.space) [[GitHub repo](https://github.com/astrocatalogs/supernovae)][The Open TDE Catalog](https://tde.space) [[GitHub repo](https://github.com/astrocatalogs/tidaldisruptions)][The Open Nova Catalog](https://opennova.space) [[GitHub repo](https://github.com/astrocatalogs/novae)][The Open Black Hole Catalog](https://holes.space) [[GitHub repo](https://github.com/astrocatalogs/blackholes)]The process for creating one’s own open astronomy catalog involves checking out this package and designing a “module” for it that is specific to that catalog’s needs, a [Wiki is available](https://github.com/astrocatalogs/astrocats/wiki) with instructions for doing so. At the moment the most developed module is the Open Supernova Catalog module; to set up astrocats with the supernovae module, one needs to check out two repositories:`shell git clone git@github.com:astrocatalogs/astrocats.git cd astrocats git clone git@github.com:astrocatalogs/supernovae.git `Astrocats will soon be listed on PyPi, at which point the install instructions will involve pip and a setup script, for now the install must be performed manually.
Package: astrochart-svg
Astro Charts SVGastro_svg is a chart generator based on Kerykeion and Opeanstro.
Like the titles says it prints out SVG file of the chart,
it's very easy to use.# Install:>>>pip3installastro_svg#Import:>>>importastrochart_svgasas# Make the instance:>>>kanye=as.MakeInstance("Kanye",1977,6,8,8,45,"Atlanta",type="Natal")# Set the output directory for the SVG:>>>kanye.output_directory="/Users/{YourName}"#Generate the SVG:>>>kanye.makeSVG()SVGgeneratedsuccessfully!>>>first=kr.Calculator("Jack",1990,6,15,13,00,"Montichiari")>>>second=kr.Calculator("Jane",1991,6,11,21,00,"Cremona")>>>name=MakeInstance(first,chart_type="Transit",second_obj=second)>>>name.makeSVG()DocumentationJust like in the exemple, first make an instance and then use the makeSVG() to generate the SVG chart.
The file generated has the name you inserted followed by Chart.svgInstallationBirtchartSVG is Python 3 package, make sure you have Python 3 installed on your system.DevelopmentYou can clone this repository or download a zip file using the right side buttons.
Package: astrochem-ml
Doing astrochemistry with robots.Theastrochem_mlpackage is designed for bringing accessible cheminformatics to
astrochemical discovery. The main features, some of which are currently active
development, are interfaces to common operations using RDKit that are relevant
to astrochemistry, and pre-trained embedding models ready for machine learning
projects that combine molecules and astrophysics.The plan is to deliver a general purpose library, in addition to providing a
command line interface to several common tasks.Free software: MIT licenseDocumentation:https://astrochem-ml.readthedocs.io.InstallationNot yet on PyPI, and so for now you can installastrochem_mlvia:`pip installgit+https://github.com/laserkelvin/astrochem_ml`FeaturesMolecule generationA significant amount of functionality wraps therdkitpackage, the main library
for doing cheminformatics in Python. For all molecule interactions, we go back
and forth between the nativerdkitobjects and SMILES/SMARTS strings.Exhaustive isotopologue generation in SMILES>>>fromastrochem_ml.smilesimportisotopes# exhaustively enumerate all possible combinations isotopologues# user can set the threshold for natural abundance and whether# to include hydrogens>>>isotopes.generate_all_isos("c1ccccc1",explicit_h=False)['c1[13cH]c[13cH][13cH][13cH]1',...'c1ccccc1','[13cH]1[13cH][13cH][13cH][13cH][13cH]1','c1c[13cH][13cH][13cH]c1']Functional group substitutionsReplace substructures with other ones in a tree data structure!>>>fromastrochem_ml.smilesimportMoleculeGenerator# randomly grow out possible structures starting from benzene,# and iteratively replace structures with other functional groups>>>benzene=MoleculeGenerator("c1ccccc1",substructs=["c","cC#N","cC=O","cN"])>>>benzene.grow_tree(50)100%|██████████████████████████████████████████████████████████████████|50/50[00:00<00:00,237.44it/s]>>>print(benzene)c1ccccc1├──Nc1ccccc1├──N#Cc1ccccc1└──O=Cc1ccccc1├──Nc1ccccc1C=O│└──N#Cc1ccccc1C=O├──Nc1cccc(C=O)c1│├──Nc1cccc(C=O)c1N││├──Nc1c(C=O)ccc(C=O)c1N││├──Nc1cc(C=O)cc(C=O)c1N...This provides a high level interface to view every structure generated,
and from which parent.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: astroconst
AstroConstA Python package that provides astronomical constants.
The code is being developed byMarc van der Sluysof the department of
Astrophysics at the Radboud University Nijmegen, the Institute of Nuclear and High-Energy Physics (Nikhef),
and the Institute for Gravitational and Subatomic Physics (GRASP) at Utrecht University, all in The
Netherlands.  The AstroConst package can be used under the conditions of theEUPL 1.2licence.Note that the package is currently is its alpha stage, and things may still change as I start using this.InstallationThis package can be installed usingpip install astroconst.  This should automatically install the
dependency packagenumpy, if it has't been installed already.  If you are installing by hand, ensure that
this package is installed as well.Example useSI units should be used everywhere - no ergs, dyn or cm (sorry!).  Values include mathematical constants (like
π), angle-conversion factors (from/to radians, degrees, hours, arcseconds, ...), calendar stuff (names of
weekdays and months, JDs, lengths of days, months and years), solar-system objects (Sun, Moon, planet
names diameters, orbital separations, etc. - note that Moon = planet #0), and some basic physical constants
((Stefan-)Bolzmann, Planck, speed of light, etc.).The submoduleaacontains constants published by the Astronomical Almanac, converted to Python."""Example Python script using the AstroConst package."""importastroconstasacprint(ac.c)# 299792458 (speed of light, quick access)print(ac.aa.c)# Access constants from Astronomical Almanacprint(ac.jd2000)# 2451545print(ac.m_sun)# 1.9891e+30 (kg)print(ac.sol_const)# 1361.5 (W/m2)print(ac.year_jul)# 31557600.0 (s)print(ac.year_jul/ac.day)# 365.25 (days)print(ac.month_syn/ac.day)# 29.530588853 (days)print('The diameter of '+ac.plname_en[5]+' is '+str(ac.pl_d[5]/ac.km)+' km')# The diameter of Jupiter is 142984 kmprint('a_'+ac.plname_en[0]+' = '+str(ac.pl_a[0]/ac.km)+' km')# a_Moon = 384400.0 km (Moon = planet #0)print(ac.dow_en_abr[0])# Sunprint(ac.months_en[3])# MarchAstroConst pagesPypi: AstroConst Python packageGitHub: AstroConst source codeReadTheDocs: AstroConst documentationAuthor and licenceAuthor: Marc van der SluysContact:http://marc.vandersluys.nlLicence:EUPL 1.2ReferencesThe Astronomical Almanac Online!Copyright (c) 2022 Marc van der Sluys
Package: astro-crispy
CRISPyComputational Ridge Identification with SCMS for PythonThis code is a python implementation of the generalized Subspace Constrained Mean Shift (SCMS) algorithm, translated and modified from theR-codedeveloped byYen-Chi Chen(University of Washington).Please cite the following papers when using the code:Ozertem, Umut, and Deniz Erdogmus. "Locally Defined Principal Curves and Surfaces." The Journal of Machine Learning Research 12 (2011): 1249-1286.Chen, Yen-Chi, Christopher Genovese, Christopher R. Genovese, and Larry Wasserman. "Generalized Mode and Ridge Estimation." (2014): arXiv :1406.1803Chen, Yen-Chi, Shirley Ho, Peter E. Freeman, Christopher R. Genovese, and Larry Wasserman. "Cosmic Web Reconstruction through Density Ridges: Method and Algorithm." MNRAS 454 1140 (2015) arXiv: 1501.05303Chen, Michael Chun-Yuan, et al. "Velocity-Coherent Filaments in NGC 1333: Evidence for Accretion Flow?" ApJ (2019, submitted)
Package: astrodbkit2
Astronomical database handler codeAstrodbKit2 is an astronomical database handler code built on top of SQLAlchemy.
This is built to work with theSIMPLE database, though
similarly constructed databases will work.Documentation is available athttps://astrodbkit2.readthedocs.io/en/latest/LicenseThis project is Copyright (c) David Rodriguez and licensed under
the terms of the BSD 3-Clause license. This package is based upon
theAstropy package templatewhich is licensed under the BSD 3-clause license. See the licenses folder for
more information.ContributingWe love contributions!AstrodbKit2is open source,
built on open source, and we’d love to have you hang out in our community.Imposter syndrome disclaimer: We want your help. No, really.There may be a little voice inside your head that is telling you that you’re not
ready to be an open source contributor; that your skills aren’t nearly good
enough to contribute. What could you possibly offer a project like this one?We assure you - the little voice in your head is wrong. If you can write code at
all, you can contribute code to open source. Contributing to open source
projects is a fantastic way to advance one’s coding skills. Writing perfect code
isn’t the measure of a good developer (that would disqualify all of us!); it’s
trying to create something, making mistakes, and learning from those
mistakes. That’s how we all improve, and we are happy to help others learn.Being an open source contributor doesn’t just mean writing code, either. You can
help out by writing documentation, tests, or even giving feedback about the
project (and yes - that includes giving feedback about the contribution
process). Some of these contributions may be the most valuable to the project as
a whole, because you’re coming to the project with fresh eyes, so you can see
the errors and assumptions that seasoned contributors have glossed over.Note: This disclaimer was originally written byAdrienne Lowefor aPyCon talk, and was adapted by
AstrodbKit2 based on its use in the README file for theMetPy project.
Package: astro-delight
TheDeep Learning Identification of Galaxy Hosts in Transients (DELIGHT,Förster et al. 2022)is a library created by theALeRCE brokerto automatically identify host galaxies of transient candidates using multi-resolution images and a convolutional neural network (you can test it with ourexample notebook, that you can run inColab). The initial idea for DELIGHT started as a project proposed for theLa Serena School of Data Sciencein 2021.You can install it usingpip install astro-delight, but we recommend cloning this repository andpip install .from there.The library has a class with several methods that allow you to get the most likely host coordinates starting from given transient coordinates. In order to do this, the delight object needs a list of object identifiers and coordinates (oid, ra, dec). With this information, it downloadsPanSTARRSimages centered around the position of the transients (2 arcmin x 2 arcmin), gets their WCS solutions, creates the multi-resolution images, does some extra preprocessing of the data, and finally predicts the position of the hosts using a multi-resolution image and a convolutional neural network. It can also estimate the host's semi-major axis if requested taking advantage of the multi-resolution images.Note that DELIGHT's prediction time is currently dominated by the time to downloadPanSTARRSimages using thepanstamps service. In the future, we expect that there will be services that directly provide multi-resolution images, which should be more lightweight with no significant loss of information. Once these images are obtained, the processing times are only milliseconds per host.If you cannot install some of the dependencies, e.g. tensorflow, you can try running DELIGHT directly from Google Colab (test in thislink).Classes:Delight: the main class containing the methods to predict host galaxy positions starting from transient coordinatesMethods(most important):init: class constructor, it requires a list of object identifiers, a list of right ascensions, and a list of declinationsdownload: downloadsPanSTARRSfits files using thepanstampsservive.get_pix_coords: gets the WCS solution in the fits files to move from pixel to celestial coordinates.compute_multiresolution: transform thePanSTARRSimages to multi-resolution imagesload_model: load DELIGHT'sTensorflowmodelpredict: predict the host positionsplot_host: plot the original host image, the multi-resolution images, and the transient and predicted host positionget_hostsize: estimate the host semi-major axissave: save the resulting dataframeload: load the resulting dataframeRequirements:xarray (python -m pip install xarray)astropy (pip install astropy)sep (pip install sep)tensorflow (https://www.tensorflow.org/install/pip,pip install tensorflow)pantamps (pip install panstamps)DELIGHT's multi-resolution images and prediction vector:DELIGHT's neural network architecture:
Package: astrodom
AstroDomAstro(nomy) Dom(ine) is a catalogue tool for deep sky images. It scans the directories where images (FITS format only) arestored and reads information from FITS headers.
Additional parameter like FWHM, Eccentricity, Noise can be added from Pixinsight CSV exports from SubFrameSelector process.The catalogue can be used to keep track of your imaging sessions and to benchmark your images.
With the Charts tool you can discover important information about your data, e.g.:How much Alt affects FWHMWhich night had the best seeing conditionsWhere in the sky (Alt, Az) the guiding is best / worse.How many hours for each filterAstroDom was tested with FITS files written by MaximDL (v4 and v6), Ekos/INDI, SGP but any other software is supported through custom profiles.
Check the documentation here:DocumentationFeaturesScans recursively filesystem directories searching for FITS files.Add image parameters from Pixinsight's SubFrameSelector process: FWHM, Eccentricity, SNRWeight, Noise.List, filter, search all the images in the database. It shows mean values and standard deviation for most important parameters. See image 1 below.Outputs charts with several information. See image 2 below.ScreenshotMain window with search criteria and results:Charts plotted for a subset of images (colors map different filters):