Saravanan666/pypi-org huggingface dataset:
Package: astropy
The Astropy Project (http://astropy.org/) is a community effort to develop a
single core package for Astronomy in Python and foster interoperability between
Python astronomy packages. This repository contains the core package which is
intended to contain much of the core functionality and some common tools needed
for performing astronomy and astrophysics with Python.Releases areregistered on PyPI,
and development is occurring at theproject’s GitHub page.For installation instructions, see theonline documentationordocs/install.rstin this source distribution.Contributing Code, Documentation, or FeedbackThe Astropy Project is made both by and for its users, so we welcome and
encourage contributions of many kinds. Our goal is to keep this a positive,
inclusive, successful, and growing community by abiding with theAstropy Community Code of Conduct.More detailed information on contributing to the project or submitting feedback
can be found on thecontributionspage. Asummary of contribution guidelinescan also be
used as a quick reference when you are ready to start writing or validating
code for submission.Getting started with GitHub CodespacesCodespaces is a cloud development environment supported by GitHub. None of the Astropy build machinery depends on it, but it is a convenient way to quickly get started doing development on Astropy.To get started, create a codespace for this repository by clicking this 👇A codespace will open in a web-based version of Visual Studio Code. Thedev containeris fully configured with software needed for this project. Feel free to take a look atGitHub Codespaces Supportpage for help.Note: Dev containers is an open spec which is supported byGitHub Codespacesandother tools.Supporting the ProjectThe Astropy Project is sponsored by NumFOCUS, a 501(c)(3) nonprofit in the
United States. You can donate to the project by using the link above, and this
donation will support our mission to promote sustainable, high-level code base
for the astronomy community, open code development, educational materials, and
reproducible scientific research.LicenseAstropy is licensed under a 3-clause BSD style license - see theLICENSE.rstfile.If you locally cloned this repo before 7 Apr 2021The primary branch for this repo has been transitioned frommastertomain.  If you have a local clone of this repository and want to keep your
local branch in sync with this repo, you’ll need to do the following in your
local clone from your terminal:git fetch --all --prune
# you can stop here if you don't use your local "master"/"main" branch
git branch -m master main
git branch -u origin/main mainIf you are using a GUI to manage your repos you’ll have to find the equivalent
commands as it’s different for different programs. Alternatively, you can just
delete your local clone and re-clone!
Package: astropy-changelog
AboutThis package contains a parser for the Astropy changelog format. Example usage:In[1]:fromastropy_changelogimportloadIn[2]:changes=load('CHANGES.rst')In[3]:changes.versionsOut[3]:['0.1','0.2','0.2.1','0.2.2','0.2.3',...]In[4]:changes.issuesOut[4]:[256,272,291,293,296,...]In[5]:changes.versions_for_issue(4242)Out[5]:['1.2']In[6]:changes.issues_for_version('2.0.7')Out[6]:[7411,7248,7402,7422,7469,7486,7453,7493,7510,7493]Format specificationThe current format uses reStructuredText. Changelog entries should be given as
bullet point items inside sections for each version. These sections should have
a title with the following syntax:version (release date)The release date can beunreleasedif the version is not released yet.The version sections can optionally include sub-sections in which the bullet
items are organized, and the file can also optionally include an overall title.
Package: astropy-healpix
astropy healpixThis is a BSD-licensed HEALPix package developed by the Astropy project
and based on C code written by Dustin Lang inastrometry.net. See theDocumentationfor
information about installing and using this package.LicenseThis project is Copyright (c) Astropy Developers 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! astropy-healpix is 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
astropy-healpix based on its use in the README file for theMetPy project.
Package: astropy-helpers
Theastropy-helperspackage includes many build, installation, and
documentation-related tools used by the Astropy project, but packaged separately
for use by other projects that wish to leverage this work. The motivation behind
this package and details of its implementation are in the acceptedAstropy Proposal for Enhancement (APE) 4.Astropy-helpers is not a traditional package in the sense that it is not
intended to be installed directly by users or developers. Instead, it is meant
to be accessed when thesetup.pycommand is run - see the
“Using astropy-helpers in a package”
section in the documentation for how to do this.
For a real-life example of how to implement astropy-helpers in a
project, see thesetup.pyandsetup.cfgfiles of theAffiliated package template.For more information, see the documentation athttp://astropy-helpers.readthedocs.io
Package: astropy-iers-data
IERS Earth Rotation and Leap Second tables for the astropy core packageNote:This package is not currently meant to be used directly by users, and only
meant to be used from the core astropy package.https://docs.astropy.org/en/latest/utils/iers.htmlLicenseThis project is Copyright (c) Astropy Developers and licensed under
the terms of the BSD 3-Clause license. This package is based upon
theOpenAstronomy packaging guidewhich is licensed under the BSD 3-clause licence. See the licenses folder for
more information.ContributingWe love contributions! astropy-iers-data is 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
astropy-iers-data based on its use in the README file for theMetPy project.
Package: astropy-sphinx-theme
This is the repository for the default Astropy project documentation
theme(s). To use this theme, simply install this package then add the
following line to your documentation’sconf.pyfile:html_theme='bootstrap-astropy'This requires Sphinx 1.6 or later to work properly. For older versions
of Sphinx, you will need to do:importastropy_sphinx_themehtml_theme_path=astropy_sphinx_theme.get_html_theme_path()html_theme='bootstrap-astropy'bootstrap-astropyis the only theme that is currently available, but
the structure of the package allows more themes to be added in future if
needed.Several options for the theme can be set in theconf.pyfile:html_theme_options={'logotext1':'packagename',# white,  semi-bold'logotext2':'',# orange, light'logotext3':':docs',# white,  light'astropy_project_menubar':True}Thelogotext?options can be used to customize the top left logo, while
theastropy_project_menubaroption can be set toTruefor packages
that are managed by the project itself (this will add links to find out more
about the Astropy project, about the team, and so on).
Package: astro-pyvista
pyvista is a package for the inspection, reduction, and analysis
of astronomical data. It includes a native Python display tool, tv,
that is modeled after the original xvista display tool.Much of the package is under some level of development, but includes
modules for:image display (tv)image reduction (imred)spectral analysis (spectra) : tracing, wavelength calibration, fluxingobservation planning (skycalc) : wrappers around astroplanexposure time calculation tools (etc)stellar photometry (stars) : wrappers around photutils)image manipulation (image) : functions for basic image manipulation, including boxesimage simulation (simulate)Help can be found athttps://pyvista.readthedocs.orgSome examples, in the form of jupyter notebooks, can be found
in the docs/notebooks subdirectory of the distribution, seehttps://github.com/holtzmanjon/pyvista/tree/main/doc/notebooksQuestions, requests, etc. can  be directed to Jon Holtzman atholtz@nmsu.edu
Package: astrosa
AstroSA: Astronomical Observation Scheduler AssessmentThis project is an assessment framework for astronomical observation schedulers.这是一个评价天文观测调度器的框架。UsageRefers tomain.py参见：main.pyRequirementspython-mpipinstall-rrequirements.txtInstallAstroSA is available in Pypi.pipinstallastrosaAlso, you can install from source code.gitclonehttps://github/h-xie/astrosacdastrosa
pipinstall.DataAstroSA provide a sqlite database in directoryastrosa/data/astrosa.sqlite.It contains experimental data from the
paper, including a
priority plan, a sequential plan, and corresponding cloud data on the date 2023-06-08 at location JLO.You can use byimportsqlite3importastrosadatabase=astrosa.DATA_DIRconn=sqlite3.connect(database+'/astrosa.sqlite')CatalogueWe also provide a data converter fromVizieRtosqliteintyc2_to_sql.ipynb. You can use it to convert tycho-2
from FITS format to sqlite format. Tycho-2 catalogue can be downloaded via:Tycho-2 catalogue in FITSCloudWe provide cloud image to score scriptcloud_to_data.py. You can use it to convert cloud image to cloud data. It only
counts NIGHT.pythoncloud_to_data.py-fpath_to_your_cloud_image
Package: astro-salsa
SALSASALSA: Synthetic Absorption Line Surveyor Application is a Python tool that
constructs synthetic absorber catalogs from hydrodynamic galaxy simulations.
Salsa heavily utilizesytto access simulation data
andTridentto create light rays/sight lines and
generate synthetic spectra.Observational studies generate large absorber catalogs by studying the absorption
line spectra of distant quasars, as their light passes through intervening galaxies.
Salsa can generate similar catalogs from cosmological and galactic simulations,
allowing research to study these simulations from an observers perspective. This
can give new insights into the data as well as help facilitate comparisons and
collaboration between simulations and observations.Salsa allows us to dip into galactic simulations and start to chip away at the
many unknowns of the universeAJOSS paperwas published for
SALSA and we recommend reading it for an overview of the package and its possible uses.
If you do use SALSA in a project we ask that you cite this paper.For detailed information on how to install and run salsa, Read the DocshereInstallIf you have all the dependencies installed, you can clone the repository and
run these commands:$ git clone https://github.com/biboyd/SALSA.git
  $ cd SALSA
  $ pip install -e .
  $ python
  >>> import salsaNow you should be all set to code!Installing dependenciesTo help with installing dependencies,enivronment.ymlis included in the
repository. First,install condaThen you should be able to create a conda environment via:$ conda env create --file environment.yml
  $ conda activate salsa-envNote that you need gcc compiler installed (which it often already is on most machines).
For a more detailed description see theinstallation guidewhich also includes tips if you want to install dependencies on your own.Getting StartedFor an annotated examplego here. Or launch an interactive jupyter hosted on Binderhere(note that the notebook
may take some time to load as it generally has to build the repository).If you want to explore on your own, the easiest way to get started is usesalsa.generate_catalog(). This takes:The simulation datasetNumber of light rays/sightlines to makeDirectory to save those light raysA list of ionsSome other optional parameters.This creates a number light rays and then extracts absorbers for each ion. Apandas.DataFrameis returned with information about all the absorbers which
can then be further analyzed.Contributing GuidelinesAll contributions are welcome! This is an open-source project, built on many
other open-source projects. Contributing can take many forms including:
contributing code, testing and experimenting, or offering ideas for different
features.If you are interested in contributing you can contact us directly atboyd.brendan@stonybrook.eduor add an issue on this Github page.
Package: astroscrappy
An optimized cosmic ray detector.Author:Curtis McCullyAstro-SCRAPPY is designed to detect cosmic rays in images (numpy arrays),
based on Pieter van Dokkum’s L.A.Cosmic algorithm.Much of this was originally adapted from cosmics.py written by Malte Tewes.
I have ported all of the slow functions to Cython/C, and optimized
where I can. This is designed to be as fast as possible so some of the
readability has been sacrificed, specifically in the C code.If you use this code, please cite the Zendo DOI:https://zenodo.org/record/1482019Please cite the original paper which can be found at:http://www.astro.yale.edu/dokkum/lacosmic/van Dokkum 2001, PASP, 113, 789, 1420
(article :http://adsabs.harvard.edu/abs/2001PASP..113.1420V)This code requires Cython, preferably version >= 0.21.Parallelization is achieved using OpenMP. This code should compile (although
the Cython files may have issues) using a compiler that does not support OMP,
e.g. clang.NotesThere are some differences from original LA Cosmic:Automatic recognition of saturated stars.
This avoids treating such stars as large cosmic rays.I have tried to optimize all of the code as much as possible while
maintaining the integrity of the algorithm. One of the key speedups is to
use a separable median filter instead of the true median filter. While these
are not identical, they produce comparable results and the separable version
is much faster.This implementation is much faster than the Python by as much as a factor of
~17 depending on the given parameters, even without running multiple threads.
With multiple threads, this can be increased easily by another factor of 2.
This implementation is much faster than the original IRAF version, improvment
by a factor of ~90.The arrays always must be C-contiguous, thus all loops are y outer, x inner.
This follows the astropy.io.fits (pyfits) convention.scipy is required for certain tests to pass, but the code itself does not depend on
scipy.LicenseThis project is Copyright (c) Astropy Developers and licensed under the terms of the BSD 3-Clause license. See the licenses folder for more information.
Package: astro-sedpy
Modules for storing and operating on astronomical source spectral energy distributions.Installation & setup:sedpyis pip installable:python-mpipinstallastro-sedpyOr you can install the latest version from github:gitclonehttps://github.com/bd-j/sedpycdsedpypipinstall.Then in python, e.g.,fromsedpyimportobservate# get magnitude from a spectrum:filt=observate.Filter("sdss_r0")mag=filt.ab_mag(angstroms,f_lambda_cgs)# or get several magnitudes at oncefilterlist=observate.load_filters(["galex_NUV","sdss_r0"])mags=observate.getSED(angstroms,f_lambda_cgs,filterlist=filters)For the filters available by default see thefilter_list.
For adding transmission curves, see thesedocs.This code can be referenced as:Description:observatehas methods for generating synthetic photometry through any filters,
and classes for dealing with filters generally. There is some functionality for spectra
(vaccum to air conversions).
With a huge debt to Mike Blanton’skcorrectcode .attenuationcontains simple dust attenuation methods.smoothingmethods for smoothing well-sampled spectra.extinction(Deprecated) classes for a detailed modeling of extinction curves,
following the Fitzpatrick & Massa parameterizations.
Seedust_extinctioninstead.
Package: astro-seeing
SEEINGSympy Expressions Evaluation Implemented oN the GPUThe idea is to provide the following to Sympy users:A simple way to evaluate an expressions on the GPUBackend agnostic evaluation (currently numpy and cupy are supported, in the future clpy or other numerical backends might be added)Support tools to handle groups of expressions (evaluate, plot, substitute parameters, share variables)Numerical methods (for now integration over n-dimensional domains)Numpy/Scipy evaluation comes out of the box with Sympy, using the lambdify
feature.  In order to do the same on the GPU, first development effort of
SEEING relies Cupy only, thus you need to have a CUDA enabled GPU to use it.InstallationSEEING can be installed with pip:pip install astro-seeingFor GPU usage SEEING relies on Cupy, which can be installed as a dependency
with:pip install "astro-seeing[gpu]"
Package: astroslam
SLAMStellar LAbel Machine (SLAM) is a forward model to estimate stellar labels (e.g., Teff, logg and chemical abundances).
It is based on Support Vector Regression (SVR) which is a non-parametric regression method.For details ofSLAM, seeDeriving the stellar labels of LAMOST spectra with Stellar LAbel Machine (SLAM).
Related projects: clickhere.AuthorBo Zhang (bozhang@nao.cas.cn)Home pagehttps://github.com/hypergravity/astroslamhttps://pypi.org/project/astroslam/Installfor the lateststableversion:pip install -U astroslamfor the latestgithubversion:pip install -U git+git://github.com/hypergravity/astroslamfor Zenodo versionhttps://zenodo.org/record/3461504Tutorial[updated on 2020-12-02]A new SLAM tutorial can be foundhereIf you are interested in SLAM or have any related questions, do not hesitate to contact me.Requirementsnumpyscipymatplotlibastropyscikit-learnjoblibpandasemceeHow to citePaper:@ARTICLE{2020ApJS..246....9Z,
       author = {{Zhang}, Bo and {Liu}, Chao and {Deng}, Li-Cai},
        title = "{Deriving the Stellar Labels of LAMOST Spectra with the Stellar LAbel Machine (SLAM)}",
      journal = {\apjs},
     keywords = {Astronomical methods, Astronomy data analysis, Bayesian statistics, Stellar abundances, Chemical abundances, Fundamental parameters of stars, Catalogs, Surveys, Astrophysics - Solar and Stellar Astrophysics, Astrophysics - Astrophysics of Galaxies, Astrophysics - Instrumentation and Methods for Astrophysics},
         year = 2020,
        month = jan,
       volume = {246},
       number = {1},
          eid = {9},
        pages = {9},
          doi = {10.3847/1538-4365/ab55ef},
archivePrefix = {arXiv},
       eprint = {1908.08677},
 primaryClass = {astro-ph.SR},
       adsurl = {https://ui.adsabs.harvard.edu/abs/2020ApJS..246....9Z},
      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}Code:@misc{https://doi.org/10.5281/zenodo.3461504,
    author = {Zhang, Bo},
    title = {hypergravity/astroslam: Stellar LAbel Machine},
    doi = {10.5281/zenodo.3461504},
    url = {https://zenodo.org/record/3461504},
    publisher = {Zenodo},
    year = {2019}
}For other formats, please go tohttps://search.datacite.org/works/10.5281/zenodo.3461504.
Package: astro-smpy
Stellar populations and Masses with PythonThis package contains Python software designed for building and processing composite stellar populations in a simple but flexible manner. It allows for easy synthetic photometry to be produced for single models or large suites of models.The code makes use of theAstropymodule throughout and therefore allows for easy conversion of physical units and a wide range of allowed cosmologies.Currently supported simple stellar population models are:Bruzual & Charlot 2003BPASS V1 & V2LicenseSMpyis licensed under the terms of the MIT license. See the file
“LICENSE” for information on the history of this software, terms & conditions
for usage, and a DISCLAIMER OF ALL WARRANTIES.All trademarks referenced herein are property of their respective holders.Copyright (c) 2015–, Kenneth Duncan
Package: astrosn
supernovaObject-oriented python library for analyzing supernova data, focusing on generic data flow, conversion, and convenient plotting.
The scripts are meant to be imported and used inside external plotting and analysis codes/notebooks. (See SN2020lao directory for an example)Will also be a way to quickly import the SN data from my papers. However, please do not take it without
referring to/citing the paper, (or publish it before mine is accepted without contacting me), thanks!