Add files using upload-large-folder tool

testbed/astropy__astropy/.gitattributes

@@ -0,0 +1,3 @@
+*.fits    -text
+astropy.0.3.windows.cfg eol=crlf
+CHANGES.rst merge=union

testbed/astropy__astropy/.gitignore

@@ -0,0 +1,70 @@
+# Compiled files
+*.py[cod]
+*.a
+*.o
+*.so
+*.pyd
+*.dll
+__pycache__
+
+# Ignore .c files by default to avoid including generated code. If you want to
+# add a non-generated .c extension, use `git add -f filename.c`.
+*.c
+
+# Other generated files
+MANIFEST
+astropy/version.py
+astropy/cython_version.py
+astropy/wcs/include/wcsconfig.h
+astropy/_erfa/core.py
+
+# Sphinx
+_build
+_generated
+docs/api
+docs/generated
+docs/visualization/ngc6976.jpeg
+docs/visualization/ngc6976-default.jpeg
+
+# Packages/installer info
+*.egg
+*.egg-info
+dist
+build
+eggs
+.eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+distribute-*.tar.gz
+.venv
+venv
+
+# Other
+.cache
+.tox
+.*.swp
+.*.swo
+*~
+.project
+.pydevproject
+.settings
+.coverage
+cover
+htmlcov
+
+# Mac OSX
+.DS_Store
+
+# PyCharm
+.idea
+
+# Pytest
+v
+.pytest_cache
+
+# VSCode
+.vscode

testbed/astropy__astropy/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "astropy_helpers"]
+	path = astropy_helpers
+	url = https://github.com/astropy/astropy-helpers.git

testbed/astropy__astropy/.mailmap

@@ -0,0 +1,178 @@
+Adam Ginsburg       <keflavich@gmail.com>
+Adam Ginsburg       <keflavich@gmail.com> Adam Ginsburg <adam.g.ginsburg@gmail.com>
+Adam Ginsburg       <keflavich@gmail.com> Adam Ginsburg <keflavich@yahoo.com>
+Adele Plunkett      <aplunket@eso.org>
+Alex Conley         <alexander.conley@colorado.edu> Alexander Conley <alexander.conley@colorado.edu>
+Alex Conley         <alexander.conley@colorado.edu> Alexander Conley <alexanderconley@gmail.com>
+Alex Hagen          <mr.alex.hagen@gmail.com>
+Asish Panda         <asishrocks95@gmail.com>
+Axel Donath         <axel.donath@mpi-hd.mpg.de>
+Bryce Nordgren      <bnordgren@gmail.com>
+Bogdan Nicula       <bogdan@nicula.net>
+Christopher Bonnett <c.bonnett@gmail.com>
+Christoph Gohlke    <cgohlke@uci.edu>
+Curtis McCully      <cmccully@lcogt.net>
+Daniel Bell         <stampsrule@gmail.com> Daniel <idaniel@me.com>
+Daniel Bell         <stampsrule@gmail.com> stampsrule <stampsrule@gmail.com>
+Daniel Datsev       <dan.datsev@gmail.com>
+Daniel Datsev       <dan.datsev@gmail.com> <fabled@vortex.(none)>
+David Pérez-Suárez  <dps.helio@gmail.com>
+Demitri Muna        <demitri.muna@gmail.com> <demitri@me.com>
+Demitri Muna        <demitri.muna@gmail.com> <beswiftly@gmail.com>
+Dylan Gregersen     <gregersen.dylan@gmail.com>
+Emma Hogan          <ehogan@gemini.edu>
+Moataz Hisham       <mtzhisham@gmail.com>
+Erik M. Bray        <erik.m.bray@gmail.com> <embray@stsci.edu>
+Erik M. Bray        <erik.m.bray@gmail.com> <erik.bray@lri.fr>
+Erik M. Bray        <erik.m.bray@gmail.com> Erik Bray <erik.m.bray@gmail.com>
+Gerrit Schellenberger <gerrit@uni-bonn.de>
+Gustavo Bragança    <ga.braganca@gmail.com>
+Hans Moritz Günther <moritz.guenther@gmx.de>
+Hans Moritz Günther <moritz.guenther@gmx.de> hamogu <hgunther@mit.edu>
+James Turner        <jturner@gemini.edu>
+Jeff Taylor         <jeff.c.taylor@gmail.com>
+Kacper Kowalik      <xarthisius.kk@gmail.com> Kacper Kowalik      <xarthisius@gentoo.org>
+Kacper Kowalik      <xarthisius.kk@gmail.com> Kacper Kowalik (Xarthisius) <xarthisius@gentoo.org>
+Kacper Kowalik      <xarthisius.kk@gmail.com> Kacper Kowalik (Xarthisius) <xarthisius.kk@gmail.com>
+Karan Grover        <karan@karan-HP-Pavilion-dm4-Notebook-PC.(none)>
+Karl Vyhmeister     <kvyh@users.noreply.github.com>
+Kirill Tchernyshyov <ktchernyshyov@pha.jhu.edu>
+Kelle Cruz          <kellecruz@gmail.com>
+Kevin Gullikson     <kevin.gullikson@gmail.com>
+Leonardo Ferreira <leonardo.ferreira.furg@gmail.com> [Leonardo Ferreira] <[leonardo.ferreira.furg@gmail.com]>
+Lisa Walter         <lisa@stsci.edu>
+Marten van Kerkwijk <mhvk@astro.utoronto.ca> <mhvk@swan.astro.utoronto.ca>
+Matt Davis          <jiffyclub.programatic@gmail.com>
+Nadia Dencheva      <nadia.astropy@gmail.com> <nadia.dencheva@gmail.com>
+Nadia Dencheva      <nadia.astropy@gmail.com> <dencheva@itsd-osx13.local>
+Neil Crighton       <neilcrighton@gmail.com>
+Perry Greenfield    <perry@stsci.edu>
+Pritish Chakraborty <chakrabortypritish@gmail.com>
+Ryan Cooke          <ryancooke86@gmail.com>
+Shantanu Srivastava <shan_mbic@rediffmail.com>
+Simon Conseil       <contact@saimon.org> Simon Conseil <simon.conseil@univ-lyon1.fr>
+Simon Conseil       <contact@saimon.org> Simon <contact@saimon.org>
+Simon Liedtke       <liedtke.simon@googlemail.com>
+Thomas Erben        <terben@astro.uni-bonn.de> <thomas@astro.uni-bonn.de>
+Thompson Le Blanc   <leblanc@stsci.edu>
+Thompson Le Blanc   <leblanc@stsci.edu> astrocaribe <tlcommodore@gmail.com>
+Tom Aldcroft        <taldcroft@gmail.com> <aldcroft@dhcp-131-142-152-173.cfa.harvard.edu>
+Zach Edwards        <Zachary.Astro@Gmail.com>
+Jonathan Foster     <jonathan.bruce.foster@gmail.com>
+David Kirkby         <dkirkby@uci.edu>
+Albert Y. Shih      <ayshih@gmail.com>
+Aleh Khvalko        <algerdnazgul@gmail.com>
+Elijah Bernstein-Cooper <e.bernsteincooper@gmail.com> <ezbc@astro.wisc.edu>
+Lingyi Hu           <hulingyi1995@yahoo.com.sg>
+Francesco Montesano <franz.bergesund@gmail.com>
+Daniel Lenz         <dlenz.bonn@gmail.com>
+Dan P. Cunningham   <dan.p.cunningham@gmail.com>
+Joseph Long         <josephoenix@gmail.com> <me@joseph-long.com>
+Brigitta Sipocz     <bsipocz@gmail.com> <b.sipocz@gmail.com>
+Rohit Patil         <rohit4change@yahoo.in> QuanTakeuchi <rohit4change@yahoo.in>
+Rohit Patil         <rohit4change@yahoo.in> QuanTakeuchi <Quan@Aries.(none)>
+Demitri Muna        <demitri.muna@gmail.com> Demitri Muna <github@demitri.com>
+Steve Crawford      <crawfordsm@gmail.com> Steven Crawford <crawfordsm@gmail.com>
+Steve Crawford      <crawfordsm@gmail.com> <crawfodsm@gmail.com>
+Anne Archibald      <peridot.faceted@gmail.com> Anne Archibald <archibald@astron.nl>
+Stuart Mumford      <stuart@mumford.me.uk> Stuart Mumford <stuart@cadair.com>
+Mihai Cara          <mihail.cara@gmail.com> Mihai Cara <mcara@itsd-osx22.home>
+Pey Lian Lim        <lim@stsci.edu> P. L. Lim <lim@stsci.edu>
+Pey Lian Lim        <lim@stsci.edu> P. L. Lim <2090236+pllim@users.noreply.github.com>
+Pey Lian Lim        <lim@stsci.edu> Pey Lian Lim <2090236+pllim@users.noreply.github.com>
+Jonathan Foster     <jonathan.bruce.foster@gmail.com> Jonathan Foster <jonathan.b.foster@yale.edu>
+Miguel de Val-Borro <miguel.deval@gmail.com> Miguel de Val-Borro <miguel@archlinux.net>
+Eric Depagne        <eric@depagne.org>
+Pratik Patel        <pratikpatel15133@gmail.com>
+Mavani Bhautik      <mavanibhautik@gmail.com>
+Aniket Kulkarni    <kaniket21@gmail.com>
+Sara Ogaz           <ogaz@stsci.edu>
+Sourabh Cheedella   <cheedella.sourabh@gmail.com>
+Sudheesh Singanamalla <sudheesh1995@outlook.com>
+Amit Kumar          <dtu.amit@gmail.com>
+Jake VanderPlas     <jakevdp@gmail.com> Jake VanderPlas <jakevdp@uw.edu>
+Matthew Craig       <mattwcraig@gmail.com> Matt Craig <mattwcraig@gmail.com>
+Sergio Pascual      <sergio.pasra@gmail.com> Sergio Pascual <sergiopr@fis.ucm.es>
+Laura Watkins       <lauralwatkins@gmail.com> Laura L Watkins <lauralwatkins@gmail.com>
+Axel Donath         <axel.donath@mpi-hd.mpg.de> Axel Donath <donath@stud.uni-heidelberg.de>
+Zé Vinicius         <jvmirca@gmail.com> Ze Vinicius <jvmirca@gmail.com>
+Ole Streicher       <ole@aip.de> Ole Streicher <debian@liska.ath.cx>
+Alex Rudy           <alex.rudy@gmail.com> Alexander Rudy <alex.rudy@gmail.com>
+Leo Singer          <leo.singer@ligo.org> Leo Singer <leo.singer@nasa.gov>
+Anthony Horton      <anthony.horton@aao.gov.au>
+Maneesh Yadav       <maneesh.yadav@sri.com>
+Esteban Pardo Sánchez <stbnps@users.noreply.github.com>
+John Parejko        <parejkoj@uw.edu> John K. Parejko <parejkoj@uw.edu> <parejkoj@gmail.com>
+John Parejko        <parejkoj@uw.edu> <parejkoj@gmail.com>
+Pauline Barmby      <pbarmby@uwo.ca> Pauline <pbarmby@uwo.ca>
+Joseph Long         <josephoenix@gmail.com> <jlong@stsci.edu>
+Graham Kanarek      <graykanarek@gmail.com>
+Jurien Huisman      <huisman@strw.leidenuniv.nl>
+Aarya Patil    <aaryapatil1996@gmail.com>
+Aarya Patil    <aaryapatil1996@gmail.com> <root@aaryas-MacBook-Pro.local>
+Ritwick DSouza      <ritwick.dsouza@outlook.com>
+Jake VanderPlas <jakevdp@gmail.com>
+Douglas Burke <dburke.gw@gmail.com>
+Benjamin Alan Weaver  <weaver@noao.edu> <benjamin.weaver@nyu.edu>
+Benjamin Alan Weaver  <weaver@noao.edu> <baweaver@lbl.gov>
+Asra Nizami <anizami@macalester.edu> <anizami@itsd-summer18.stsci.edu>
+Asra Nizami <anizami@macalester.edu> <anizami@itsd-summer18.local>
+Michele Costa  <thenocturnalastrostudent@gmail.com>
+Luke G. Bouma <lgbouma@users.noreply.github.com>
+VSN Reddy Janga <janga1997@gmail.com>
+Giorgio Calderone <giorgio.calderone@gmail.com> <gcalderone@users.noreply.github.com>
+Tyler Finethy <tylfin@gmail.com>
+Sam Verstocken <sam.verstocken@gmail.com>
+Mikhail Minin <mminin2010@gmail.com>
+Matteo Bachetti <matteo@matteobachetti.it> <matteo.bachetti@irap.omp.eu>
+Anirudh Katipally <akatipally@abiomed.com>
+David Shupe <shupe@ipac.caltech.edu> <dave.shupe@gmail.com>
+Adrian Price-Whelan <adrian.prw@gmail.com> <adrianmpw@gmail.com>
+Derek Homeier <dhomeie@gwdg.de> <derek.homeier@ens-lyon.fr>
+Brett Morris <brettmorris21@gmail.com> <bmmorris@uw.edu>
+Daniel D'Avella <ddavella@stsci.edu> <drdavella@gmail.com>
+Daniel D'Avella <ddavella@stsci.edu> Dan D'Avella <ddavella@stsci.edu>
+Stuart Littlefair <s.littlefair@shef.ac.uk> StuartLittlefair <s.littlefair@shef.ac.uk>
+Juan Luis Cano Rodríguez <juanlu001@gmail.com> Juan Luis Cano Rodríguez <juanlu@satellogic.com>
+Juan Luis Cano Rodríguez <juanlu001@gmail.com> Juan Luis Cano Rodríguez <Juanlu001@users.noreply.github.com>
+Joe Hunkeler <jhunk@stsci.edu> Joseph Hunkeler <jhunkeler@gmail.com>
+Dan Foreman-Mackey <foreman.mackey@gmail.com> Dan F-M <danfm@nyu.edu>
+Dan Foreman-Mackey <foreman.mackey@gmail.com> Dan F-M <foreman.mackey@gmail.com>
+Johnny Greco <jgreco@astro.princeton.edu> Johnny <jgreco@astro.princeton.edu>
+Zé Vinicius <jvmirca@gmail.com> mirca <jvmirca@gmail.com>
+Michael Seifert <michaelseifert04@yahoo.de> --system <michaelseifert04@yahoo.de>
+Michael Seifert <michaelseifert04@yahoo.de> MSeifert04 <michaelseifert04@yahoo.de>
+Vishnunarayan K I <appukuttancr@gmail.com> vn-ki <appukuttancr@gmail.com>
+Ritiek Malhotra <ritiekmalhotra123@gmail.com> ritiek <ritiekmalhotra123@gmail.com>
+Rohan Rajpal <rohan17089@iiitd.ac.in> rohanrajpal <rohan17089@iiitd.ac.in>
+Mangala Gowri Krishnamoorthy <mangalagb@gmail.com> mangalagb <mangalagb@gmail.com>
+Hannes Breytenbach <hannes@saao.ac.za> astromancer <hannes@saao.ac.za>
+Hannes Breytenbach <hannes@saao.ac.za> apodemus <hannes@saao.ac.za>
+Christian Clauss <cclauss@bluewin.ch> cclauss <cclauss@bluewin.ch>
+Eric Koch  <koch.eric.w@gmail.com> e-koch <koch.eric.w@gmail.com>
+Alexander Bakanov <bakanov.aleksandr@gmail.com> Aleksandr Bakanov <aleksandr_bakanov@epam.com>
+Emily Deibert <emilydeibert@gmail.com> emilydeibert <emilydeibert@gmail.com>
+Sanjeev Dubey <getsanjeevdubey@gmail.com> getsanjeev <getsanjeevdubey@gmail.com>
+Humna Awan <humna.awan@rutgers.edu> Humna <humna.awan@rutgers.edu>
+Daria Cara  <daria.cara.2@gmail.com> unknown <daria.cara.2@gmail.com>
+Jani Šumak  <jani.sumak@gmail.com> dasdachs <jani.sumak@gmail.com>
+Alexandre Beelen <alexandre.beelen@ias.u-psud.fr> alexandre beelen <alexandre.beelen@ias.u-psud.fr>
+Steve Crawford <crawfordsm@gmail.com> Steven Crawford <scrawford@stsci.edu>
+Steve Crawford <crawfordsm@gmail.com> crawfordsm <crawfordsm@gmail.com>
+Mike Alexandersen <mikea@asiaa.sinica.edu.tw> Mike Alexandersen (on Vancouver) <mikea@asiaa.sinica.edu.tw>
+Patricio Rojo <pato@das.uchile.cl> duckrojo <pato@oan.cl>
+Ana Posses <anaposses@gmail.com> anaposses <anaposses@gmail.com>
+Kyle Oman <koman@astro.rug.nl> K.A. Oman <koman@astro.rug.nl>
+Vital Fernández <vital.fernandez@gmail.com> Delosari <lativmail@gmail.com>
+Anany Shrey Jain <ananyashreyjain1998@gmail.com> ananyashreyjain <31594632+ananyashreyjain@users.noreply.github.com>
+Joseph Schlitz <jrschlitz0725@gmail.com> SG004 <jrschlitz0725@gmail.com>
+Benjamin Roulston <benjamin.roulston@protonmail.com> broulston <benjamin.roulston@protonmail.com>
+Himanshu Pathak <hpathak336@gmail.com> himanshupathak21061998 <hpathak336@gmail.com>
+Dan Taranu <dtaranu@astro.princeton.edu> taranu <dtaranu@astro.princeton.edu>
+Yash Kumar <yash.kmr.99@gmail.com> yashkmr99 <yash.kmr.99@gmail.com>
+Benjamin Winkel <bwinkel@mpifr.de> bwinkel <bwinkel78@gmail.com>
+Javier Pascual Granado <javier@iaa.es> JaviPG <javier@iaa.es>
+Javier Pascual Granado <javier@iaa.es> javier-iaa <javier@iaa.es>
+Rohit Kapoor <algorithm059@gmail.com> algo-circle <algorithm059@gmail.com>
+Jane Rigby <jane.rigby@gmail.com> janerigby <jane.rigby@gmail.com>
+Lisa Martin <48742903+lisamartin72@users.noreply.github.com>  lisamartin72 <48742903+lisamartin72@users.noreply.github.com>

testbed/astropy__astropy/.readthedocs.yml

@@ -0,0 +1,22 @@
+version: 2
+
+build:
+  image: latest
+
+# Install regular dependencies.
+# Then, install special pinning for RTD.
+python:
+  version: 3.6
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs
+        - all
+    - requirements: docs/rtd_requirements.txt
+
+submodules:
+  include: all
+
+# Don't build any extra formats
+formats: []

testbed/astropy__astropy/.travis.yml

@@ -0,0 +1,216 @@
+# We set the language to c because python isn't supported on the MacOS X nodes
+# on Travis. However, the language ends up being irrelevant anyway, since we
+# install Python ourselves using conda.
+language: c
+
+compiler: gcc
+
+# Cache can be cleared from the travis settings menu, see docs currently at
+# https://docs.travis-ci.com/user/caching#Clearing-Caches
+cache:
+  - ccache
+
+os:
+    - linux
+
+stage: Comprehensive tests
+
+# Setting sudo to false opts in to Travis-CI container-based builds.
+sudo: false
+
+# The apt packages below are needed for sphinx builds, which can no longer
+# be installed with sudo apt-get.
+addons:
+    apt:
+        packages:
+            - graphviz
+            - language-pack-de
+
+env:
+    global:
+        # Set defaults to avoid repeating in most cases
+        - PYTHON_VERSION=3.6
+        - NUMPY_VERSION=stable
+        - PYTEST_VERSION=3.10
+        - MAIN_CMD='python setup.py'
+        - CONDA_DEPENDENCIES='Cython jinja2'
+        - CONDA_ALL_DEPENDENCIES='Cython jinja2 scipy h5py matplotlib pyyaml pandas pytz html5lib beautifulsoup4 ipython mpmath bleach bottleneck'
+        - DEV_PIP_DEP='asdf>=2.3 Cython jinja2 scipy h5py matplotlib pyyaml scikit-image pandas pytz html5lib beautifulsoup4 ipython mpmath bleach bottleneck'
+        - ASDF_PIP_DEP='asdf>=2.3'
+        - SETUP_XVFB=True
+        - EVENT_TYPE='push pull_request'
+        - SETUP_CMD='test'
+        - INSTALL_WITH_PIP=False
+        - EXTRAS_INSTALL=""
+
+        # PEP8 errors/warnings:
+        # E101 - mix of tabs and spaces
+        # W191 - use of tabs
+        # W291 - trailing whitespace
+        # W292 - no newline at end of file
+        # W293 - trailing whitespace
+        # W391 - blank line at end of file
+        # E111 - 4 spaces per indentation level
+        # E112 - 4 spaces per indentation level
+        # E113 - 4 spaces per indentation level
+        # E502 - the backslash is redundant between brackets
+        # E722 - do not use bare except
+        # E901 - SyntaxError or IndentationError
+        # E902 - IOError
+        # E999: SyntaxError -- failed to compile a file into an Abstract Syntax Tree
+        # # F821: undefined name  # Note: Removed for now because of heavy use of units.si
+        # F822: undefined name in __all__
+        # F823: local variable name referenced before assignment
+        - FLAKE8_OPT="--select=E101,W191,W291,W292,W293,W391,E111,E112,E113,E502,E722,E901,E902,E999,F822,F823"
+
+stages:
+   # Do the style check and a single test job, don't proceed if it fails
+   - name: Initial tests
+   # Do the rest of the tests
+   - name: Comprehensive tests
+   - name: Cron tests
+     if: type = cron
+
+matrix:
+
+    # Don't wait for allowed failures
+    fast_finish: true
+
+    include:
+        # Try MacOS X. Use a slightly old numpy version to help test against
+        # all supported numpy versions.
+        - os: osx
+          stage: Cron tests
+          env: SETUP_CMD='test --remote-data=astropy'
+               CONDA_DEPENDENCIES="$CONDA_ALL_DEPENDENCIES clang"
+               PIP_DEPENDENCIES="scikit-image jplephem $ASDF_PIP_DEP"
+               CCOMPILER=clang
+               EVENT_TYPE='cron'
+
+        # Try all python versions and Numpy versions. Since we can assume that
+        # the Numpy developers have taken care of testing Numpy with different
+        # versions of Python, we can vary Python and Numpy versions at the same
+        # time.
+        # Run this test using native pytest
+        - os: linux
+          env: PYTHON_VERSION=3.5 NUMPY_VERSION=1.13
+               INSTALL_CMD='python setup.py build_ext --inplace'
+               PIP_DEPENDENCIES='pytest-astropy'
+               TEST_CMD='pytest --open-files --doctest-rst'
+               PYTEST_VERSION=3.7
+          script:
+            - $INSTALL_CMD
+            - $TEST_CMD
+
+        # Now try with all optional dependencies. We also include the --readonly
+        # flag to make sure no files are being written to the temporary install
+        # location during testing. We also use this build to make sure that the
+        # dependencies get correctly installed with pip.
+        - os: linux
+          env: SETUP_CMD='test --remote-data=astropy --readonly'
+               LC_CTYPE=C.ascii LC_ALL=C
+               PYTEST_VERSION=4.4
+               PIP_DEPENDENCIES="" CONDA_DEPENDENCIES=""
+               INSTALL_WITH_PIP=True
+               EXTRAS_INSTALL="test,all"
+
+        - os: linux
+          stage: Initial tests
+          env: PYTHON_VERSION=3.7 CONDA_DEPENDENCIES=$CONDA_ALL_DEPENDENCIES
+               PIP_DEPENDENCIES="scikit-image $ASDF_PIP_DEP"
+               SETUP_CMD='test -a "--durations=50"'
+          compiler: clang
+
+        # Full tests with coverage checks.
+        - os: linux
+          env: SETUP_CMD='test --coverage --remote-data=astropy --readonly'
+               CONDA_DEPENDENCIES=$CONDA_ALL_DEPENDENCIES
+               PIP_DEPENDENCIES="scikit-image codecov objgraph jplephem bintrees sortedcontainers $ASDF_PIP_DEP"
+               LC_CTYPE=C.ascii LC_ALL=C
+               CFLAGS='--coverage -fno-inline-functions -O0'
+               MATPLOTLIB_VERSION=2.1
+               EVENT_TYPE='push pull_request cron'
+
+        # Try pre-release version of Numpy without optional dependencies
+        - os: linux
+          env: NUMPY_VERSION=prerelease
+               EVENT_TYPE='push pull_request cron'
+
+        # Do a PEP8/pyflakes test with flake8
+        - os: linux
+          stage: Initial tests
+          env: MAIN_CMD="flake8 astropy --count $FLAKE8_OPT" SETUP_CMD=''
+
+        # Try developer version of Numpy with optional dependencies and also
+        # run all remote tests. Since both cases will be potentially
+        # unstable, we combine them into a single unstable build that we can
+        # mark as an allowed failure below.
+        - os: linux
+          env: PYTHON_VERSION=3.7 NUMPY_VERSION=dev SETUP_CMD='test --remote-data'
+               CONDA_DEPENDENCIES=''
+               PIP_DEPENDENCIES=$DEV_PIP_DEP
+               MATPLOTLIB_VERSION=dev
+
+        # We check numpy-dev also in a job that only runs from cron, so that
+        # we can spot issues sooner. We do not use remote data here, since
+        # that gives too many false positives due to URL timeouts.
+        # We also install all dependencies via pip here so we pick up the latest
+        # releases.
+        - os: linux
+          stage: Cron tests
+          env: NUMPY_VERSION=dev MATPLOTLIB_VERSION=dev EVENT_TYPE='cron'
+               CONDA_DEPENDENCIES=''
+               PIP_DEPENDENCIES=$DEV_PIP_DEP
+
+        # Run documentation link check in a cron job.
+        # Was originally in CircleCI doc build but links are too flaky, so
+        # we moved it here instead.
+        - os: linux
+          stage: Cron tests
+          env: SETUP_CMD='build_docs -b linkcheck'
+               PIP_DEPENDENCIES="" CONDA_DEPENDENCIES=""
+               INSTALL_WITH_PIP=True
+               EXTRAS_INSTALL="docs,all"
+
+    allow_failures:
+      - os: linux
+        env: PYTHON_VERSION=3.7 NUMPY_VERSION=dev SETUP_CMD='test --remote-data'
+             CONDA_DEPENDENCIES=''
+             PIP_DEPENDENCIES=$DEV_PIP_DEP
+             MATPLOTLIB_VERSION=dev
+
+before_install:
+
+    # We need to use CCOMPILER otherwise Travis overwrites CC if we define it
+    # in env: above.
+    - if [ ! -z $CCOMPILER ]; then
+        export CC=$CCOMPILER;
+      fi
+
+     # Check CC variable
+    - echo $CC
+
+    # Write configuration items to standard location to make sure they are
+    # ignored (the tests will fail if not)
+    - mkdir -p $HOME/.astropy/config/
+    - printf "unicode_output = True\nmax_width = 500" > $HOME/.astropy/config/astropy.cfg
+
+
+install:
+    - git clone git://github.com/astropy/ci-helpers.git
+    - source ci-helpers/travis/setup_conda.sh
+    - if [[ $INSTALL_WITH_PIP == True ]]; then
+        if [ -z $EXTRAS_INSTALL ]; then
+          pip install -e .;
+        else
+          pip install -e .[$EXTRAS_INSTALL];
+        fi
+      fi
+
+script:
+    - $MAIN_CMD $SETUP_CMD
+
+after_success:
+    - if [[ $SETUP_CMD == *--coverage* ]]; then
+        codecov --gcov-glob "*cextern*";
+      fi

testbed/astropy__astropy/CITATION

@@ -0,0 +1,112 @@
+If you use Astropy for work/research presented in a publication (whether
+directly, or as a dependency to another package), we recommend and encourage
+the following acknowledgment:
+
+  This research made use of Astropy, a community-developed core Python package
+  for Astronomy (Astropy Collaboration, 2018).
+
+where (Astropy Collaboration, 2018) is a citation to this paper:
+
+  http://adsabs.harvard.edu/abs/2018AJ....156..123T
+
+An earlier paper is also available describing the status of the package at
+the time of v0.2. If you have used Astropy for a long time, you are
+encouraged to acknowledge both papers:
+
+  This research made use of Astropy, a community-developed core Python package
+  for Astronomy (Astropy Collaboration, 2013, 2018).
+
+where (Astropy Collaboration, 2013) is a citation to this paper:
+
+  http://adsabs.harvard.edu/abs/2013A%26A...558A..33A
+
+We encourage you to also include citations to the papers in the main text
+wherever appropriate.
+
+
+Recommended BibTeX entries for the above citations are:
+
+@ARTICLE{2018AJ....156..123T,
+   author = {{The Astropy Collaboration} and {Price-Whelan}, A.~M. and {Sip{\H o}cz}, B.~M. and 
+	{G{\"u}nther}, H.~M. and {Lim}, P.~L. and {Crawford}, S.~M. and 
+	{Conseil}, S. and {Shupe}, D.~L. and {Craig}, M.~W. and {Dencheva}, N. and 
+	{Ginsburg}, A. and {VanderPlas}, J.~T. and {Bradley}, L.~D. and 
+	{P{\'e}rez-Su{\'a}rez}, D. and {de Val-Borro}, M. and {Paper Contributors}, (. and 
+	{Aldcroft}, T.~L. and {Cruz}, K.~L. and {Robitaille}, T.~P. and 
+	{Tollerud}, E.~J. and {Coordination Committee}, (. and {Ardelean}, C. and 
+	{Babej}, T. and {Bach}, Y.~P. and {Bachetti}, M. and {Bakanov}, A.~V. and 
+	{Bamford}, S.~P. and {Barentsen}, G. and {Barmby}, P. and {Baumbach}, A. and 
+	{Berry}, K.~L. and {Biscani}, F. and {Boquien}, M. and {Bostroem}, K.~A. and 
+	{Bouma}, L.~G. and {Brammer}, G.~B. and {Bray}, E.~M. and {Breytenbach}, H. and 
+	{Buddelmeijer}, H. and {Burke}, D.~J. and {Calderone}, G. and 
+	{Cano Rodr{\'{\i}}guez}, J.~L. and {Cara}, M. and {Cardoso}, J.~V.~M. and 
+	{Cheedella}, S. and {Copin}, Y. and {Corrales}, L. and {Crichton}, D. and 
+	{D{\rsquo}Avella}, D. and {Deil}, C. and {Depagne}, {\'E}. and 
+	{Dietrich}, J.~P. and {Donath}, A. and {Droettboom}, M. and 
+	{Earl}, N. and {Erben}, T. and {Fabbro}, S. and {Ferreira}, L.~A. and 
+	{Finethy}, T. and {Fox}, R.~T. and {Garrison}, L.~H. and {Gibbons}, S.~L.~J. and 
+	{Goldstein}, D.~A. and {Gommers}, R. and {Greco}, J.~P. and 
+	{Greenfield}, P. and {Groener}, A.~M. and {Grollier}, F. and 
+	{Hagen}, A. and {Hirst}, P. and {Homeier}, D. and {Horton}, A.~J. and 
+	{Hosseinzadeh}, G. and {Hu}, L. and {Hunkeler}, J.~S. and {Ivezi{\'c}}, {\v Z}. and 
+	{Jain}, A. and {Jenness}, T. and {Kanarek}, G. and {Kendrew}, S. and 
+	{Kern}, N.~S. and {Kerzendorf}, W.~E. and {Khvalko}, A. and 
+	{King}, J. and {Kirkby}, D. and {Kulkarni}, A.~M. and {Kumar}, A. and 
+	{Lee}, A. and {Lenz}, D. and {Littlefair}, S.~P. and {Ma}, Z. and 
+	{Macleod}, D.~M. and {Mastropietro}, M. and {McCully}, C. and 
+	{Montagnac}, S. and {Morris}, B.~M. and {Mueller}, M. and {Mumford}, S.~J. and 
+	{Muna}, D. and {Murphy}, N.~A. and {Nelson}, S. and {Nguyen}, G.~H. and 
+	{Ninan}, J.~P. and {N{\"o}the}, M. and {Ogaz}, S. and {Oh}, S. and 
+	{Parejko}, J.~K. and {Parley}, N. and {Pascual}, S. and {Patil}, R. and 
+	{Patil}, A.~A. and {Plunkett}, A.~L. and {Prochaska}, J.~X. and 
+	{Rastogi}, T. and {Reddy Janga}, V. and {Sabater}, J. and {Sakurikar}, P. and 
+	{Seifert}, M. and {Sherbert}, L.~E. and {Sherwood-Taylor}, H. and 
+	{Shih}, A.~Y. and {Sick}, J. and {Silbiger}, M.~T. and {Singanamalla}, S. and 
+	{Singer}, L.~P. and {Sladen}, P.~H. and {Sooley}, K.~A. and 
+	{Sornarajah}, S. and {Streicher}, O. and {Teuben}, P. and {Thomas}, S.~W. and 
+	{Tremblay}, G.~R. and {Turner}, J.~E.~H. and {Terr{\'o}n}, V. and 
+	{van Kerkwijk}, M.~H. and {de la Vega}, A. and {Watkins}, L.~L. and 
+	{Weaver}, B.~A. and {Whitmore}, J.~B. and {Woillez}, J. and 
+	{Zabalza}, V. and {Contributors}, (.},
+    title = "{The Astropy Project: Building an Open-science Project and Status of the v2.0 Core Package}",
+  journal = {\aj},
+archivePrefix = "arXiv",
+   eprint = {1801.02634},
+ primaryClass = "astro-ph.IM",
+ keywords = {methods: data analysis, methods: miscellaneous, methods: statistical, reference systems },
+     year = 2018,
+    month = sep,
+   volume = 156,
+      eid = {123},
+    pages = {123},
+      doi = {10.3847/1538-3881/aabc4f},
+   adsurl = {http://adsabs.harvard.edu/abs/2018AJ....156..123T},
+  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}
+
+@ARTICLE{2013A&A...558A..33A,
+   author = {{Astropy Collaboration} and {Robitaille}, T.~P. and {Tollerud}, E.~J. and
+    {Greenfield}, P. and {Droettboom}, M. and {Bray}, E. and {Aldcroft}, T. and
+    {Davis}, M. and {Ginsburg}, A. and {Price-Whelan}, A.~M. and
+    {Kerzendorf}, W.~E. and {Conley}, A. and {Crighton}, N. and
+    {Barbary}, K. and {Muna}, D. and {Ferguson}, H. and {Grollier}, F. and
+    {Parikh}, M.~M. and {Nair}, P.~H. and {Unther}, H.~M. and {Deil}, C. and
+    {Woillez}, J. and {Conseil}, S. and {Kramer}, R. and {Turner}, J.~E.~H. and
+    {Singer}, L. and {Fox}, R. and {Weaver}, B.~A. and {Zabalza}, V. and
+    {Edwards}, Z.~I. and {Azalee Bostroem}, K. and {Burke}, D.~J. and
+    {Casey}, A.~R. and {Crawford}, S.~M. and {Dencheva}, N. and
+    {Ely}, J. and {Jenness}, T. and {Labrie}, K. and {Lian Lim}, P. and
+    {Pierfederici}, F. and {Pontzen}, A. and {Ptak}, A. and {Refsdal}, B. and
+    {Servillat}, M. and {Streicher}, O.},
+    title = "{Astropy: A community Python package for astronomy}",
+  journal = {\aap},
+ keywords = {methods: data analysis, methods: miscellaneous, virtual observatory tools},
+     year = 2013,
+    month = oct,
+   volume = 558,
+      eid = {A33},
+    pages = {A33},
+      doi = {10.1051/0004-6361/201322068},
+   adsurl = {http://adsabs.harvard.edu/abs/2013A%26A...558A..33A},
+  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}

testbed/astropy__astropy/CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+All Astropy community members are expected to abide by the [Astropy Project Code of Conduct](http://www.astropy.org/code_of_conduct.html).

testbed/astropy__astropy/CONTRIBUTING.md

@@ -0,0 +1,177 @@
+Contributing to Astropy
+=======================
+
+Reporting Issues
+----------------
+
+When opening an issue to report a problem, please try to provide a minimal code
+example that reproduces the issue along with details of the operating
+system and the Python, NumPy, and `astropy` versions you are using.
+
+Contributing Code
+-----------------
+
+So you are interested in contributing code to the Astropy Project? Excellent!
+We love contributions! Astropy 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 by
+`Adrienne Lowe <https://github.com/adriennefriend>`_ for a
+`PyCon talk <https://www.youtube.com/watch?v=6Uj746j9Heo>`_, and was adapted by
+Astropy based on its use in the README file for the
+`MetPy project <https://github.com/Unidata/MetPy>`_.
+
+Most contributions to Astropy are done via pull requests from GitHub users'
+forks of the [astropy repository](https://github.com/astropy/astropy). If you
+are new to this style of development, you will want to read over our
+[development workflow](http://docs.astropy.org/en/latest/development/workflow/development_workflow.html).
+
+You may also/instead be interested in contributing to an
+[astropy affiliated package](http://www.astropy.org/affiliated/).
+Affiliated packages are astronomy-related software packages that are not a part
+of the `astropy` core package, but build on it for more specialized applications
+and follow the Astropy guidelines for reuse, interoperability, and interfacing.
+Each affiliated package has its own developers/maintainers and its own specific
+guidelines for contributions, so be sure to read their docs.
+
+Once you open a pull request (which should be opened against the ``master``
+branch, not against any of the other branches), please make sure to
+include the following:
+
+- **Code**: the code you are adding, which should follow
+  our [coding guidelines](http://docs.astropy.org/en/latest/development/codeguide.html) as much as possible.
+
+- **Tests**: these are usually tests to ensure code that previously
+  failed now works (regression tests), or tests that cover as much as possible
+  of the new functionality to make sure it does not break in the future and
+  also returns consistent results on all platforms (since we run these tests on
+  many platforms/configurations). For more information about how to write
+  tests, see our [testing guidelines](http://docs.astropy.org/en/latest/development/testguide.html).
+
+- **Documentation**: if you are adding new functionality, be sure to include a
+  description in the main documentation (in ``docs/``). Again, we have some
+  detailed [documentation guidelines](http://docs.astropy.org/en/latest/development/docguide.html) to help you out.
+
+- **Performance improvements**: if you are making changes that impact `astropy`
+  performance, consider adding a performance benchmark in the
+  [astropy-benchmarks](https://github.com/astropy/astropy-benchmarks)
+  repository. You can find out more about how to do this
+  [in the README for that repository](https://github.com/astropy/astropy-benchmarks#contributing-a-benchmark).
+
+- **Changelog entry**: whether you are fixing a bug or adding new
+  functionality, you should add an entry to the ``CHANGES.rst`` file that
+  includes the PR number. If you are opening a pull request you may not know
+  the PR number yet, but you can add it once the pull request is open. If you
+  are not sure where to put the changelog entry, wait until a maintainer
+  has reviewed your PR and assigned it to a milestone.
+
+  You do not need to include a changelog entry for fixes to bugs introduced in
+  the developer version and therefore are not present in the stable releases. In
+  general you do not need to include a changelog entry for minor documentation
+  or test updates. Only user-visible changes (new features/API changes, fixed
+  issues) need to be mentioned. If in doubt, ask the core maintainer reviewing
+  your changes.
+
+Other Tips
+----------
+
+- To prevent the automated tests from running, you can add ``[ci skip]`` to your
+  commit message. This is useful if your PR is a work in progress and you are
+  not yet ready for the tests to run. For example:
+
+      $ git commit -m "WIP widget [ci skip]"
+
+  - If you already made the commit without including this string, you can edit
+    your existing commit message by running:
+
+        $ git commit --amend
+
+- To skip only the AppVeyor (Windows) CI builds you can use ``[skip appveyor]``,
+  and to skip testing on Travis CI use ``[skip travis]``.
+
+- If your commit makes substantial changes to the documentation but no code
+  changes, then you can use ``[docs only]``, which will skip all but the
+  documentation building jobs on Travis.
+
+- When contributing trivial documentation fixes (i.e. fixes to typos, spelling,
+  grammar) that don't contain any special markup and are not associated with
+  code changes, please include the string ``[docs only]`` in your commit
+  message.
+
+      $ git commit -m "Fixed typo [docs only]"
+
+Checklist for Contributed Code
+------------------------------
+
+A pull request for a new feature will be reviewed to see if it meets the
+following requirements. For any pull request, an `astropy` maintainer can help
+to make sure that the pull request meets the requirements for inclusion in the
+package.
+
+**Scientific Quality** (when applicable)
+  * Is the submission relevant to astronomy?
+  * Are references included to the origin source for the algorithm?
+  * Does the code perform as expected?
+  * Has the code been tested against previously existing implementations?
+
+**Code Quality**
+  * Are the [coding guidelines](http://docs.astropy.org/en/latest/development/codeguide.html) followed?
+  * Is the code compatible with Python >=3.5?
+  * Are there dependencies other than the `astropy` core, the Python Standard
+    Library, and NumPy 1.10.0 or later?
+    * Is the package importable even if the C-extensions are not built?
+    * Are additional dependencies handled appropriately?
+    * Do functions that require additional dependencies raise an `ImportError`
+      if they are not present?
+
+**Testing**
+  * Are the [testing guidelines](http://docs.astropy.org/en/latest/development/testguide.html) followed?
+  * Are the inputs to the functions sufficiently tested?
+  * Are there tests for any exceptions raised?
+  * Are there tests for the expected performance?
+  * Are the sources for the tests documented?
+  * Have tests that require an [optional dependency](http://docs.astropy.org/en/latest/development/testguide.html#tests-requiring-optional-dependencies)
+    been marked as such?
+  * Does ``python setup.py test`` run without failures?
+
+**Documentation**
+  * Are the [documentation guidelines](http://docs.astropy.org/en/latest/development/docguide.html) followed?
+  * Is there a [docstring](http://docs.astropy.org/en/latest/development/docrules.html) in the function describing:
+    * What the code does?
+    * The format of the inputs of the function?
+    * The format of the outputs of the function?
+    * References to the original algorithms?
+    * Any exceptions which are raised?
+    * An example of running the code?
+  * Is there any information needed to be added to the docs to describe the
+    function?
+  * Does the documentation build without errors or warnings?
+
+**License**
+  * Is the `astropy` license included at the top of the file?
+  * Are there any conflicts with this code and existing codes?
+
+**Astropy requirements**
+  * Do all the Travis CI, AppVeyor, and CircleCI tests pass?
+  * If applicable, has an entry been added into the changelog?
+  * Can you check out the pull request and repeat the examples and tests?

testbed/astropy__astropy/GOVERNANCE.md

@@ -0,0 +1,3 @@
+# Astropy Project Governance
+
+Please visit our website to learn more about the [Astropy Team](http://www.astropy.org/team.html).

testbed/astropy__astropy/LICENSE.rst

@@ -0,0 +1,26 @@
+Copyright (c) 2011-2017, Astropy Developers
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name of the Astropy Team nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

testbed/astropy__astropy/MANIFEST.in

@@ -0,0 +1,53 @@
+include .astropy-root
+include LICENSE.rst
+include README.rst
+include CHANGES.rst
+include pip-requirements*
+include CITATION
+include astropy/CITATION
+
+include ah_bootstrap.py
+include setup.cfg
+include astropy/tests/coveragerc
+recursive-include astropy *.pyx *.c *.h *.map *.templ
+
+include astropy/astropy.cfg
+
+# We have to explicitly include the following modules, otherwise only the
+# Python 2 versions are included when making a source distribution in Python
+# 2, and similarly for Python 3:
+include astropy/extern/configobj/*.py
+recursive-include astropy/utils/compat *.py
+
+recursive-include docs *
+recursive-include examples *
+recursive-include licenses *
+recursive-include cextern *
+recursive-include scripts *
+recursive-include static *
+
+prune docs/_build
+prune build
+
+
+# the next few stanzas are for astropy_helpers.  It's derived from the
+# astropy_helpers/MANIFEST.in, but requires additional includes for the actual
+# package directory and egg-info.
+
+include astropy_helpers/README.rst
+include astropy_helpers/CHANGES.rst
+include astropy_helpers/LICENSE.rst
+recursive-include astropy_helpers/licenses *
+
+include astropy_helpers/ah_bootstrap.py
+
+recursive-include astropy_helpers/astropy_helpers *.py *.pyx *.c *.h *.rst
+recursive-include astropy_helpers/astropy_helpers.egg-info *
+# include the sphinx stuff with "*" because there are css/html/rst/etc.
+recursive-include astropy_helpers/astropy_helpers/sphinx *
+
+prune astropy_helpers/build
+prune astropy_helpers/astropy_helpers/tests
+
+
+global-exclude *.pyc *.o

testbed/astropy__astropy/README.rst

@@ -0,0 +1,90 @@
+=======
+Astropy
+=======
+
+|Travis Status| |AppVeyor Status| |CircleCI Status| |Coverage Status| |PyPI Status| |Documentation Status|
+
+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 are `registered on PyPI <http://pypi.python.org/pypi/astropy>`_,
+and development is occurring at the
+`project's GitHub page <http://github.com/astropy/astropy>`_.
+
+For installation instructions, see the `online documentation <http://docs.astropy.org/>`_
+or  `docs/install.rst <docs/install.rst>`_ in this source distribution.
+
+Contributing Code, Documentation, or Feedback
+---------------------------------------------
+
+The 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 the
+`Astropy Community Code of Conduct <http://www.astropy.org/about.html#codeofconduct>`_.
+
+More detailed information on contributing to the project or submitting feedback
+can be found on the `contributions <http://www.astropy.org/contribute.html>`_
+page. A `summary of contribution guidelines <CONTRIBUTING.md>`_ can also be
+used as a quick reference when you are ready to start writing or validating
+code for submission.
+
+Supporting the Project
+----------------------
+
+|NumFOCUS| |Donate|
+
+The 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.
+
+License
+-------
+
+Astropy is licensed under a 3-clause BSD style license - see the
+`LICENSE.rst <LICENSE.rst>`_ file.
+
+Notes for Package Managers
+--------------------------
+
+For system packagers: Please install `astropy` with the command::
+
+    $ python setup.py --offline install
+
+This will prevent the astropy_helpers bootstrap script from attempting to
+reach out to PyPI.
+
+.. |Travis Status| image:: https://travis-ci.org/astropy/astropy.svg
+    :target: https://travis-ci.org/astropy/astropy
+    :alt: Astropy's Travis CI Status
+
+.. |CircleCI Status| image:: https://circleci.com/gh/astropy/astropy.svg?style=svg
+    :target: https://circleci.com/gh/astropy/astropy
+    :alt: Astropy's CircleCI Status
+
+.. |AppVeyor Status| image:: https://ci.appveyor.com/api/projects/status/ym7lxajcs5qwm31e/branch/master?svg=true
+    :target: https://ci.appveyor.com/project/Astropy/astropy/branch/master
+    :alt: Astropy's Appveyor Status
+
+.. |Coverage Status| image:: https://codecov.io/gh/astropy/astropy/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/astropy/astropy
+    :alt: Astropy's Coverage Status
+
+.. |PyPI Status| image:: https://img.shields.io/pypi/v/astropy.svg
+    :target: https://pypi.python.org/pypi/astropy
+    :alt: Astropy's PyPI Status
+
+.. |Documentation Status| image:: https://readthedocs.org/projects/astropy/badge/?version=stable
+    :target: http://docs.astropy.org/en/stable/?badge=stable
+    :alt: Documentation Status
+
+.. |NumFOCUS| image:: https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A
+    :target: http://numfocus.org
+    :alt: Powered by NumFOCUS
+
+.. |Donate| image:: https://img.shields.io/badge/Donate-to%20Astropy-brightgreen.svg
+    :target: https://numfocus.salsalabs.org/donate-to-astropy/index.html

testbed/astropy__astropy/ah_bootstrap.py

@@ -0,0 +1,1010 @@
+"""
+This bootstrap module contains code for ensuring that the astropy_helpers
+package will be importable by the time the setup.py script runs.  It also
+includes some workarounds to ensure that a recent-enough version of setuptools
+is being used for the installation.
+
+This module should be the first thing imported in the setup.py of distributions
+that make use of the utilities in astropy_helpers.  If the distribution ships
+with its own copy of astropy_helpers, this module will first attempt to import
+from the shipped copy.  However, it will also check PyPI to see if there are
+any bug-fix releases on top of the current version that may be useful to get
+past platform-specific bugs that have been fixed.  When running setup.py, use
+the ``--offline`` command-line option to disable the auto-upgrade checks.
+
+When this module is imported or otherwise executed it automatically calls a
+main function that attempts to read the project's setup.cfg file, which it
+checks for a configuration section called ``[ah_bootstrap]`` the presences of
+that section, and options therein, determine the next step taken:  If it
+contains an option called ``auto_use`` with a value of ``True``, it will
+automatically call the main function of this module called
+`use_astropy_helpers` (see that function's docstring for full details).
+Otherwise no further action is taken and by default the system-installed version
+of astropy-helpers will be used (however, ``ah_bootstrap.use_astropy_helpers``
+may be called manually from within the setup.py script).
+
+This behavior can also be controlled using the ``--auto-use`` and
+``--no-auto-use`` command-line flags. For clarity, an alias for
+``--no-auto-use`` is ``--use-system-astropy-helpers``, and we recommend using
+the latter if needed.
+
+Additional options in the ``[ah_boostrap]`` section of setup.cfg have the same
+names as the arguments to `use_astropy_helpers`, and can be used to configure
+the bootstrap script when ``auto_use = True``.
+
+See https://github.com/astropy/astropy-helpers for more details, and for the
+latest version of this module.
+"""
+
+import contextlib
+import errno
+import io
+import locale
+import os
+import re
+import subprocess as sp
+import sys
+
+from distutils import log
+from distutils.debug import DEBUG
+
+from configparser import ConfigParser, RawConfigParser
+
+import pkg_resources
+
+from setuptools import Distribution
+from setuptools.package_index import PackageIndex
+
+# This is the minimum Python version required for astropy-helpers
+__minimum_python_version__ = (3, 5)
+
+# TODO: Maybe enable checking for a specific version of astropy_helpers?
+DIST_NAME = 'astropy-helpers'
+PACKAGE_NAME = 'astropy_helpers'
+UPPER_VERSION_EXCLUSIVE = None
+
+# Defaults for other options
+DOWNLOAD_IF_NEEDED = True
+INDEX_URL = 'https://pypi.python.org/simple'
+USE_GIT = True
+OFFLINE = False
+AUTO_UPGRADE = True
+
+# A list of all the configuration options and their required types
+CFG_OPTIONS = [
+    ('auto_use', bool), ('path', str), ('download_if_needed', bool),
+    ('index_url', str), ('use_git', bool), ('offline', bool),
+    ('auto_upgrade', bool)
+]
+
+# Start off by parsing the setup.cfg file
+
+SETUP_CFG = ConfigParser()
+
+if os.path.exists('setup.cfg'):
+
+    try:
+        SETUP_CFG.read('setup.cfg')
+    except Exception as e:
+        if DEBUG:
+            raise
+
+        log.error(
+            "Error reading setup.cfg: {0!r}\n{1} will not be "
+            "automatically bootstrapped and package installation may fail."
+            "\n{2}".format(e, PACKAGE_NAME, _err_help_msg))
+
+# We used package_name in the package template for a while instead of name
+if SETUP_CFG.has_option('metadata', 'name'):
+    parent_package = SETUP_CFG.get('metadata', 'name')
+elif SETUP_CFG.has_option('metadata', 'package_name'):
+    parent_package = SETUP_CFG.get('metadata', 'package_name')
+else:
+    parent_package = None
+
+if SETUP_CFG.has_option('options', 'python_requires'):
+
+    python_requires = SETUP_CFG.get('options', 'python_requires')
+
+    # The python_requires key has a syntax that can be parsed by SpecifierSet
+    # in the packaging package. However, we don't want to have to depend on that
+    # package, so instead we can use setuptools (which bundles packaging). We
+    # have to add 'python' to parse it with Requirement.
+
+    from pkg_resources import Requirement
+    req = Requirement.parse('python' + python_requires)
+
+    # We want the Python version as a string, which we can get from the platform module
+    import platform
+    # strip off trailing '+' incase this is a dev install of python
+    python_version = platform.python_version().strip('+')
+    # allow pre-releases to count as 'new enough'
+    if not req.specifier.contains(python_version, True):
+        if parent_package is None:
+            message = "ERROR: Python {} is required by this package\n".format(req.specifier)
+        else:
+            message = "ERROR: Python {} is required by {}\n".format(req.specifier, parent_package)
+        sys.stderr.write(message)
+        sys.exit(1)
+
+if sys.version_info < __minimum_python_version__:
+
+    if parent_package is None:
+        message = "ERROR: Python {} or later is required by astropy-helpers\n".format(
+            __minimum_python_version__)
+    else:
+        message = "ERROR: Python {} or later is required by astropy-helpers for {}\n".format(
+            __minimum_python_version__, parent_package)
+
+    sys.stderr.write(message)
+    sys.exit(1)
+
+_str_types = (str, bytes)
+
+
+# What follows are several import statements meant to deal with install-time
+# issues with either missing or misbehaving pacakges (including making sure
+# setuptools itself is installed):
+
+# Check that setuptools 30.3 or later is present
+from distutils.version import LooseVersion
+
+try:
+    import setuptools
+    assert LooseVersion(setuptools.__version__) >= LooseVersion('30.3')
+except (ImportError, AssertionError):
+    sys.stderr.write("ERROR: setuptools 30.3 or later is required by astropy-helpers\n")
+    sys.exit(1)
+
+# typing as a dependency for 1.6.1+ Sphinx causes issues when imported after
+# initializing submodule with ah_boostrap.py
+# See discussion and references in
+# https://github.com/astropy/astropy-helpers/issues/302
+
+try:
+    import typing   # noqa
+except ImportError:
+    pass
+
+
+# Note: The following import is required as a workaround to
+# https://github.com/astropy/astropy-helpers/issues/89; if we don't import this
+# module now, it will get cleaned up after `run_setup` is called, but that will
+# later cause the TemporaryDirectory class defined in it to stop working when
+# used later on by setuptools
+try:
+    import setuptools.py31compat   # noqa
+except ImportError:
+    pass
+
+
+# matplotlib can cause problems if it is imported from within a call of
+# run_setup(), because in some circumstances it will try to write to the user's
+# home directory, resulting in a SandboxViolation.  See
+# https://github.com/matplotlib/matplotlib/pull/4165
+# Making sure matplotlib, if it is available, is imported early in the setup
+# process can mitigate this (note importing matplotlib.pyplot has the same
+# issue)
+try:
+    import matplotlib
+    matplotlib.use('Agg')
+    import matplotlib.pyplot
+except:
+    # Ignore if this fails for *any* reason*
+    pass
+
+
+# End compatibility imports...
+
+
+class _Bootstrapper(object):
+    """
+    Bootstrapper implementation.  See ``use_astropy_helpers`` for parameter
+    documentation.
+    """
+
+    def __init__(self, path=None, index_url=None, use_git=None, offline=None,
+                 download_if_needed=None, auto_upgrade=None):
+
+        if path is None:
+            path = PACKAGE_NAME
+
+        if not (isinstance(path, _str_types) or path is False):
+            raise TypeError('path must be a string or False')
+
+        if not isinstance(path, str):
+            fs_encoding = sys.getfilesystemencoding()
+            path = path.decode(fs_encoding)  # path to unicode
+
+        self.path = path
+
+        # Set other option attributes, using defaults where necessary
+        self.index_url = index_url if index_url is not None else INDEX_URL
+        self.offline = offline if offline is not None else OFFLINE
+
+        # If offline=True, override download and auto-upgrade
+        if self.offline:
+            download_if_needed = False
+            auto_upgrade = False
+
+        self.download = (download_if_needed
+                         if download_if_needed is not None
+                         else DOWNLOAD_IF_NEEDED)
+        self.auto_upgrade = (auto_upgrade
+                             if auto_upgrade is not None else AUTO_UPGRADE)
+
+        # If this is a release then the .git directory will not exist so we
+        # should not use git.
+        git_dir_exists = os.path.exists(os.path.join(os.path.dirname(__file__), '.git'))
+        if use_git is None and not git_dir_exists:
+            use_git = False
+
+        self.use_git = use_git if use_git is not None else USE_GIT
+        # Declared as False by default--later we check if astropy-helpers can be
+        # upgraded from PyPI, but only if not using a source distribution (as in
+        # the case of import from a git submodule)
+        self.is_submodule = False
+
+    @classmethod
+    def main(cls, argv=None):
+        if argv is None:
+            argv = sys.argv
+
+        config = cls.parse_config()
+        config.update(cls.parse_command_line(argv))
+
+        auto_use = config.pop('auto_use', False)
+        bootstrapper = cls(**config)
+
+        if auto_use:
+            # Run the bootstrapper, otherwise the setup.py is using the old
+            # use_astropy_helpers() interface, in which case it will run the
+            # bootstrapper manually after reconfiguring it.
+            bootstrapper.run()
+
+        return bootstrapper
+
+    @classmethod
+    def parse_config(cls):
+
+        if not SETUP_CFG.has_section('ah_bootstrap'):
+            return {}
+
+        config = {}
+
+        for option, type_ in CFG_OPTIONS:
+            if not SETUP_CFG.has_option('ah_bootstrap', option):
+                continue
+
+            if type_ is bool:
+                value = SETUP_CFG.getboolean('ah_bootstrap', option)
+            else:
+                value = SETUP_CFG.get('ah_bootstrap', option)
+
+            config[option] = value
+
+        return config
+
+    @classmethod
+    def parse_command_line(cls, argv=None):
+        if argv is None:
+            argv = sys.argv
+
+        config = {}
+
+        # For now we just pop recognized ah_bootstrap options out of the
+        # arg list.  This is imperfect; in the unlikely case that a setup.py
+        # custom command or even custom Distribution class defines an argument
+        # of the same name then we will break that.  However there's a catch22
+        # here that we can't just do full argument parsing right here, because
+        # we don't yet know *how* to parse all possible command-line arguments.
+        if '--no-git' in argv:
+            config['use_git'] = False
+            argv.remove('--no-git')
+
+        if '--offline' in argv:
+            config['offline'] = True
+            argv.remove('--offline')
+
+        if '--auto-use' in argv:
+            config['auto_use'] = True
+            argv.remove('--auto-use')
+
+        if '--no-auto-use' in argv:
+            config['auto_use'] = False
+            argv.remove('--no-auto-use')
+
+        if '--use-system-astropy-helpers' in argv:
+            config['auto_use'] = False
+            argv.remove('--use-system-astropy-helpers')
+
+        return config
+
+    def run(self):
+        strategies = ['local_directory', 'local_file', 'index']
+        dist = None
+
+        # First, remove any previously imported versions of astropy_helpers;
+        # this is necessary for nested installs where one package's installer
+        # is installing another package via setuptools.sandbox.run_setup, as in
+        # the case of setup_requires
+        for key in list(sys.modules):
+            try:
+                if key == PACKAGE_NAME or key.startswith(PACKAGE_NAME + '.'):
+                    del sys.modules[key]
+            except AttributeError:
+                # Sometimes mysterious non-string things can turn up in
+                # sys.modules
+                continue
+
+        # Check to see if the path is a submodule
+        self.is_submodule = self._check_submodule()
+
+        for strategy in strategies:
+            method = getattr(self, 'get_{0}_dist'.format(strategy))
+            dist = method()
+            if dist is not None:
+                break
+        else:
+            raise _AHBootstrapSystemExit(
+                "No source found for the {0!r} package; {0} must be "
+                "available and importable as a prerequisite to building "
+                "or installing this package.".format(PACKAGE_NAME))
+
+        # This is a bit hacky, but if astropy_helpers was loaded from a
+        # directory/submodule its Distribution object gets a "precedence" of
+        # "DEVELOP_DIST".  However, in other cases it gets a precedence of
+        # "EGG_DIST".  However, when activing the distribution it will only be
+        # placed early on sys.path if it is treated as an EGG_DIST, so always
+        # do that
+        dist = dist.clone(precedence=pkg_resources.EGG_DIST)
+
+        # Otherwise we found a version of astropy-helpers, so we're done
+        # Just active the found distribution on sys.path--if we did a
+        # download this usually happens automatically but it doesn't hurt to
+        # do it again
+        # Note: Adding the dist to the global working set also activates it
+        # (makes it importable on sys.path) by default.
+
+        try:
+            pkg_resources.working_set.add(dist, replace=True)
+        except TypeError:
+            # Some (much) older versions of setuptools do not have the
+            # replace=True option here.  These versions are old enough that all
+            # bets may be off anyways, but it's easy enough to work around just
+            # in case...
+            if dist.key in pkg_resources.working_set.by_key:
+                del pkg_resources.working_set.by_key[dist.key]
+            pkg_resources.working_set.add(dist)
+
+    @property
+    def config(self):
+        """
+        A `dict` containing the options this `_Bootstrapper` was configured
+        with.
+        """
+
+        return dict((optname, getattr(self, optname))
+                    for optname, _ in CFG_OPTIONS if hasattr(self, optname))
+
+    def get_local_directory_dist(self):
+        """
+        Handle importing a vendored package from a subdirectory of the source
+        distribution.
+        """
+
+        if not os.path.isdir(self.path):
+            return
+
+        log.info('Attempting to import astropy_helpers from {0} {1!r}'.format(
+                 'submodule' if self.is_submodule else 'directory',
+                 self.path))
+
+        dist = self._directory_import()
+
+        if dist is None:
+            log.warn(
+                'The requested path {0!r} for importing {1} does not '
+                'exist, or does not contain a copy of the {1} '
+                'package.'.format(self.path, PACKAGE_NAME))
+        elif self.auto_upgrade and not self.is_submodule:
+            # A version of astropy-helpers was found on the available path, but
+            # check to see if a bugfix release is available on PyPI
+            upgrade = self._do_upgrade(dist)
+            if upgrade is not None:
+                dist = upgrade
+
+        return dist
+
+    def get_local_file_dist(self):
+        """
+        Handle importing from a source archive; this also uses setup_requires
+        but points easy_install directly to the source archive.
+        """
+
+        if not os.path.isfile(self.path):
+            return
+
+        log.info('Attempting to unpack and import astropy_helpers from '
+                 '{0!r}'.format(self.path))
+
+        try:
+            dist = self._do_download(find_links=[self.path])
+        except Exception as e:
+            if DEBUG:
+                raise
+
+            log.warn(
+                'Failed to import {0} from the specified archive {1!r}: '
+                '{2}'.format(PACKAGE_NAME, self.path, str(e)))
+            dist = None
+
+        if dist is not None and self.auto_upgrade:
+            # A version of astropy-helpers was found on the available path, but
+            # check to see if a bugfix release is available on PyPI
+            upgrade = self._do_upgrade(dist)
+            if upgrade is not None:
+                dist = upgrade
+
+        return dist
+
+    def get_index_dist(self):
+        if not self.download:
+            log.warn('Downloading {0!r} disabled.'.format(DIST_NAME))
+            return None
+
+        log.warn(
+            "Downloading {0!r}; run setup.py with the --offline option to "
+            "force offline installation.".format(DIST_NAME))
+
+        try:
+            dist = self._do_download()
+        except Exception as e:
+            if DEBUG:
+                raise
+            log.warn(
+                'Failed to download and/or install {0!r} from {1!r}:\n'
+                '{2}'.format(DIST_NAME, self.index_url, str(e)))
+            dist = None
+
+        # No need to run auto-upgrade here since we've already presumably
+        # gotten the most up-to-date version from the package index
+        return dist
+
+    def _directory_import(self):
+        """
+        Import astropy_helpers from the given path, which will be added to
+        sys.path.
+
+        Must return True if the import succeeded, and False otherwise.
+        """
+
+        # Return True on success, False on failure but download is allowed, and
+        # otherwise raise SystemExit
+        path = os.path.abspath(self.path)
+
+        # Use an empty WorkingSet rather than the man
+        # pkg_resources.working_set, since on older versions of setuptools this
+        # will invoke a VersionConflict when trying to install an upgrade
+        ws = pkg_resources.WorkingSet([])
+        ws.add_entry(path)
+        dist = ws.by_key.get(DIST_NAME)
+
+        if dist is None:
+            # We didn't find an egg-info/dist-info in the given path, but if a
+            # setup.py exists we can generate it
+            setup_py = os.path.join(path, 'setup.py')
+            if os.path.isfile(setup_py):
+                # We use subprocess instead of run_setup from setuptools to
+                # avoid segmentation faults - see the following for more details:
+                # https://github.com/cython/cython/issues/2104
+                sp.check_output([sys.executable, 'setup.py', 'egg_info'], cwd=path)
+
+                for dist in pkg_resources.find_distributions(path, True):
+                    # There should be only one...
+                    return dist
+
+        return dist
+
+    def _do_download(self, version='', find_links=None):
+        if find_links:
+            allow_hosts = ''
+            index_url = None
+        else:
+            allow_hosts = None
+            index_url = self.index_url
+
+        # Annoyingly, setuptools will not handle other arguments to
+        # Distribution (such as options) before handling setup_requires, so it
+        # is not straightforward to programmatically augment the arguments which
+        # are passed to easy_install
+        class _Distribution(Distribution):
+            def get_option_dict(self, command_name):
+                opts = Distribution.get_option_dict(self, command_name)
+                if command_name == 'easy_install':
+                    if find_links is not None:
+                        opts['find_links'] = ('setup script', find_links)
+                    if index_url is not None:
+                        opts['index_url'] = ('setup script', index_url)
+                    if allow_hosts is not None:
+                        opts['allow_hosts'] = ('setup script', allow_hosts)
+                return opts
+
+        if version:
+            req = '{0}=={1}'.format(DIST_NAME, version)
+        else:
+            if UPPER_VERSION_EXCLUSIVE is None:
+                req = DIST_NAME
+            else:
+                req = '{0}<{1}'.format(DIST_NAME, UPPER_VERSION_EXCLUSIVE)
+
+        attrs = {'setup_requires': [req]}
+
+        # NOTE: we need to parse the config file (e.g. setup.cfg) to make sure
+        # it honours the options set in the [easy_install] section, and we need
+        # to explicitly fetch the requirement eggs as setup_requires does not
+        # get honored in recent versions of setuptools:
+        # https://github.com/pypa/setuptools/issues/1273
+
+        try:
+
+            context = _verbose if DEBUG else _silence
+            with context():
+                dist = _Distribution(attrs=attrs)
+                try:
+                    dist.parse_config_files(ignore_option_errors=True)
+                    dist.fetch_build_eggs(req)
+                except TypeError:
+                    # On older versions of setuptools, ignore_option_errors
+                    # doesn't exist, and the above two lines are not needed
+                    # so we can just continue
+                    pass
+
+            # If the setup_requires succeeded it will have added the new dist to
+            # the main working_set
+            return pkg_resources.working_set.by_key.get(DIST_NAME)
+        except Exception as e:
+            if DEBUG:
+                raise
+
+            msg = 'Error retrieving {0} from {1}:\n{2}'
+            if find_links:
+                source = find_links[0]
+            elif index_url != INDEX_URL:
+                source = index_url
+            else:
+                source = 'PyPI'
+
+            raise Exception(msg.format(DIST_NAME, source, repr(e)))
+
+    def _do_upgrade(self, dist):
+        # Build up a requirement for a higher bugfix release but a lower minor
+        # release (so API compatibility is guaranteed)
+        next_version = _next_version(dist.parsed_version)
+
+        req = pkg_resources.Requirement.parse(
+            '{0}>{1},<{2}'.format(DIST_NAME, dist.version, next_version))
+
+        package_index = PackageIndex(index_url=self.index_url)
+
+        upgrade = package_index.obtain(req)
+
+        if upgrade is not None:
+            return self._do_download(version=upgrade.version)
+
+    def _check_submodule(self):
+        """
+        Check if the given path is a git submodule.
+
+        See the docstrings for ``_check_submodule_using_git`` and
+        ``_check_submodule_no_git`` for further details.
+        """
+
+        if (self.path is None or
+                (os.path.exists(self.path) and not os.path.isdir(self.path))):
+            return False
+
+        if self.use_git:
+            return self._check_submodule_using_git()
+        else:
+            return self._check_submodule_no_git()
+
+    def _check_submodule_using_git(self):
+        """
+        Check if the given path is a git submodule.  If so, attempt to initialize
+        and/or update the submodule if needed.
+
+        This function makes calls to the ``git`` command in subprocesses.  The
+        ``_check_submodule_no_git`` option uses pure Python to check if the given
+        path looks like a git submodule, but it cannot perform updates.
+        """
+
+        cmd = ['git', 'submodule', 'status', '--', self.path]
+
+        try:
+            log.info('Running `{0}`; use the --no-git option to disable git '
+                     'commands'.format(' '.join(cmd)))
+            returncode, stdout, stderr = run_cmd(cmd)
+        except _CommandNotFound:
+            # The git command simply wasn't found; this is most likely the
+            # case on user systems that don't have git and are simply
+            # trying to install the package from PyPI or a source
+            # distribution.  Silently ignore this case and simply don't try
+            # to use submodules
+            return False
+
+        stderr = stderr.strip()
+
+        if returncode != 0 and stderr:
+            # Unfortunately the return code alone cannot be relied on, as
+            # earlier versions of git returned 0 even if the requested submodule
+            # does not exist
+
+            # This is a warning that occurs in perl (from running git submodule)
+            # which only occurs with a malformatted locale setting which can
+            # happen sometimes on OSX.  See again
+            # https://github.com/astropy/astropy/issues/2749
+            perl_warning = ('perl: warning: Falling back to the standard locale '
+                            '("C").')
+            if not stderr.strip().endswith(perl_warning):
+                # Some other unknown error condition occurred
+                log.warn('git submodule command failed '
+                         'unexpectedly:\n{0}'.format(stderr))
+                return False
+
+        # Output of `git submodule status` is as follows:
+        #
+        # 1: Status indicator: '-' for submodule is uninitialized, '+' if
+        # submodule is initialized but is not at the commit currently indicated
+        # in .gitmodules (and thus needs to be updated), or 'U' if the
+        # submodule is in an unstable state (i.e. has merge conflicts)
+        #
+        # 2. SHA-1 hash of the current commit of the submodule (we don't really
+        # need this information but it's useful for checking that the output is
+        # correct)
+        #
+        # 3. The output of `git describe` for the submodule's current commit
+        # hash (this includes for example what branches the commit is on) but
+        # only if the submodule is initialized.  We ignore this information for
+        # now
+        _git_submodule_status_re = re.compile(
+            r'^(?P<status>[+-U ])(?P<commit>[0-9a-f]{40}) '
+            r'(?P<submodule>\S+)( .*)?$')
+
+        # The stdout should only contain one line--the status of the
+        # requested submodule
+        m = _git_submodule_status_re.match(stdout)
+        if m:
+            # Yes, the path *is* a git submodule
+            self._update_submodule(m.group('submodule'), m.group('status'))
+            return True
+        else:
+            log.warn(
+                'Unexpected output from `git submodule status`:\n{0}\n'
+                'Will attempt import from {1!r} regardless.'.format(
+                    stdout, self.path))
+            return False
+
+    def _check_submodule_no_git(self):
+        """
+        Like ``_check_submodule_using_git``, but simply parses the .gitmodules file
+        to determine if the supplied path is a git submodule, and does not exec any
+        subprocesses.
+
+        This can only determine if a path is a submodule--it does not perform
+        updates, etc.  This function may need to be updated if the format of the
+        .gitmodules file is changed between git versions.
+        """
+
+        gitmodules_path = os.path.abspath('.gitmodules')
+
+        if not os.path.isfile(gitmodules_path):
+            return False
+
+        # This is a minimal reader for gitconfig-style files.  It handles a few of
+        # the quirks that make gitconfig files incompatible with ConfigParser-style
+        # files, but does not support the full gitconfig syntax (just enough
+        # needed to read a .gitmodules file).
+        gitmodules_fileobj = io.StringIO()
+
+        # Must use io.open for cross-Python-compatible behavior wrt unicode
+        with io.open(gitmodules_path) as f:
+            for line in f:
+                # gitconfig files are more flexible with leading whitespace; just
+                # go ahead and remove it
+                line = line.lstrip()
+
+                # comments can start with either # or ;
+                if line and line[0] in (':', ';'):
+                    continue
+
+                gitmodules_fileobj.write(line)
+
+        gitmodules_fileobj.seek(0)
+
+        cfg = RawConfigParser()
+
+        try:
+            cfg.readfp(gitmodules_fileobj)
+        except Exception as exc:
+            log.warn('Malformatted .gitmodules file: {0}\n'
+                     '{1} cannot be assumed to be a git submodule.'.format(
+                         exc, self.path))
+            return False
+
+        for section in cfg.sections():
+            if not cfg.has_option(section, 'path'):
+                continue
+
+            submodule_path = cfg.get(section, 'path').rstrip(os.sep)
+
+            if submodule_path == self.path.rstrip(os.sep):
+                return True
+
+        return False
+
+    def _update_submodule(self, submodule, status):
+        if status == ' ':
+            # The submodule is up to date; no action necessary
+            return
+        elif status == '-':
+            if self.offline:
+                raise _AHBootstrapSystemExit(
+                    "Cannot initialize the {0} submodule in --offline mode; "
+                    "this requires being able to clone the submodule from an "
+                    "online repository.".format(submodule))
+            cmd = ['update', '--init']
+            action = 'Initializing'
+        elif status == '+':
+            cmd = ['update']
+            action = 'Updating'
+            if self.offline:
+                cmd.append('--no-fetch')
+        elif status == 'U':
+            raise _AHBootstrapSystemExit(
+                'Error: Submodule {0} contains unresolved merge conflicts.  '
+                'Please complete or abandon any changes in the submodule so that '
+                'it is in a usable state, then try again.'.format(submodule))
+        else:
+            log.warn('Unknown status {0!r} for git submodule {1!r}.  Will '
+                     'attempt to use the submodule as-is, but try to ensure '
+                     'that the submodule is in a clean state and contains no '
+                     'conflicts or errors.\n{2}'.format(status, submodule,
+                                                        _err_help_msg))
+            return
+
+        err_msg = None
+        cmd = ['git', 'submodule'] + cmd + ['--', submodule]
+        log.warn('{0} {1} submodule with: `{2}`'.format(
+            action, submodule, ' '.join(cmd)))
+
+        try:
+            log.info('Running `{0}`; use the --no-git option to disable git '
+                     'commands'.format(' '.join(cmd)))
+            returncode, stdout, stderr = run_cmd(cmd)
+        except OSError as e:
+            err_msg = str(e)
+        else:
+            if returncode != 0:
+                err_msg = stderr
+
+        if err_msg is not None:
+            log.warn('An unexpected error occurred updating the git submodule '
+                     '{0!r}:\n{1}\n{2}'.format(submodule, err_msg,
+                                               _err_help_msg))
+
+class _CommandNotFound(OSError):
+    """
+    An exception raised when a command run with run_cmd is not found on the
+    system.
+    """
+
+
+def run_cmd(cmd):
+    """
+    Run a command in a subprocess, given as a list of command-line
+    arguments.
+
+    Returns a ``(returncode, stdout, stderr)`` tuple.
+    """
+
+    try:
+        p = sp.Popen(cmd, stdout=sp.PIPE, stderr=sp.PIPE)
+        # XXX: May block if either stdout or stderr fill their buffers;
+        # however for the commands this is currently used for that is
+        # unlikely (they should have very brief output)
+        stdout, stderr = p.communicate()
+    except OSError as e:
+        if DEBUG:
+            raise
+
+        if e.errno == errno.ENOENT:
+            msg = 'Command not found: `{0}`'.format(' '.join(cmd))
+            raise _CommandNotFound(msg, cmd)
+        else:
+            raise _AHBootstrapSystemExit(
+                'An unexpected error occurred when running the '
+                '`{0}` command:\n{1}'.format(' '.join(cmd), str(e)))
+
+
+    # Can fail of the default locale is not configured properly.  See
+    # https://github.com/astropy/astropy/issues/2749.  For the purposes under
+    # consideration 'latin1' is an acceptable fallback.
+    try:
+        stdio_encoding = locale.getdefaultlocale()[1] or 'latin1'
+    except ValueError:
+        # Due to an OSX oddity locale.getdefaultlocale() can also crash
+        # depending on the user's locale/language settings.  See:
+        # http://bugs.python.org/issue18378
+        stdio_encoding = 'latin1'
+
+    # Unlikely to fail at this point but even then let's be flexible
+    if not isinstance(stdout, str):
+        stdout = stdout.decode(stdio_encoding, 'replace')
+    if not isinstance(stderr, str):
+        stderr = stderr.decode(stdio_encoding, 'replace')
+
+    return (p.returncode, stdout, stderr)
+
+
+def _next_version(version):
+    """
+    Given a parsed version from pkg_resources.parse_version, returns a new
+    version string with the next minor version.
+
+    Examples
+    ========
+    >>> _next_version(pkg_resources.parse_version('1.2.3'))
+    '1.3.0'
+    """
+
+    if hasattr(version, 'base_version'):
+        # New version parsing from setuptools >= 8.0
+        if version.base_version:
+            parts = version.base_version.split('.')
+        else:
+            parts = []
+    else:
+        parts = []
+        for part in version:
+            if part.startswith('*'):
+                break
+            parts.append(part)
+
+    parts = [int(p) for p in parts]
+
+    if len(parts) < 3:
+        parts += [0] * (3 - len(parts))
+
+    major, minor, micro = parts[:3]
+
+    return '{0}.{1}.{2}'.format(major, minor + 1, 0)
+
+
+class _DummyFile(object):
+    """A noop writeable object."""
+
+    errors = ''  # Required for Python 3.x
+    encoding = 'utf-8'
+
+    def write(self, s):
+        pass
+
+    def flush(self):
+        pass
+
+
+@contextlib.contextmanager
+def _verbose():
+    yield
+
+@contextlib.contextmanager
+def _silence():
+    """A context manager that silences sys.stdout and sys.stderr."""
+
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    sys.stdout = _DummyFile()
+    sys.stderr = _DummyFile()
+    exception_occurred = False
+    try:
+        yield
+    except:
+        exception_occurred = True
+        # Go ahead and clean up so that exception handling can work normally
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+        raise
+
+    if not exception_occurred:
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+
+_err_help_msg = """
+If the problem persists consider installing astropy_helpers manually using pip
+(`pip install astropy_helpers`) or by manually downloading the source archive,
+extracting it, and installing by running `python setup.py install` from the
+root of the extracted source code.
+"""
+
+
+class _AHBootstrapSystemExit(SystemExit):
+    def __init__(self, *args):
+        if not args:
+            msg = 'An unknown problem occurred bootstrapping astropy_helpers.'
+        else:
+            msg = args[0]
+
+        msg += '\n' + _err_help_msg
+
+        super(_AHBootstrapSystemExit, self).__init__(msg, *args[1:])
+
+
+BOOTSTRAPPER = _Bootstrapper.main()
+
+
+def use_astropy_helpers(**kwargs):
+    """
+    Ensure that the `astropy_helpers` module is available and is importable.
+    This supports automatic submodule initialization if astropy_helpers is
+    included in a project as a git submodule, or will download it from PyPI if
+    necessary.
+
+    Parameters
+    ----------
+
+    path : str or None, optional
+        A filesystem path relative to the root of the project's source code
+        that should be added to `sys.path` so that `astropy_helpers` can be
+        imported from that path.
+
+        If the path is a git submodule it will automatically be initialized
+        and/or updated.
+
+        The path may also be to a ``.tar.gz`` archive of the astropy_helpers
+        source distribution.  In this case the archive is automatically
+        unpacked and made temporarily available on `sys.path` as a ``.egg``
+        archive.
+
+        If `None` skip straight to downloading.
+
+    download_if_needed : bool, optional
+        If the provided filesystem path is not found an attempt will be made to
+        download astropy_helpers from PyPI.  It will then be made temporarily
+        available on `sys.path` as a ``.egg`` archive (using the
+        ``setup_requires`` feature of setuptools.  If the ``--offline`` option
+        is given at the command line the value of this argument is overridden
+        to `False`.
+
+    index_url : str, optional
+        If provided, use a different URL for the Python package index than the
+        main PyPI server.
+
+    use_git : bool, optional
+        If `False` no git commands will be used--this effectively disables
+        support for git submodules. If the ``--no-git`` option is given at the
+        command line the value of this argument is overridden to `False`.
+
+    auto_upgrade : bool, optional
+        By default, when installing a package from a non-development source
+        distribution ah_boostrap will try to automatically check for patch
+        releases to astropy-helpers on PyPI and use the patched version over
+        any bundled versions.  Setting this to `False` will disable that
+        functionality. If the ``--offline`` option is given at the command line
+        the value of this argument is overridden to `False`.
+
+    offline : bool, optional
+        If `False` disable all actions that require an internet connection,
+        including downloading packages from the package index and fetching
+        updates to any git submodule.  Defaults to `True`.
+    """
+
+    global BOOTSTRAPPER
+
+    config = BOOTSTRAPPER.config
+    config.update(**kwargs)
+
+    # Create a new bootstrapper with the updated configuration and run it
+    BOOTSTRAPPER = _Bootstrapper(**config)
+    BOOTSTRAPPER.run()

testbed/astropy__astropy/appveyor.yml

@@ -0,0 +1,38 @@
+# AppVeyor.com is a Continuous Integration service to build and run tests under
+# Windows
+
+environment:
+
+    global:
+        PYTHON: "C:\\conda"
+        MINICONDA_VERSION: "latest"
+        CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\ci-helpers\\appveyor\\windows_sdk.cmd"
+        PYTHON_ARCH: "64" # needs to be set for CMD_IN_ENV to succeed. If a mix
+                          # of 32 bit and 64 bit builds are needed, move this
+                          # to the matrix section.
+        CONDA_DEPENDENCIES: "Cython scipy h5py beautifulsoup4 html5lib jinja2 pyyaml matplotlib scikit-image pytz pandas"
+        PIP_DEPENDENCIES: "objgraph asdf"
+
+    matrix:
+        - PYTHON_VERSION: "3.7"
+          NUMPY_VERSION: "stable"
+
+matrix:
+    fast_finish: true
+
+platform:
+    -x64
+
+os: Visual Studio 2017
+
+install:
+    - "git clone git://github.com/astropy/ci-helpers.git"
+    - "powershell ci-helpers/appveyor/install-miniconda.ps1"
+    - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
+    - "activate test"
+
+# Not a .NET project, we build Astropy in the install step instead
+build: false
+
+test_script:
+    - "%CMD_IN_ENV% python setup.py test --readonly"

testbed/astropy__astropy/astropy/CITATION

@@ -0,0 +1,112 @@
+If you use Astropy for work/research presented in a publication (whether
+directly, or as a dependency to another package), we recommend and encourage
+the following acknowledgment:
+
+  This research made use of Astropy, a community-developed core Python package
+  for Astronomy (Astropy Collaboration, 2018).
+
+where (Astropy Collaboration, 2018) is a citation to this paper:
+
+  http://adsabs.harvard.edu/abs/2018AJ....156..123T
+
+An earlier paper is also available describing the status of the package at
+the time of v0.2. If you have used Astropy for a long time, you are
+encouraged to acknowledge both papers:
+
+  This research made use of Astropy, a community-developed core Python package
+  for Astronomy (Astropy Collaboration, 2013, 2018).
+
+where (Astropy Collaboration, 2013) is a citation to this paper:
+
+  http://adsabs.harvard.edu/abs/2013A%26A...558A..33A
+
+We encourage you to also include citations to the papers in the main text
+wherever appropriate.
+
+
+Recommended BibTeX entries for the above citations are:
+
+@ARTICLE{2018AJ....156..123T,
+   author = {{The Astropy Collaboration} and {Price-Whelan}, A.~M. and {Sip{\H o}cz}, B.~M. and 
+	{G{\"u}nther}, H.~M. and {Lim}, P.~L. and {Crawford}, S.~M. and 
+	{Conseil}, S. and {Shupe}, D.~L. and {Craig}, M.~W. and {Dencheva}, N. and 
+	{Ginsburg}, A. and {VanderPlas}, J.~T. and {Bradley}, L.~D. and 
+	{P{\'e}rez-Su{\'a}rez}, D. and {de Val-Borro}, M. and {Paper Contributors}, (. and 
+	{Aldcroft}, T.~L. and {Cruz}, K.~L. and {Robitaille}, T.~P. and 
+	{Tollerud}, E.~J. and {Coordination Committee}, (. and {Ardelean}, C. and 
+	{Babej}, T. and {Bach}, Y.~P. and {Bachetti}, M. and {Bakanov}, A.~V. and 
+	{Bamford}, S.~P. and {Barentsen}, G. and {Barmby}, P. and {Baumbach}, A. and 
+	{Berry}, K.~L. and {Biscani}, F. and {Boquien}, M. and {Bostroem}, K.~A. and 
+	{Bouma}, L.~G. and {Brammer}, G.~B. and {Bray}, E.~M. and {Breytenbach}, H. and 
+	{Buddelmeijer}, H. and {Burke}, D.~J. and {Calderone}, G. and 
+	{Cano Rodr{\'{\i}}guez}, J.~L. and {Cara}, M. and {Cardoso}, J.~V.~M. and 
+	{Cheedella}, S. and {Copin}, Y. and {Corrales}, L. and {Crichton}, D. and 
+	{D{\rsquo}Avella}, D. and {Deil}, C. and {Depagne}, {\'E}. and 
+	{Dietrich}, J.~P. and {Donath}, A. and {Droettboom}, M. and 
+	{Earl}, N. and {Erben}, T. and {Fabbro}, S. and {Ferreira}, L.~A. and 
+	{Finethy}, T. and {Fox}, R.~T. and {Garrison}, L.~H. and {Gibbons}, S.~L.~J. and 
+	{Goldstein}, D.~A. and {Gommers}, R. and {Greco}, J.~P. and 
+	{Greenfield}, P. and {Groener}, A.~M. and {Grollier}, F. and 
+	{Hagen}, A. and {Hirst}, P. and {Homeier}, D. and {Horton}, A.~J. and 
+	{Hosseinzadeh}, G. and {Hu}, L. and {Hunkeler}, J.~S. and {Ivezi{\'c}}, {\v Z}. and 
+	{Jain}, A. and {Jenness}, T. and {Kanarek}, G. and {Kendrew}, S. and 
+	{Kern}, N.~S. and {Kerzendorf}, W.~E. and {Khvalko}, A. and 
+	{King}, J. and {Kirkby}, D. and {Kulkarni}, A.~M. and {Kumar}, A. and 
+	{Lee}, A. and {Lenz}, D. and {Littlefair}, S.~P. and {Ma}, Z. and 
+	{Macleod}, D.~M. and {Mastropietro}, M. and {McCully}, C. and 
+	{Montagnac}, S. and {Morris}, B.~M. and {Mueller}, M. and {Mumford}, S.~J. and 
+	{Muna}, D. and {Murphy}, N.~A. and {Nelson}, S. and {Nguyen}, G.~H. and 
+	{Ninan}, J.~P. and {N{\"o}the}, M. and {Ogaz}, S. and {Oh}, S. and 
+	{Parejko}, J.~K. and {Parley}, N. and {Pascual}, S. and {Patil}, R. and 
+	{Patil}, A.~A. and {Plunkett}, A.~L. and {Prochaska}, J.~X. and 
+	{Rastogi}, T. and {Reddy Janga}, V. and {Sabater}, J. and {Sakurikar}, P. and 
+	{Seifert}, M. and {Sherbert}, L.~E. and {Sherwood-Taylor}, H. and 
+	{Shih}, A.~Y. and {Sick}, J. and {Silbiger}, M.~T. and {Singanamalla}, S. and 
+	{Singer}, L.~P. and {Sladen}, P.~H. and {Sooley}, K.~A. and 
+	{Sornarajah}, S. and {Streicher}, O. and {Teuben}, P. and {Thomas}, S.~W. and 
+	{Tremblay}, G.~R. and {Turner}, J.~E.~H. and {Terr{\'o}n}, V. and 
+	{van Kerkwijk}, M.~H. and {de la Vega}, A. and {Watkins}, L.~L. and 
+	{Weaver}, B.~A. and {Whitmore}, J.~B. and {Woillez}, J. and 
+	{Zabalza}, V. and {Contributors}, (.},
+    title = "{The Astropy Project: Building an Open-science Project and Status of the v2.0 Core Package}",
+  journal = {\aj},
+archivePrefix = "arXiv",
+   eprint = {1801.02634},
+ primaryClass = "astro-ph.IM",
+ keywords = {methods: data analysis, methods: miscellaneous, methods: statistical, reference systems },
+     year = 2018,
+    month = sep,
+   volume = 156,
+      eid = {123},
+    pages = {123},
+      doi = {10.3847/1538-3881/aabc4f},
+   adsurl = {http://adsabs.harvard.edu/abs/2018AJ....156..123T},
+  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}
+
+@ARTICLE{2013A&A...558A..33A,
+   author = {{Astropy Collaboration} and {Robitaille}, T.~P. and {Tollerud}, E.~J. and
+    {Greenfield}, P. and {Droettboom}, M. and {Bray}, E. and {Aldcroft}, T. and
+    {Davis}, M. and {Ginsburg}, A. and {Price-Whelan}, A.~M. and
+    {Kerzendorf}, W.~E. and {Conley}, A. and {Crighton}, N. and
+    {Barbary}, K. and {Muna}, D. and {Ferguson}, H. and {Grollier}, F. and
+    {Parikh}, M.~M. and {Nair}, P.~H. and {Unther}, H.~M. and {Deil}, C. and
+    {Woillez}, J. and {Conseil}, S. and {Kramer}, R. and {Turner}, J.~E.~H. and
+    {Singer}, L. and {Fox}, R. and {Weaver}, B.~A. and {Zabalza}, V. and
+    {Edwards}, Z.~I. and {Azalee Bostroem}, K. and {Burke}, D.~J. and
+    {Casey}, A.~R. and {Crawford}, S.~M. and {Dencheva}, N. and
+    {Ely}, J. and {Jenness}, T. and {Labrie}, K. and {Lian Lim}, P. and
+    {Pierfederici}, F. and {Pontzen}, A. and {Ptak}, A. and {Refsdal}, B. and
+    {Servillat}, M. and {Streicher}, O.},
+    title = "{Astropy: A community Python package for astronomy}",
+  journal = {\aap},
+ keywords = {methods: data analysis, methods: miscellaneous, virtual observatory tools},
+     year = 2013,
+    month = oct,
+   volume = 558,
+      eid = {A33},
+    pages = {A33},
+      doi = {10.1051/0004-6361/201322068},
+   adsurl = {http://adsabs.harvard.edu/abs/2013A%26A...558A..33A},
+  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
+}

testbed/astropy__astropy/astropy/__init__.py

@@ -0,0 +1,343 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+Astropy is a package intended to contain core functionality and some
+common tools needed for performing astronomy and astrophysics research with
+Python. It also provides an index for other astronomy packages and tools for
+managing them.
+"""
+
+# Prior to Astropy 3.2, astropy was imported during setup.py commands. If we are
+# in setup mode, then astropy-helpers defines an _ASTROPY_SETUP_ variable, which
+# we used to use to conditionally import C extensions for example. However, the
+# behavior of importing the package during the setup process is not good
+# practice and we therefore now explicitly prevent the package from being
+# imported in that case to prevent any regressions. We use _ASTROPY_CORE_SETUP_
+# (defined in setup.py) rather than _ASTROPY_SETUP_ since the latter is also
+# set up for affiliated packages, and those need to be able to import the
+# (installed) core package during e.g. python setup.py test.
+try:
+    _ASTROPY_CORE_SETUP_
+except NameError:
+    pass
+else:
+    raise RuntimeError("The astropy package cannot be imported during setup")
+
+import sys
+import os
+from warnings import warn
+
+__minimum_python_version__ = '3.5'
+__minimum_numpy_version__ = '1.13.0'
+# ASDF is an optional dependency, but this is the minimum version that is
+# compatible with Astropy when it is installed.
+__minimum_asdf_version__ = '2.3.0'
+
+
+class UnsupportedPythonError(Exception):
+    pass
+
+
+# This is the same check as the one at the top of setup.py
+if sys.version_info < tuple((int(val) for val in __minimum_python_version__.split('.'))):
+    raise UnsupportedPythonError("Astropy does not support Python < {}".format(__minimum_python_version__))
+
+
+def _is_astropy_source(path=None):
+    """
+    Returns whether the source for this module is directly in an astropy
+    source distribution or checkout.
+    """
+
+    # If this __init__.py file is in ./astropy/ then import is within a source
+    # dir .astropy-root is a file distributed with the source, but that should
+    # not installed
+    if path is None:
+        path = os.path.join(os.path.dirname(__file__), os.pardir)
+    elif os.path.isfile(path):
+        path = os.path.dirname(path)
+
+    source_dir = os.path.abspath(path)
+    return os.path.exists(os.path.join(source_dir, '.astropy-root'))
+
+
+def _is_astropy_setup():
+    """
+    Returns whether we are currently being imported in the context of running
+    Astropy's setup.py.
+    """
+
+    main_mod = sys.modules.get('__main__')
+    if not main_mod:
+        return False
+
+    return (getattr(main_mod, '__file__', False) and
+            os.path.basename(main_mod.__file__).rstrip('co') == 'setup.py' and
+            _is_astropy_source(main_mod.__file__))
+
+try:
+    from .version import version as __version__
+except ImportError:
+    # TODO: Issue a warning using the logging framework
+    __version__ = ''
+try:
+    from .version import githash as __githash__
+except ImportError:
+    # TODO: Issue a warning using the logging framework
+    __githash__ = ''
+
+
+# The location of the online documentation for astropy
+# This location will normally point to the current released version of astropy
+if 'dev' in __version__:
+    online_docs_root = 'http://docs.astropy.org/en/latest/'
+else:
+    online_docs_root = 'http://docs.astropy.org/en/{0}/'.format(__version__)
+
+
+def _check_numpy():
+    """
+    Check that Numpy is installed and it is of the minimum version we
+    require.
+    """
+    # Note: We could have used distutils.version for this comparison,
+    # but it seems like overkill to import distutils at runtime.
+    requirement_met = False
+
+    try:
+        import numpy
+    except ImportError:
+        pass
+    else:
+        from .utils import minversion
+        requirement_met = minversion(numpy, __minimum_numpy_version__)
+
+    if not requirement_met:
+        msg = ("Numpy version {0} or later must be installed to use "
+               "Astropy".format(__minimum_numpy_version__))
+        raise ImportError(msg)
+
+    return numpy
+
+
+_check_numpy()
+
+
+from . import config as _config
+
+
+class Conf(_config.ConfigNamespace):
+    """
+    Configuration parameters for `astropy`.
+    """
+
+    unicode_output = _config.ConfigItem(
+        False,
+        'When True, use Unicode characters when outputting values, and '
+        'displaying widgets at the console.')
+    use_color = _config.ConfigItem(
+        sys.platform != 'win32',
+        'When True, use ANSI color escape sequences when writing to the console.',
+        aliases=['astropy.utils.console.USE_COLOR', 'astropy.logger.USE_COLOR'])
+    max_lines = _config.ConfigItem(
+        None,
+        description='Maximum number of lines in the display of pretty-printed '
+        'objects. If not provided, try to determine automatically from the '
+        'terminal size.  Negative numbers mean no limit.',
+        cfgtype='integer(default=None)',
+        aliases=['astropy.table.pprint.max_lines'])
+    max_width = _config.ConfigItem(
+        None,
+        description='Maximum number of characters per line in the display of '
+        'pretty-printed objects.  If not provided, try to determine '
+        'automatically from the terminal size. Negative numbers mean no '
+        'limit.',
+        cfgtype='integer(default=None)',
+        aliases=['astropy.table.pprint.max_width'])
+
+
+conf = Conf()
+
+# Create the test() function
+from .tests.runner import TestRunner
+test = TestRunner.make_test_runner_in(__path__[0])
+
+
+# if we are *not* in setup mode, import the logger and possibly populate the
+# configuration file with the defaults
+def _initialize_astropy():
+    from . import config
+
+    def _rollback_import(message):
+        log.error(message)
+        # Now disable exception logging to avoid an annoying error in the
+        # exception logger before we raise the import error:
+        _teardown_log()
+
+        # Roll back any astropy sub-modules that have been imported thus
+        # far
+
+        for key in list(sys.modules):
+            if key.startswith('astropy.'):
+                del sys.modules[key]
+        raise ImportError('astropy')
+
+    try:
+        from .utils import _compiler
+    except ImportError:
+        if _is_astropy_source():
+            log.warning('You appear to be trying to import astropy from '
+                        'within a source checkout without building the '
+                        'extension modules first.  Attempting to (re)build '
+                        'extension modules:')
+
+            try:
+                _rebuild_extensions()
+            except BaseException as exc:
+                _rollback_import(
+                    'An error occurred while attempting to rebuild the '
+                    'extension modules.  Please try manually running '
+                    '`./setup.py develop` or `./setup.py build_ext '
+                    '--inplace` to see what the issue was.  Extension '
+                    'modules must be successfully compiled and importable '
+                    'in order to import astropy.')
+                # Reraise the Exception only in case it wasn't an Exception,
+                # for example if a "SystemExit" or "KeyboardInterrupt" was
+                # invoked.
+                if not isinstance(exc, Exception):
+                    raise
+
+        else:
+            # Outright broken installation; don't be nice.
+            raise
+
+    # add these here so we only need to cleanup the namespace at the end
+    config_dir = os.path.dirname(__file__)
+
+    try:
+        config.configuration.update_default_config(__package__, config_dir)
+    except config.configuration.ConfigurationDefaultMissingError as e:
+        wmsg = (e.args[0] + " Cannot install default profile. If you are "
+                "importing from source, this is expected.")
+        warn(config.configuration.ConfigurationDefaultMissingWarning(wmsg))
+
+
+def _rebuild_extensions():
+    global __version__
+    global __githash__
+
+    import subprocess
+    import time
+
+    from .utils.console import Spinner
+
+    devnull = open(os.devnull, 'w')
+    old_cwd = os.getcwd()
+    os.chdir(os.path.join(os.path.dirname(__file__), os.pardir))
+    try:
+        sp = subprocess.Popen([sys.executable, 'setup.py', 'build_ext',
+                               '--inplace'], stdout=devnull,
+                               stderr=devnull)
+        with Spinner('Rebuilding extension modules') as spinner:
+            while sp.poll() is None:
+                next(spinner)
+                time.sleep(0.05)
+    finally:
+        os.chdir(old_cwd)
+        devnull.close()
+
+    if sp.returncode != 0:
+        raise OSError('Running setup.py build_ext --inplace failed '
+                      'with error code {0}: try rerunning this command '
+                      'manually to check what the error was.'.format(
+                          sp.returncode))
+
+    # Try re-loading module-level globals from the astropy.version module,
+    # which may not have existed before this function ran
+    try:
+        from .version import version as __version__
+    except ImportError:
+        pass
+
+    try:
+        from .version import githash as __githash__
+    except ImportError:
+        pass
+
+
+# Set the bibtex entry to the article referenced in CITATION.
+def _get_bibtex():
+    citation_file = os.path.join(os.path.dirname(__file__), 'CITATION')
+
+    with open(citation_file, 'r') as citation:
+        refs = citation.read().split('@ARTICLE')[1:]
+        if len(refs) == 0: return ''
+        bibtexreference = "@ARTICLE{0}".format(refs[0])
+    return bibtexreference
+
+
+__citation__ = __bibtex__ = _get_bibtex()
+
+import logging
+
+# Use the root logger as a dummy log before initilizing Astropy's logger
+log = logging.getLogger()
+
+
+from .logger import _init_log, _teardown_log
+
+log = _init_log()
+
+_initialize_astropy()
+
+from .utils.misc import find_api_page
+
+
+def online_help(query):
+    """
+    Search the online Astropy documentation for the given query.
+    Opens the results in the default web browser.  Requires an active
+    Internet connection.
+
+    Parameters
+    ----------
+    query : str
+        The search query.
+    """
+    from urllib.parse import urlencode
+    import webbrowser
+
+    version = __version__
+    if 'dev' in version:
+        version = 'latest'
+    else:
+        version = 'v' + version
+
+    url = 'http://docs.astropy.org/en/{0}/search.html?{1}'.format(
+        version, urlencode({'q': query}))
+
+    webbrowser.open(url)
+
+
+__dir_inc__ = ['__version__', '__githash__', '__minimum_numpy_version__',
+               '__bibtex__', 'test', 'log', 'find_api_page', 'online_help',
+               'online_docs_root', 'conf']
+
+
+from types import ModuleType as __module_type__
+# Clean up top-level namespace--delete everything that isn't in __dir_inc__
+# or is a magic attribute, and that isn't a submodule of this package
+for varname in dir():
+    if not ((varname.startswith('__') and varname.endswith('__')) or
+            varname in __dir_inc__ or
+            (varname[0] != '_' and
+                isinstance(locals()[varname], __module_type__) and
+                locals()[varname].__name__.startswith(__name__ + '.'))):
+        # The last clause in the the above disjunction deserves explanation:
+        # When using relative imports like ``from .. import config``, the
+        # ``config`` variable is automatically created in the namespace of
+        # whatever module ``..`` resolves to (in this case astropy).  This
+        # happens a few times just in the module setup above.  This allows
+        # the cleanup to keep any public submodules of the astropy package
+        del locals()[varname]
+
+del varname, __module_type__

testbed/astropy__astropy/astropy/_erfa/__init__.py

@@ -0,0 +1,3 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from .core import *

testbed/astropy__astropy/astropy/_erfa/core.py.templ

@@ -0,0 +1,313 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+# "core.py" is auto-generated by erfa_generator.py from the template
+# "core.py.templ". Do *not* edit "core.py" directly, instead edit
+# "core.py.templ" and run erfa_generator.py from the source directory to
+# update it.
+
+"""
+Python wrappers for the ufunc wrappers of the ERFA library.
+
+..warning::
+    This is currently *not* part of the public Astropy API, and may change in
+    the future.
+
+The key idea is that any function can be called with inputs that are arrays,
+and the ufuncs will automatically vectorize and call the ERFA functions for
+each item using broadcasting rules for numpy.  So the return values are always
+numpy arrays of some sort.
+
+For ERFA functions that take/return vectors or matrices, the vector/matrix
+dimension(s) are always the *last* dimension(s).  For example, if you
+want to give ten matrices (i.e., the ERFA input type is double[3][3]),
+you would pass in a (10, 3, 3) numpy array.  If the output of the ERFA
+function is scalar, you'll get back a length-10 1D array.
+(Note that the ufuncs take this into account using structured dtypes.)
+
+Note that the ufunc part of these functions are implemented in a separate
+module (compiled as ``ufunc``), derived from the ``ufunc.c`` file.
+"""
+
+import warnings
+
+import numpy
+
+# we import these exceptions from astropy locations instead of defining them
+# in this file because otherwise there are circular dependencies
+from astropy.utils.exceptions import ErfaError, ErfaWarning
+from astropy.utils.misc import check_broadcast
+
+from . import ufunc
+from .ufunc import (dt_eraASTROM, dt_eraLDBODY, dt_pv,
+                    dt_sign, dt_type, dt_ymdf, dt_hmsf, dt_dmsf)
+
+__all__ = ['ErfaError', 'ErfaWarning',
+           {{ funcs|map(attribute='pyname')|surround("'","'")|join(", ") }},
+           {{ constants|map(attribute='name')|surround("'","'")|join(", ") }},
+           # TODO: delete the functions below when they can get auto-generated
+           'version', 'version_major', 'version_minor', 'version_micro', 'sofa_version',
+           'dt_eraASTROM', 'dt_eraLDBODY', 'dt_pv', 'dt_ymdf', 'dt_hmsf', 'dt_dmsf']
+
+
+# <---------------------------------Error-handling---------------------------->
+
+
+STATUS_CODES = {}  # populated below before each function that returns an int
+
+# This is a hard-coded list of status codes that need to be remapped,
+# such as to turn errors into warnings.
+STATUS_CODES_REMAP = {
+    'cal2jd': {-3: 3}
+}
+
+
+def check_errwarn(statcodes, func_name):
+    if not numpy.any(statcodes):
+        return
+    # Remap any errors into warnings in the STATUS_CODES_REMAP dict.
+    if func_name in STATUS_CODES_REMAP:
+        for before, after in STATUS_CODES_REMAP[func_name].items():
+            statcodes[statcodes == before] = after
+            STATUS_CODES[func_name][after] = STATUS_CODES[func_name][before]
+
+    if numpy.any(statcodes<0):
+        # errors present - only report the errors.
+        if statcodes.shape:
+            statcodes = statcodes[statcodes<0]
+
+        errcodes = numpy.unique(statcodes)
+
+        errcounts = dict([(e, numpy.sum(statcodes==e)) for e in errcodes])
+
+        elsemsg = STATUS_CODES[func_name].get('else', None)
+        if elsemsg is None:
+            errmsgs = dict([(e, STATUS_CODES[func_name].get(e, 'Return code ' + str(e))) for e in errcodes])
+        else:
+            errmsgs = dict([(e, STATUS_CODES[func_name].get(e, elsemsg)) for e in errcodes])
+
+        emsg = ', '.join(['{0} of "{1}"'.format(errcounts[e], errmsgs[e]) for e in errcodes])
+        raise ErfaError('ERFA function "' + func_name + '" yielded ' + emsg)
+
+    elif numpy.any(statcodes>0):
+        #only warnings present
+        if statcodes.shape:
+            statcodes = statcodes[statcodes>0]
+
+        warncodes = numpy.unique(statcodes)
+
+        warncounts = dict([(w, numpy.sum(statcodes==w)) for w in warncodes])
+
+        elsemsg = STATUS_CODES[func_name].get('else', None)
+        if elsemsg is None:
+            warnmsgs = dict([(w, STATUS_CODES[func_name].get(w, 'Return code ' + str(w))) for w in warncodes])
+        else:
+            warnmsgs = dict([(w, STATUS_CODES[func_name].get(w, elsemsg)) for w in warncodes])
+
+        wmsg = ', '.join(['{0} of "{1}"'.format(warncounts[w], warnmsgs[w]) for w in warncodes])
+        warnings.warn('ERFA function "' + func_name + '" yielded ' + wmsg, ErfaWarning)
+
+
+# <------------------------structured dtype conversion------------------------>
+
+{%- if NUMPY_LT_1_16 %}
+# Note: the following are only necessary for NUMPY_LT_1_16.  Once we support
+# only numpy >=1.16, they can be removed, and the template code below should be
+# adapted.  Note that for >=1.16, these are not used, since the template parts
+# that use it are never inserted (since `d3_fix_arg` is always empty).
+class D3Fix(numpy.ndarray):
+    """NDarray subclass that can transfer itself into a Quantity.
+
+    For the rationale for this, see arrayify_inputs_and_create_d3_fix.
+    """
+    def __quantity_subclass__(self, unit):
+        return type(self), True
+
+    def __array_wrap__(self, obj, context):
+        return obj.view(numpy.ndarray)
+
+
+def arrayify_inputs_and_create_d3_fix(inputs, core_dims, out_core_shape, out_dtype):
+    """Create an empty array of the right trailing shape.
+
+    Gufuncs currently do not allow one to pass in fixed dimensions, which
+    means that for functions with signatures like `()->(n)`, one has to pass in
+    an output argument for the gufunc to determine `n` (to be 3 for instance).
+
+    For those gufuncs, this functions creates the output array upfront,
+    with properly broadcast dimensions.
+
+    A problem that arises, though, is that if anything overrides the function
+    using ``__array_ufunc__``, it will fail because the output is of the wrong
+    class.  To work around this for `~astropy.units.Quantity` at least, we
+    create the output with a special class (``D3Fix``), which has an
+    ``__array_wrap__`` that will turn it into a regular ndarray for normal
+    usage, and a ``__quantity_subclass__`` that allows it to be replaced by a
+    `~astropy.units.Quantity`.
+
+    Obviously, this is a hack, and only works easily for Quantity (which,
+    however, is the only class likely to use this private implementation).  As
+    an alternative, one could create a regular empty ndarray and then remove
+    it in the C type resolver, so that a new one with the proper class is
+    created by the iterator.  But that seemed even more fragile.
+
+    Parameters
+    ----------
+    inputs : array-like
+        Input arguments, used to determine the required broadcast shape.
+    core_dims: list of int
+        Number of core dimensions for the inputs; these are removed for
+        calculating the broadcast shape.
+    out_core_shape : tuple
+        Output core shape; the full shape will be the broadcast shape
+        determined from the inputs plus this core shape.
+    out_dtype : `~numpy.dtype`
+        Data type of the array.
+
+    Notes
+    -----
+    Once https://github.com/numpy/numpy/pull/11175 is in, this will no
+    longer be necessary for all but NUMPY_LT_1_16, since we'll be able to just
+    define the signature with explicit numerical dimensions.
+    """
+    shapes = []
+    arrays = []
+    for input, core_dim in zip(inputs, core_dims):
+        try:
+            shape = input.shape
+        except AttributeError:
+            input = numpy.asanyarray(input)
+            shape = input.shape
+        shapes.append(shape[:-core_dim] if core_dim else shape)
+        arrays.append(input)
+
+    broadcast_shape = check_broadcast(*shapes)
+    d3_fix = numpy.empty(broadcast_shape + out_core_shape, out_dtype).view(D3Fix)
+    return arrays, d3_fix
+{%- endif %}
+
+
+dt_bytes1 = numpy.dtype('S1')
+dt_bytes12 = numpy.dtype('S12')
+
+# <--------------------------Actual ERFA-wrapping code------------------------>
+
+{% for constant in constants %}
+{{ constant.name }} = {{ constant.value }}
+"""{{ constant.doc|join(' ') }}"""
+{%- endfor %}
+
+
+{% for func in funcs -%}
+def {{ func.pyname }}({{ func.args_by_inout('in|inout')|map(attribute='name')|join(', ') }}):
+    """
+    Wrapper for ERFA function ``{{ func.name }}``.
+
+    Parameters
+    ----------
+    {%- for arg in func.args_by_inout('in|inout') %}
+    {{ arg.name }} : {{ arg.ctype }} array
+    {%- endfor %}
+
+    Returns
+    -------
+    {%- for arg in func.args_by_inout('inout|out|ret') %}
+    {{ arg.name }} : {{ arg.ctype }} array
+    {%- endfor %}
+
+    Notes
+    -----
+    The ERFA documentation is below.
+
+{{ func.doc }}
+    """
+
+    {#-
+     # Call the ufunc. Note that we pass inout twice, once as input
+     # and once as output, so that changes are done in-place
+     #}
+    {%- if func.d3_fix_arg %}
+    {% if func.args_by_inout('in|inout') -%}
+    ({{ func.args_by_inout('in|inout')|map(attribute='name')|join(', ') }},)
+    {%- else -%}_{%- endif -%}, {{ func.d3_fix_arg.name
+        }} = arrayify_inputs_and_create_d3_fix(
+        [{{ func.args_by_inout('in|inout')|map(attribute='name')|list()|join(', ')
+        }}], core_dims=[{{
+        func.args_by_inout('in|inout')|map(attribute='ndim')|list()|join(', ')
+        }}], out_core_shape={{ func.d3_fix_arg.shape
+        }}, out_dtype=numpy.{{ func.d3_fix_arg.ctype }})
+    {%- endif %}
+    {{ func.python_call }}
+    {#-
+     # Check whether any warnings or errors occurred.
+     #}
+    {%- for arg in func.args_by_inout('stat') %}
+    check_errwarn({{ arg.name }}, '{{ func.pyname }}')
+    {%- endfor %}
+    {#-
+     # Any string outputs will be in structs; view them as their base type.
+     #}
+    {%- for arg in func.args_by_inout('out') -%}
+    {%- if 'char' in arg.ctype %}
+    {{ arg.name }} = {{ arg.name }}.view({{ arg.view_dtype }})
+    {%- endif %}
+    {%- endfor %}
+    {#-
+     # Return the output arguments (including the inplace ones)
+     #}
+    return {{ func.args_by_inout('inout|out|ret')|map(attribute='name')|join(', ') }}
+
+
+{#
+ # Define the status codes that this function returns.
+ #}
+{%- if func.args_by_inout('stat') -%}
+{%- for stat in func.args_by_inout('stat') -%}
+{%- if stat.doc_info.statuscodes -%}
+STATUS_CODES['{{ func.pyname }}'] = {{ stat.doc_info.statuscodes|string }}
+{% endif %}
+{% endfor %}
+{% endif -%}
+{% endfor -%}
+
+
+# TODO: delete the functions below when they can get auto-generated
+# (current machinery doesn't support returning strings or non-status-codes)
+def version():
+    """
+    Returns the package version
+    as defined in configure.ac
+    in string format
+    """
+    return "1.4.0"
+
+def version_major():
+    """
+    Returns the package major version
+    as defined in configure.ac
+    as integer
+    """
+    return 1
+
+def version_minor():
+    """
+    Returns the package minor version
+    as defined in configure.ac
+    as integer
+    """
+    return 4
+
+def version_micro():
+    """
+    Returns the package micro version
+    as defined in configure.ac
+    as integer
+    """
+    return 0
+
+def sofa_version():
+    """
+    Returns the corresponding SOFA version
+    as defined in configure.ac
+    in string format
+    """
+    return "20170420"

testbed/astropy__astropy/astropy/_erfa/erfa_additions.h

@@ -0,0 +1,21 @@
+#ifndef ERFAADDITIONSDEF
+#define ERFAADDITIONSDEF
+
+/*
+**  - - - - - - - - - - - - - - - - -
+**   e r f a _ a d d i t i o n s . h
+**  - - - - - - - - - - - - - - - - -
+**
+**  A few extra routines which are particularly handy for constructing
+**  pv vectors inside the coordinate transforms.
+**
+**  MHvK proposed these to Catherine Hohenkerk for inclusion in SOFA
+**  on 2018-05-24, with the response suggesting this was reasonable and
+**  might thus be done.
+*/
+
+/* Extra/PVMergeExtract */
+void eraPav2pv(double p[3], double v[3], double pv[2][3]);
+void eraPv2pav(double pv[2][3], double p[3], double v[3]);
+
+#endif

testbed/astropy__astropy/astropy/_erfa/erfa_generator.py

@@ -0,0 +1,740 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+This module's main purpose is to act as a script to create new versions
+of ufunc.c when ERFA is updated (or this generator is enhanced).
+
+`Jinja2 <http://jinja.pocoo.org/>`_ must be installed for this
+module/script to function.
+
+Note that this does *not* currently automate the process of creating structs
+or dtypes for those structs.  They should be added manually in the template file.
+"""
+# note that we do *not* use unicode_literals here, because that makes the
+# generated code's strings have u'' in them on py 2.x
+
+import re
+import os.path
+from collections import OrderedDict
+from distutils.version import LooseVersion
+
+import numpy
+
+# Note: once we support only numpy >=1.16, all things related to "d3_fix"
+# can be removed, here and in the templates (core.py.templ
+
+# NOTE: we define this variable here instead of importing from astropy to
+# ensure that running this script does not require importing astropy.
+NUMPY_LT_1_16 = LooseVersion(numpy.__version__) < '1.16'
+
+
+DEFAULT_ERFA_LOC = os.path.join(os.path.split(__file__)[0],
+                                '../../cextern/erfa')
+DEFAULT_TEMPLATE_LOC = os.path.split(__file__)[0]
+
+NDIMS_REX = re.compile(re.escape("numpy.dtype([('fi0', '.*', <(.*)>)])").replace(r'\.\*', '.*').replace(r'\<', '(').replace(r'\>', ')'))
+
+
+class FunctionDoc:
+
+    def __init__(self, doc):
+        self.doc = doc.replace("**", "  ").replace("/*\n", "").replace("*/", "")
+        self.__input = None
+        self.__output = None
+        self.__ret_info = None
+
+    def _get_arg_doc_list(self, doc_lines):
+        """Parse input/output doc section lines, getting arguments from them.
+
+        Ensure all elements of eraASTROM and eraLDBODY are left out, as those
+        are not input or output arguments themselves.  Also remove the nb
+        argument in from of eraLDBODY, as we infer nb from the python array.
+        """
+        doc_list = []
+        skip = []
+        for d in doc_lines:
+            arg_doc = ArgumentDoc(d)
+            if arg_doc.name is not None:
+                if skip:
+                    if skip[0] == arg_doc.name:
+                        skip.pop(0)
+                        continue
+                    else:
+                        raise RuntimeError("We whould be skipping {} "
+                                           "but {} encountered."
+                                           .format(skip[0], arg_doc.name))
+
+                if arg_doc.type.startswith('eraLDBODY'):
+                    # Special-case LDBODY: for those, the previous argument
+                    # is always the number of bodies, but we don't need it
+                    # as an input argument for the ufunc since we're going
+                    # to determine this from the array itself. Also skip
+                    # the description of its contents; those are not arguments.
+                    doc_list.pop()
+                    skip = ['bm', 'dl', 'pv']
+                elif arg_doc.type.startswith('eraASTROM'):
+                    # Special-case ASTROM: need to skip the description
+                    # of its contents; those are not arguments.
+                    skip = ['pmt', 'eb', 'eh', 'em', 'v', 'bm1',
+                            'bpn', 'along', 'xpl', 'ypl', 'sphi',
+                            'cphi', 'diurab', 'eral', 'refa', 'refb']
+
+                doc_list.append(arg_doc)
+
+        return doc_list
+
+    @property
+    def input(self):
+        if self.__input is None:
+            self.__input = []
+            for regex in ("Given([^\n]*):\n(.+?)  \n",
+                          "Given and returned([^\n]*):\n(.+?)  \n"):
+                result = re.search(regex, self.doc, re.DOTALL)
+                if result is not None:
+                    doc_lines = result.group(2).split("\n")
+                    self.__input += self._get_arg_doc_list(doc_lines)
+
+        return self.__input
+
+    @property
+    def output(self):
+        if self.__output is None:
+            self.__output = []
+            for regex in ("Given and returned([^\n]*):\n(.+?)  \n",
+                          "Returned([^\n]*):\n(.+?)  \n"):
+                result = re.search(regex, self.doc, re.DOTALL)
+                if result is not None:
+                    doc_lines = result.group(2).split("\n")
+                    self.__output += self._get_arg_doc_list(doc_lines)
+
+        return self.__output
+
+    @property
+    def ret_info(self):
+        if self.__ret_info is None:
+            ret_info = []
+            result = re.search("Returned \\(function value\\)([^\n]*):\n(.+?)  \n", self.doc, re.DOTALL)
+            if result is not None:
+                ret_info.append(ReturnDoc(result.group(2)))
+
+            if len(ret_info) == 0:
+                self.__ret_info = ''
+            elif len(ret_info) == 1:
+                self.__ret_info = ret_info[0]
+            else:
+                raise ValueError("Multiple C return sections found in this doc:\n" + self.doc)
+
+        return self.__ret_info
+
+    def __repr__(self):
+        return self.doc.replace("  \n", "\n")
+
+
+class ArgumentDoc:
+
+    def __init__(self, doc):
+        match = re.search("^ +([^ ]+)[ ]+([^ ]+)[ ]+(.+)", doc)
+        if match is not None:
+            self.name = match.group(1)
+            self.type = match.group(2)
+            self.doc = match.group(3)
+        else:
+            self.name = None
+            self.type = None
+            self.doc = None
+
+    def __repr__(self):
+        return "    {0:15} {1:15} {2}".format(self.name, self.type, self.doc)
+
+
+class Variable:
+    """Properties shared by Argument and Return."""
+    @property
+    def npy_type(self):
+        """Predefined type used by numpy ufuncs to indicate a given ctype.
+
+        Eg., NPY_DOUBLE for double.
+        """
+        return "NPY_" + self.ctype.upper()
+
+    @property
+    def dtype(self):
+        """Name of dtype corresponding to the ctype.
+
+        Specifically,
+        double : dt_double
+        int : dt_int
+        double[3]: dt_vector
+        double[2][3] : dt_pv
+        double[2] : dt_pvdpv
+        double[3][3] : dt_matrix
+        int[4] : dt_ymdf | dt_hmsf | dt_dmsf, depding on name
+        eraASTROM: dt_eraASTROM
+        eraLDBODY: dt_eraLDBODY
+        char : dt_sign
+        char[] : dt_type
+
+        The corresponding dtypes are defined in ufunc.c, where they are
+        used for the loop definitions.  In core.py, they are also used
+        to view-cast regular arrays to these structured dtypes.
+        """
+        if self.ctype == 'const char':
+            return 'dt_type'
+        elif self.ctype == 'char':
+            return 'dt_sign'
+        elif self.ctype == 'int' and self.shape == (4,):
+            return 'dt_' + self.name[1:]
+        elif self.ctype == 'double' and self.shape == (3,):
+            return 'dt_double'
+        elif self.ctype == 'double' and self.shape == (2, 3):
+            return 'dt_pv'
+        elif self.ctype == 'double' and self.shape == (2,):
+            return 'dt_pvdpv'
+        elif self.ctype == 'double' and self.shape == (3, 3):
+            return 'dt_double'
+        elif not self.shape:
+            return 'dt_' + self.ctype
+        else:
+            raise ValueError("ctype {} with shape {} not recognized."
+                             .format(self.ctype, self.shape))
+
+    @property
+    def view_dtype(self):
+        """Name of dtype corresponding to the ctype for viewing back as array.
+
+        E.g., dt_double for double, dt_double33 for double[3][3].
+
+        The types are defined in core.py, where they are used for view-casts
+        of structured results as regular arrays.
+        """
+        if self.ctype == 'const char':
+            return 'dt_bytes12'
+        elif self.ctype == 'char':
+            return 'dt_bytes1'
+        else:
+            raise ValueError('Only char ctype should need view back!')
+
+    @property
+    def ndim(self):
+        return len(self.shape)
+
+    @property
+    def size(self):
+        size = 1
+        for s in self.shape:
+            size *= s
+        return size
+
+    @property
+    def cshape(self):
+        return ''.join(['[{0}]'.format(s) for s in self.shape])
+
+    @property
+    def signature_shape(self):
+        if self.ctype == 'eraLDBODY':
+            return '(n)'
+        elif self.ctype == 'double' and self.shape == (3,):
+            return '(d3)' if NUMPY_LT_1_16 else '(3)'
+        elif self.ctype == 'double' and self.shape == (3, 3):
+            return '(d3, d3)' if NUMPY_LT_1_16 else '(3, 3)'
+        else:
+            return '()'
+
+
+class Argument(Variable):
+
+    def __init__(self, definition, doc):
+        self.definition = definition
+        self.doc = doc
+        self.__inout_state = None
+        self.ctype, ptr_name_arr = definition.strip().rsplit(" ", 1)
+        if "*" == ptr_name_arr[0]:
+            self.is_ptr = True
+            name_arr = ptr_name_arr[1:]
+        else:
+            self.is_ptr = False
+            name_arr = ptr_name_arr
+        if "[]" in ptr_name_arr:
+            self.is_ptr = True
+            name_arr = name_arr[:-2]
+        if "[" in name_arr:
+            self.name, arr = name_arr.split("[", 1)
+            self.shape = tuple([int(size) for size in arr[:-1].split("][")])
+        else:
+            self.name = name_arr
+            self.shape = ()
+
+    @property
+    def inout_state(self):
+        if self.__inout_state is None:
+            self.__inout_state = ''
+            for i in self.doc.input:
+                if self.name in i.name.split(','):
+                    self.__inout_state = 'in'
+            for o in self.doc.output:
+                if self.name in o.name.split(','):
+                    if self.__inout_state == 'in':
+                        self.__inout_state = 'inout'
+                    else:
+                        self.__inout_state = 'out'
+        return self.__inout_state
+
+    @property
+    def name_for_call(self):
+        """How the argument should be used in the call to the ERFA function.
+
+        This takes care of ensuring that inputs are passed by value,
+        as well as adding back the number of bodies for any LDBODY argument.
+        The latter presumes that in the ufunc inner loops, that number is
+        called 'nb'.
+        """
+        if self.ctype == 'eraLDBODY':
+            assert self.name == 'b'
+            return 'nb, _' + self.name
+        elif self.is_ptr:
+            return '_'+self.name
+        else:
+            return '*_'+self.name
+
+    def __repr__(self):
+        return "Argument('{0}', name='{1}', ctype='{2}', inout_state='{3}')".format(self.definition, self.name, self.ctype, self.inout_state)
+
+
+class ReturnDoc:
+
+    def __init__(self, doc):
+        self.doc = doc
+
+        self.infoline = doc.split('\n')[0].strip()
+        self.type = self.infoline.split()[0]
+        self.descr = self.infoline.split()[1]
+
+        if self.descr.startswith('status'):
+            self.statuscodes = statuscodes = {}
+
+            code = None
+            for line in doc[doc.index(':')+1:].split('\n'):
+                ls = line.strip()
+                if ls != '':
+                    if ' = ' in ls:
+                        code, msg = ls.split(' = ')
+                        if code != 'else':
+                            code = int(code)
+                        statuscodes[code] = msg
+                    elif code is not None:
+                        statuscodes[code] += ls
+        else:
+            self.statuscodes = None
+
+    def __repr__(self):
+        return "Return value, type={0:15}, {1}, {2}".format(self.type, self.descr, self.doc)
+
+
+class Return(Variable):
+
+    def __init__(self, ctype, doc):
+        self.name = 'c_retval'
+        self.inout_state = 'stat' if ctype == 'int' else 'ret'
+        self.ctype = ctype
+        self.shape = ()
+        self.doc = doc
+
+    def __repr__(self):
+        return "Return(name='{0}', ctype='{1}', inout_state='{2}')".format(self.name, self.ctype, self.inout_state)
+
+    @property
+    def doc_info(self):
+        return self.doc.ret_info
+
+
+class Function:
+    """
+    A class representing a C function.
+
+    Parameters
+    ----------
+    name : str
+        The name of the function
+    source_path : str
+        Either a directory, which means look for the function in a
+        stand-alone file (like for the standard ERFA distribution), or a
+        file, which means look for the function in that file (as for the
+        astropy-packaged single-file erfa.c).
+    match_line : str, optional
+        If given, searching of the source file will skip until it finds
+        a line matching this string, and start from there.
+    """
+
+    def __init__(self, name, source_path, match_line=None):
+        self.name = name
+        self.pyname = name.split('era')[-1].lower()
+        self.filename = self.pyname+".c"
+        if os.path.isdir(source_path):
+            self.filepath = os.path.join(os.path.normpath(source_path), self.filename)
+        else:
+            self.filepath = source_path
+
+        with open(self.filepath) as f:
+            if match_line:
+                line = f.readline()
+                while line != '':
+                    if line.startswith(match_line):
+                        filecontents = '\n' + line + f.read()
+                        break
+                    line = f.readline()
+                else:
+                    msg = ('Could not find the match_line "{0}" in '
+                           'the source file "{1}"')
+                    raise ValueError(msg.format(match_line, self.filepath))
+            else:
+                filecontents = f.read()
+
+        pattern = r"\n([^\n]+{0} ?\([^)]+\)).+?(/\*.+?\*/)".format(name)
+        p = re.compile(pattern, flags=re.DOTALL | re.MULTILINE)
+
+        search = p.search(filecontents)
+        self.cfunc = " ".join(search.group(1).split())
+        self.doc = FunctionDoc(search.group(2))
+
+        self.args = []
+        for arg in re.search(r"\(([^)]+)\)", self.cfunc).group(1).split(', '):
+            self.args.append(Argument(arg, self.doc))
+        self.ret = re.search("^(.*){0}".format(name), self.cfunc).group(1).strip()
+        if self.ret != 'void':
+            self.args.append(Return(self.ret, self.doc))
+
+    def args_by_inout(self, inout_filter, prop=None, join=None):
+        """
+        Gives all of the arguments and/or returned values, depending on whether
+        they are inputs, outputs, etc.
+
+        The value for `inout_filter` should be a string containing anything
+        that arguments' `inout_state` attribute produces.  Currently, that can be:
+
+          * "in" : input
+          * "out" : output
+          * "inout" : something that's could be input or output (e.g. a struct)
+          * "ret" : the return value of the C function
+          * "stat" : the return value of the C function if it is a status code
+
+        It can also be a "|"-separated string giving inout states to OR
+        together.
+        """
+        result = []
+        for arg in self.args:
+            if arg.inout_state in inout_filter.split('|'):
+                if prop is None:
+                    result.append(arg)
+                else:
+                    result.append(getattr(arg, prop))
+        if join is not None:
+            return join.join(result)
+        else:
+            return result
+
+    @property
+    def user_dtype(self):
+        """The non-standard dtype, if any, needed by this function's ufunc.
+
+        This would be any structured array for any input or output, but
+        we give preference to LDBODY, since that also decides that the ufunc
+        should be a generalized ufunc.
+        """
+        user_dtype = None
+        for arg in self.args_by_inout('in|inout|out'):
+            if arg.ctype == 'eraLDBODY':
+                return arg.dtype
+            elif user_dtype is None and arg.dtype not in ('dt_double',
+                                                          'dt_int'):
+                user_dtype = arg.dtype
+
+        return user_dtype
+
+    @property
+    def signature(self):
+        """Possible signature, if this function should be a gufunc."""
+        if all(arg.signature_shape == '()'
+               for arg in self.args_by_inout('in|inout|out')):
+            return None
+
+        return '->'.join(
+            [','.join([arg.signature_shape for arg in args])
+             for args in (self.args_by_inout('in|inout'),
+                          self.args_by_inout('inout|out|ret|stat'))])
+
+    def _d3_fix_arg_and_index(self):
+        if not any('d3' in arg.signature_shape
+                   for arg in self.args_by_inout('in|inout')):
+            for j, arg in enumerate(self.args_by_inout('out')):
+                if 'd3' in arg.signature_shape:
+                    return j, arg
+
+        return None, None
+
+    @property
+    def d3_fix_op_index(self):
+        """Whether only output arguments have a d3 dimension."""
+        index = self._d3_fix_arg_and_index()[0]
+        if index is not None:
+            len_in = len(list(self.args_by_inout('in')))
+            len_inout = len(list(self.args_by_inout('inout')))
+            index += + len_in + 2 * len_inout
+        return index
+
+    @property
+    def d3_fix_arg(self):
+        """Whether only output arguments have a d3 dimension."""
+        return self._d3_fix_arg_and_index()[1]
+
+    @property
+    def python_call(self):
+        outnames = [arg.name for arg in self.args_by_inout('inout|out|stat|ret')]
+        argnames = [arg.name for arg in self.args_by_inout('in|inout')]
+        argnames += [arg.name for arg in self.args_by_inout('inout')]
+        d3fix_index = self._d3_fix_arg_and_index()[0]
+        if d3fix_index is not None:
+            argnames += ['None'] * d3fix_index + [self.d3_fix_arg.name]
+        return '{out} = {func}({args})'.format(out=', '.join(outnames),
+                                               func='ufunc.' + self.pyname,
+                                               args=', '.join(argnames))
+
+    def __repr__(self):
+        return "Function(name='{0}', pyname='{1}', filename='{2}', filepath='{3}')".format(self.name, self.pyname, self.filename, self.filepath)
+
+
+
+class Constant:
+
+    def __init__(self, name, value, doc):
+        self.name = name.replace("ERFA_", "")
+        self.value = value.replace("ERFA_", "")
+        self.doc = doc
+
+
+class ExtraFunction(Function):
+    """
+    An "extra" function - e.g. one not following the SOFA/ERFA standard format.
+
+    Parameters
+    ----------
+    cname : str
+        The name of the function in C
+    prototype : str
+        The prototype for the function (usually derived from the header)
+    pathfordoc : str
+        The path to a file that contains the prototype, with the documentation
+        as a multiline string *before* it.
+    """
+
+    def __init__(self, cname, prototype, pathfordoc):
+        self.name = cname
+        self.pyname = cname.split('era')[-1].lower()
+        self.filepath, self.filename = os.path.split(pathfordoc)
+
+        self.prototype = prototype.strip()
+        if prototype.endswith('{') or prototype.endswith(';'):
+            self.prototype = prototype[:-1].strip()
+
+        incomment = False
+        lastcomment = None
+        with open(pathfordoc, 'r') as f:
+            for l in f:
+                if incomment:
+                    if l.lstrip().startswith('*/'):
+                        incomment = False
+                        lastcomment = ''.join(lastcomment)
+                    else:
+                        if l.startswith('**'):
+                            l = l[2:]
+                        lastcomment.append(l)
+                else:
+                    if l.lstrip().startswith('/*'):
+                        incomment = True
+                        lastcomment = []
+                    if l.startswith(self.prototype):
+                        self.doc = lastcomment
+                        break
+            else:
+                raise ValueError('Did not find prototype {} in file '
+                                 '{}'.format(self.prototype, pathfordoc))
+
+        self.args = []
+        argset = re.search(r"{0}\(([^)]+)?\)".format(self.name),
+                           self.prototype).group(1)
+        if argset is not None:
+            for arg in argset.split(', '):
+                self.args.append(Argument(arg, self.doc))
+        self.ret = re.match("^(.*){0}".format(self.name),
+                            self.prototype).group(1).strip()
+        if self.ret != 'void':
+            self.args.append(Return(self.ret, self.doc))
+
+    def __repr__(self):
+        r = super().__repr__()
+        if r.startswith('Function'):
+            r = 'Extra' + r
+        return r
+
+
+def main(srcdir=DEFAULT_ERFA_LOC, outfn='core.py', ufuncfn='ufunc.c',
+         templateloc=DEFAULT_TEMPLATE_LOC, extra='erfa_additions.h',
+         verbose=True):
+    from jinja2 import Environment, FileSystemLoader
+
+    if verbose:
+        print_ = lambda *args, **kwargs: print(*args, **kwargs)
+    else:
+        print_ = lambda *args, **kwargs: None
+
+    # Prepare the jinja2 templating environment
+    env = Environment(loader=FileSystemLoader(templateloc))
+
+    def prefix(a_list, pre):
+        return [pre+'{0}'.format(an_element) for an_element in a_list]
+
+    def postfix(a_list, post):
+        return ['{0}'.format(an_element)+post for an_element in a_list]
+
+    def surround(a_list, pre, post):
+        return [pre+'{0}'.format(an_element)+post for an_element in a_list]
+    env.filters['prefix'] = prefix
+    env.filters['postfix'] = postfix
+    env.filters['surround'] = surround
+
+    erfa_c_in = env.get_template(ufuncfn + '.templ')
+    erfa_py_in = env.get_template(outfn + '.templ')
+
+    # Extract all the ERFA function names from erfa.h
+    if os.path.isdir(srcdir):
+        erfahfn = os.path.join(srcdir, 'erfa.h')
+        multifilserc = True
+    else:
+        erfahfn = os.path.join(os.path.split(srcdir)[0], 'erfa.h')
+        multifilserc = False
+
+    with open(erfahfn, "r") as f:
+        erfa_h = f.read()
+        print_("read erfa header")
+    if extra:
+        with open(os.path.join(templateloc or '.', extra), "r") as f:
+            erfa_h += f.read()
+        print_("read extra header")
+
+    funcs = OrderedDict()
+    section_subsection_functions = re.findall(
+        r'/\* (\w*)/(\w*) \*/\n(.*?)\n\n', erfa_h,
+        flags=re.DOTALL | re.MULTILINE)
+    for section, subsection, functions in section_subsection_functions:
+        print_("{0}.{1}".format(section, subsection))
+        # Right now, we compile everything, but one could be more selective.
+        # In particular, at the time of writing (2018-06-11), what was
+        # actually require for astropy was not quite everything, but:
+        # ((section == 'Extra')
+        #       or (section == "Astronomy")
+        #       or (subsection == "AngleOps")
+        #       or (subsection == "SphericalCartesian")
+        #       or (subsection == "MatrixVectorProducts")
+        #       or (subsection == 'VectorOps'))
+        if True:
+
+            func_names = re.findall(r' (\w+)\(.*?\);', functions,
+                                    flags=re.DOTALL)
+            for name in func_names:
+                print_("{0}.{1}.{2}...".format(section, subsection, name))
+                if multifilserc:
+                    # easy because it just looks in the file itself
+                    cdir = (srcdir if section != 'Extra' else
+                            templateloc or '.')
+                    funcs[name] = Function(name, cdir)
+                else:
+                    # Have to tell it to look for a declaration matching
+                    # the start of the header declaration, otherwise it
+                    # might find a *call* of the function instead of the
+                    # definition
+                    for line in functions.split(r'\n'):
+                        if name in line:
+                            # [:-1] is to remove trailing semicolon, and
+                            # splitting on '(' is because the header and
+                            # C files don't necessarily have to match
+                            # argument names and line-breaking or
+                            # whitespace
+                            match_line = line[:-1].split('(')[0]
+                            funcs[name] = Function(name, cdir, match_line)
+                            break
+                    else:
+                        raise ValueError("A name for a C file wasn't "
+                                         "found in the string that "
+                                         "spawned it.  This should be "
+                                         "impossible!")
+
+    funcs = funcs.values()
+
+    # Extract all the ERFA constants from erfam.h
+    erfamhfn = os.path.join(srcdir, 'erfam.h')
+    with open(erfamhfn, 'r') as f:
+        erfa_m_h = f.read()
+    constants = []
+    for chunk in erfa_m_h.split("\n\n"):
+        result = re.findall(r"#define (ERFA_\w+?) (.+?)$", chunk,
+                            flags=re.DOTALL | re.MULTILINE)
+        if result:
+            doc = re.findall(r"/\* (.+?) \*/\n", chunk, flags=re.DOTALL)
+            for (name, value) in result:
+                constants.append(Constant(name, value, doc))
+
+    # TODO: re-enable this when const char* return values and
+    #       non-status code integer rets are possible
+    # #Add in any "extra" functions from erfaextra.h
+    # erfaextrahfn = os.path.join(srcdir, 'erfaextra.h')
+    # with open(erfaextrahfn, 'r') as f:
+    #     for l in f:
+    #         ls = l.strip()
+    #         match = re.match('.* (era.*)\(', ls)
+    #         if match:
+    #             print_("Extra:  {0} ...".format(match.group(1)))
+    #             funcs.append(ExtraFunction(match.group(1), ls, erfaextrahfn))
+
+    print_("Rendering template")
+    erfa_c = erfa_c_in.render(funcs=funcs, NUMPY_LT_1_16=NUMPY_LT_1_16)
+    erfa_py = erfa_py_in.render(funcs=funcs, constants=constants,
+                                NUMPY_LT_1_16=NUMPY_LT_1_16)
+
+    if outfn is not None:
+        print_("Saving to", outfn, 'and', ufuncfn)
+        with open(os.path.join(templateloc, outfn), "w") as f:
+            f.write(erfa_py)
+        with open(os.path.join(templateloc, ufuncfn), "w") as f:
+            f.write(erfa_c)
+
+    print_("Done!")
+
+    return erfa_c, erfa_py, funcs
+
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser
+
+    ap = ArgumentParser()
+    ap.add_argument('srcdir', default=DEFAULT_ERFA_LOC, nargs='?',
+                    help='Directory where the ERFA c and header files '
+                         'can be found or to a single erfa.c file '
+                         '(which must be in the same directory as '
+                         'erfa.h). Defaults to the builtin astropy '
+                         'erfa: "{0}"'.format(DEFAULT_ERFA_LOC))
+    ap.add_argument('-o', '--output', default='core.py',
+                    help='The output filename for the pure-python output.')
+    ap.add_argument('-u', '--ufunc', default='ufunc.c',
+                    help='The output filename for the ufunc .c output')
+    ap.add_argument('-t', '--template-loc',
+                    default=DEFAULT_TEMPLATE_LOC,
+                    help='the location where the "core.py.templ" and '
+                         '"ufunc.c.templ templates can be found.')
+    ap.add_argument('-x', '--extra',
+                    default='erfa_additions.h',
+                    help='header file for any extra files in the template '
+                         'location that should be included.')
+    ap.add_argument('-q', '--quiet', action='store_false', dest='verbose',
+                    help='Suppress output normally printed to stdout.')
+
+    args = ap.parse_args()
+    main(args.srcdir, args.output, args.ufunc, args.template_loc,
+         args.extra)

testbed/astropy__astropy/astropy/_erfa/pav2pv.c

@@ -0,0 +1,30 @@
+#include "erfa.h"
+
+void eraPav2pv(double p[3], double v[3], double pv[2][3])
+/*
+**  - - - - - - - - - -
+**   e r a P a v 2 p v
+**  - - - - - - - - - -
+**
+**  Extend a p-vector to a pv-vector by appending a zero velocity.
+**
+**  Given:
+**     p        double[3]       p-vector
+**     v        double[3]       v-vector
+**
+**  Returned:
+**     pv       double[2][3]    pv-vector
+**
+**  Called:
+**     eraCp        copy p-vector
+**
+**  Copyright (C) 2013-2017, NumFOCUS Foundation.
+**  Derived, with permission, from the SOFA library.  See notes at end of file.
+*/
+{
+   eraCp(p, pv[0]);
+   eraCp(v, pv[1]);
+
+   return;
+
+}

testbed/astropy__astropy/astropy/_erfa/pv2pav.c

@@ -0,0 +1,30 @@
+#include "erfa.h"
+
+void eraPv2pav(double pv[2][3], double p[3], double v[3])
+/*
+**  - - - - - - - - -
+**   e r a P v 2 p a v
+**  - - - - - - - - -
+**
+**  Extend a p-vector to a pv-vector by appending a zero velocity.
+**
+**  Given:
+**     pv       double[2][3]    pv-vector
+**
+**  Returned:
+**     p        double[3]       p-vector
+**     v        double[3]       v-vector
+**
+**  Called:
+**     eraCp        copy p-vector
+**
+**  Copyright (C) 2013-2017, NumFOCUS Foundation.
+**  Derived, with permission, from the SOFA library.  See notes at end of file.
+*/
+{
+   eraCp(pv[0], p);
+   eraCp(pv[1], v);
+
+   return;
+
+}

testbed/astropy__astropy/astropy/_erfa/setup_package.py

@@ -0,0 +1,108 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import os
+import glob
+
+from distutils import log
+from distutils.extension import Extension
+
+from astropy_helpers import setup_helpers
+from astropy_helpers.utils import import_file
+from astropy_helpers.version_helpers import get_pkg_version_module
+
+ERFAPKGDIR = os.path.relpath(os.path.dirname(__file__))
+
+ERFA_SRC = os.path.abspath(os.path.join(ERFAPKGDIR, '..', '..',
+                                        'cextern', 'erfa'))
+
+SRC_FILES = glob.glob(os.path.join(ERFA_SRC, '*'))
+SRC_FILES += [os.path.join(ERFAPKGDIR, filename)
+              for filename in ['pav2pv.c', 'pv2pav.c', 'erfa_additions.h',
+                               'ufunc.c.templ', 'core.py.templ',
+                               'erfa_generator.py']]
+
+GEN_FILES = [os.path.join(ERFAPKGDIR, 'core.py'),
+             os.path.join(ERFAPKGDIR, 'ufunc.c')]
+
+
+def pre_build_py_hook(cmd_obj):
+    preprocess_source()
+
+
+def pre_build_ext_hook(cmd_obj):
+    preprocess_source()
+
+
+def pre_sdist_hook(cmd_obj):
+    preprocess_source()
+
+
+def preprocess_source():
+    # Generating the ERFA wrappers should only be done if needed. This also
+    # ensures that it is not done for any release tarball since those will
+    # include core.py and ufunc.c.
+    if all(os.path.exists(filename) for filename in GEN_FILES):
+
+        # Determine modification times
+        erfa_mtime = max(os.path.getmtime(filename) for filename in SRC_FILES)
+        gen_mtime = min(os.path.getmtime(filename) for filename in GEN_FILES)
+
+        version = import_file(os.path.join(ERFAPKGDIR, '..', 'version.py'))
+
+        if gen_mtime > erfa_mtime:
+            # If generated source is recent enough, don't update
+            return
+        elif version.release:
+            # or, if we're on a release, issue a warning, but go ahead and use
+            # the wrappers anyway
+            log.warn('WARNING: The autogenerated wrappers in astropy._erfa '
+                     'seem to be older than the source templates used to '
+                     'create them. Because this is a release version we will '
+                     'use them anyway, but this might be a sign of some sort '
+                     'of version mismatch or other tampering. Or it might just '
+                     'mean you moved some files around or otherwise '
+                     'accidentally changed timestamps.')
+            return
+        # otherwise rebuild the autogenerated files
+
+        # If jinja2 isn't present, then print a warning and use existing files
+        try:
+            import jinja2  # pylint: disable=W0611
+        except ImportError:
+            log.warn("WARNING: jinja2 could not be imported, so the existing "
+                     "ERFA core.py and ufunc.c files will be used")
+            return
+
+    gen = import_file(os.path.join(ERFAPKGDIR, 'erfa_generator.py'))
+
+    gen.main(verbose=False)
+
+
+def get_extensions():
+    sources = [os.path.join(ERFAPKGDIR, fn)
+               for fn in ("ufunc.c", "pav2pv.c", "pv2pav.c")]
+    include_dirs = ['numpy']
+    libraries = []
+
+    if setup_helpers.use_system_library('erfa'):
+        libraries.append('erfa')
+    else:
+        # get all of the .c files in the cextern/erfa directory
+        erfafns = os.listdir(ERFA_SRC)
+        sources.extend(['cextern/erfa/' + fn
+                        for fn in erfafns if fn.endswith('.c')])
+
+        include_dirs.append('cextern/erfa')
+
+    erfa_ext = Extension(
+        name="astropy._erfa.ufunc",
+        sources=sources,
+        include_dirs=include_dirs,
+        libraries=libraries,
+        language="c",)
+
+    return [erfa_ext]
+
+
+def get_external_libraries():
+    return ['erfa']

testbed/astropy__astropy/astropy/_erfa/tests/__init__.py

@@ -0,0 +1 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst

testbed/astropy__astropy/astropy/_erfa/tests/test_erfa.py

@@ -0,0 +1,240 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import numpy as np
+
+from astropy._erfa import core as erfa
+from astropy.tests.helper import catch_warnings
+
+
+def test_erfa_wrapper():
+    """
+    Runs a set of tests that mostly make sure vectorization is
+    working as expected
+    """
+
+    jd = np.linspace(2456855.5, 2456855.5+1.0/24.0/60.0, 60*2+1)
+    ra = np.linspace(0.0, np.pi*2.0, 5)
+    dec = np.linspace(-np.pi/2.0, np.pi/2.0, 4)
+
+    aob, zob, hob, dob, rob, eo = erfa.atco13(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, jd, 0.0, 0.0, 0.0, np.pi/4.0, 0.0, 0.0, 0.0, 1014.0, 0.0, 0.0, 0.5)
+    assert aob.shape == (121,)
+
+    aob, zob, hob, dob, rob, eo = erfa.atco13(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, jd[0], 0.0, 0.0, 0.0, np.pi/4.0, 0.0, 0.0, 0.0, 1014.0, 0.0, 0.0, 0.5)
+    assert aob.shape == ()
+
+    aob, zob, hob, dob, rob, eo = erfa.atco13(ra[:, None, None], dec[None, :, None], 0.0, 0.0, 0.0, 0.0, jd[None, None, :], 0.0, 0.0, 0.0, np.pi/4.0, 0.0, 0.0, 0.0, 1014.0, 0.0, 0.0, 0.5)
+    (aob.shape) == (5, 4, 121)
+
+    iy, im, id, ihmsf = erfa.d2dtf("UTC", 3, jd, 0.0)
+    assert iy.shape == (121,)
+    assert ihmsf.shape == (121,)
+    assert ihmsf.dtype == erfa.dt_hmsf
+
+    iy, im, id, ihmsf = erfa.d2dtf("UTC", 3, jd[0], 0.0)
+    assert iy.shape == ()
+    assert ihmsf.shape == ()
+    assert ihmsf.dtype == erfa.dt_hmsf
+
+
+def test_angle_ops():
+
+    sign, idmsf = erfa.a2af(6, -np.pi)
+    assert sign == b'-'
+    assert idmsf.item() == (180, 0, 0, 0)
+
+    sign, ihmsf = erfa.a2tf(6, np.pi)
+    assert sign == b'+'
+    assert ihmsf.item() == (12, 0, 0, 0)
+
+    rad = erfa.af2a('-', 180, 0, 0.0)
+    np.testing.assert_allclose(rad, -np.pi)
+
+    rad = erfa.tf2a('+', 12, 0, 0.0)
+    np.testing.assert_allclose(rad, np.pi)
+
+    rad = erfa.anp(3.*np.pi)
+    np.testing.assert_allclose(rad, np.pi)
+
+    rad = erfa.anpm(3.*np.pi)
+    np.testing.assert_allclose(rad, -np.pi)
+
+    sign, ihmsf = erfa.d2tf(1, -1.5)
+    assert sign == b'-'
+    assert ihmsf.item() == (36, 0, 0, 0)
+
+    days = erfa.tf2d('+', 3, 0, 0.0)
+    np.testing.assert_allclose(days, 0.125)
+
+
+def test_spherical_cartesian():
+
+    theta, phi = erfa.c2s([0.0, np.sqrt(2.0), np.sqrt(2.0)])
+    np.testing.assert_allclose(theta, np.pi/2.0)
+    np.testing.assert_allclose(phi, np.pi/4.0)
+
+    theta, phi, r = erfa.p2s([0.0, np.sqrt(2.0), np.sqrt(2.0)])
+    np.testing.assert_allclose(theta, np.pi/2.0)
+    np.testing.assert_allclose(phi, np.pi/4.0)
+    np.testing.assert_allclose(r, 2.0)
+
+    pv = np.array(([0.0, np.sqrt(2.0), np.sqrt(2.0)], [1.0, 0.0, 0.0]),
+                  dtype=erfa.dt_pv)
+    theta, phi, r, td, pd, rd = erfa.pv2s(pv)
+    np.testing.assert_allclose(theta, np.pi/2.0)
+    np.testing.assert_allclose(phi, np.pi/4.0)
+    np.testing.assert_allclose(r, 2.0)
+    np.testing.assert_allclose(td, -np.sqrt(2.0)/2.0)
+    np.testing.assert_allclose(pd, 0.0)
+    np.testing.assert_allclose(rd, 0.0)
+
+    c = erfa.s2c(np.pi/2.0, np.pi/4.0)
+    np.testing.assert_allclose(c, [0.0, np.sqrt(2.0)/2.0, np.sqrt(2.0)/2.0], atol=1e-14)
+
+    c = erfa.s2p(np.pi/2.0, np.pi/4.0, 1.0)
+    np.testing.assert_allclose(c, [0.0, np.sqrt(2.0)/2.0, np.sqrt(2.0)/2.0], atol=1e-14)
+
+    pv = erfa.s2pv(np.pi/2.0, np.pi/4.0, 2.0, np.sqrt(2.0)/2.0, 0.0, 0.0)
+    np.testing.assert_allclose(pv['p'], [0.0, np.sqrt(2.0), np.sqrt(2.0)], atol=1e-14)
+    np.testing.assert_allclose(pv['v'],  [-1.0, 0.0, 0.0], atol=1e-14)
+
+
+def test_errwarn_reporting():
+    """
+    Test that the ERFA error reporting mechanism works as it should
+    """
+
+    # no warning
+    erfa.dat(1990, 1, 1, 0.5)
+
+    # check warning is raised for a scalar
+    with catch_warnings() as w:
+        erfa.dat(100, 1, 1, 0.5)
+        assert len(w) == 1
+        assert w[0].category == erfa.ErfaWarning
+        assert '1 of "dubious year (Note 1)"' in str(w[0].message)
+
+    # and that the count is right for a vector.
+    with catch_warnings() as w:
+        erfa.dat([100, 200, 1990], 1, 1, 0.5)
+        assert len(w) == 1
+        assert w[0].category == erfa.ErfaWarning
+        assert '2 of "dubious year (Note 1)"' in str(w[0].message)
+
+    try:
+        erfa.dat(1990, [1, 34, 2], [1, 1, 43], 0.5)
+    except erfa.ErfaError as e:
+        if '1 of "bad day (Note 3)", 1 of "bad month"' not in e.args[0]:
+            assert False, 'Raised the correct type of error, but wrong message: ' + e.args[0]
+
+    try:
+        erfa.dat(200, [1, 34, 2], [1, 1, 43], 0.5)
+    except erfa.ErfaError as e:
+        if 'warning' in e.args[0]:
+            assert False, 'Raised the correct type of error, but there were warnings mixed in: ' + e.args[0]
+
+
+def test_vector_inouts():
+    """
+    Tests that ERFA functions working with vectors are correctly consumed and spit out
+    """
+
+    # values are from test_erfa.c t_ab function
+    pnat = [-0.76321968546737951,
+            -0.60869453983060384,
+            -0.21676408580639883]
+    v = [2.1044018893653786e-5,
+         -8.9108923304429319e-5,
+         -3.8633714797716569e-5]
+    s = 0.99980921395708788
+    bm1 = 0.99999999506209258
+
+    expected = [-0.7631631094219556269,
+                -0.6087553082505590832,
+                -0.2167926269368471279]
+
+    res = erfa.ab(pnat, v, s, bm1)
+    assert res.shape == (3,)
+
+    np.testing.assert_allclose(res, expected)
+
+    res2 = erfa.ab([pnat]*4, v, s, bm1)
+    assert res2.shape == (4, 3)
+    np.testing.assert_allclose(res2, [expected]*4)
+
+    # here we stride an array and also do it Fortran-order to make sure
+    # it all still works correctly with non-contig arrays
+    pnata = np.array(pnat)
+    arrin = np.array([pnata, pnata/2, pnata/3, pnata/4, pnata/5]*4, order='F')
+    res3 = erfa.ab(arrin[::5], v, s, bm1)
+    assert res3.shape == (4, 3)
+    np.testing.assert_allclose(res3, [expected]*4)
+
+
+def test_pv_in():
+    jd1 = 2456165.5
+    jd2 = 0.401182685
+
+    pv = np.empty((), dtype=erfa.dt_pv)
+    pv['p'] = [-6241497.16,
+               401346.896,
+               -1251136.04]
+    pv['v'] = [-29.264597,
+               -455.021831,
+               0.0266151194]
+
+    astrom = erfa.apcs13(jd1, jd2, pv)
+    assert astrom.shape == ()
+
+    # values from t_erfa_c
+    np.testing.assert_allclose(astrom['pmt'], 12.65133794027378508)
+    np.testing.assert_allclose(astrom['em'], 1.010428384373318379)
+    np.testing.assert_allclose(astrom['eb'], [0.9012691529023298391,
+                                              -.4173999812023068781,
+                                              -.1809906511146821008])
+    np.testing.assert_allclose(astrom['bpn'], np.eye(3))
+
+    # first make sure it *fails* if we mess with the input orders
+    pvbad = np.empty_like(pv)
+    pvbad['p'], pvbad['v'] = pv['v'], pv['p']
+    astrombad = erfa.apcs13(jd1, jd2, pvbad)
+    assert not np.allclose(astrombad['em'], 1.010428384373318379)
+
+    pvarr = np.array([pv]*3)
+    astrom2 = erfa.apcs13(jd1, jd2, pvarr)
+    assert astrom2.shape == (3,)
+    np.testing.assert_allclose(astrom2['em'], 1.010428384373318379)
+
+    # try striding of the input array to make non-contiguous
+    pvmatarr = np.array([pv]*9)[::3]
+    astrom3 = erfa.apcs13(jd1, jd2, pvmatarr)
+    assert astrom3.shape == (3,)
+    np.testing.assert_allclose(astrom3['em'], 1.010428384373318379)
+
+
+def test_structs():
+    """
+    Checks producing and consuming of ERFA c structs
+    """
+
+    am, eo = erfa.apci13(2456165.5, [0.401182685, 1])
+    assert am.shape == (2, )
+    assert am.dtype == erfa.dt_eraASTROM
+    assert eo.shape == (2, )
+
+    # a few spotchecks from test_erfa.c
+    np.testing.assert_allclose(am[0]['pmt'], 12.65133794027378508)
+    np.testing.assert_allclose(am[0]['v'], [0.4289638897157027528e-4,
+                                            0.8115034002544663526e-4,
+                                            0.3517555122593144633e-4])
+
+    ri, di = erfa.atciqz(2.71, 0.174, am[0])
+    np.testing.assert_allclose(ri, 2.709994899247599271)
+    np.testing.assert_allclose(di, 0.1728740720983623469)
+
+
+def test_float32_input():
+    # Regression test for gh-8615
+    xyz = np.array([[1, 0, 0], [0.9, 0.1, 0]])
+    out64 = erfa.p2s(xyz)
+    out32 = erfa.p2s(xyz.astype('f4'))
+    np.testing.assert_allclose(out32, out64, rtol=1.e-5)

testbed/astropy__astropy/astropy/_erfa/ufunc.c.templ

@@ -0,0 +1,852 @@
+/* -*- mode: c -*- */
+
+/* Licensed under a 3-clause BSD style license - see LICENSE.rst */
+
+/*
+ * "ufunc.c" is auto-generated by erfa_generator.py from the template
+ * "ufunc.c.templ". Do *not* edit "ufunc.c" directly, instead edit
+ * "ufunc.c.templ" and run ufunc_generator.py from the source directory
+ * to update it.
+ */
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include "Python.h"
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#include "erfa.h"
+#include "erfa_additions.h"
+
+#define MODULE_DOCSTRING \
+    "Ufunc wrappers of the ERFA routines.\n\n" \
+    "These ufuncs vectorize the ERFA functions assuming structured dtypes\n" \
+    "for vector and matrix arguments. Status codes are vectors as well.\n" \
+    "Python wrappers are also provided, which convert between\n" \
+    "trailing dimensions and structured dtypes where necessary,\n" \
+    "and combine status codes."
+
+static inline void copy_to_double3(char *ptr, npy_intp s, double d[3]) {
+    char *p = ptr;
+    int j;
+    for (j = 0; j < 3; j++, p += s) {
+        d[j] = *(double *)p;
+    }
+}
+
+static inline void copy_from_double3(char *ptr, npy_intp s, double d[3]) {
+    char *p = ptr;
+    int j;
+    for (j = 0; j < 3; j++, p += s) {
+        *(double *)p = d[j];
+    }
+}
+
+static inline void copy_to_double33(char *ptr, npy_intp s0, npy_intp s1,
+                                    double d[3][3]) {
+    char *p0 = ptr;
+    int j0, j1;
+    for (j0 = 0; j0 < 3; j0++, p0 += s0) {
+        char *p1 = p0;
+        for (j1 = 0; j1 < 3; j1++, p1 += s1) {
+            d[j0][j1] = *(double *)p1;
+        }
+    }
+}
+
+static inline void copy_from_double33(char *ptr, npy_intp s0, npy_intp s1,
+                                      double d[3][3]) {
+    char *p = ptr;
+    char *p0 = ptr;
+    int j0, j1;
+    for (j0 = 0; j0 < 3; j0++, p0 += s0) {
+        char *p1 = p0;
+        for (j1 = 0; j1 < 3; j1++, p1 += s1) {
+            *(double *)p = d[j0][j1];
+        }
+    }
+}
+
+/* eraLDBODY is never returned, so we do not need a copy_from */
+static inline void copy_to_eraLDBODY(char *ptr, npy_intp s, npy_intp n,
+                                  eraLDBODY b[]) {
+    char *p = ptr;
+    npy_intp j;
+    for (j = 0; j < n; j++, p += s) {
+        b[j] = *(eraLDBODY *)p;
+    }
+}
+
+/*
+ * INNER LOOPS - iteratively call the erfa function for a chunk of data.
+ *
+ * For each argument:
+ * char *<name> is the pointer to the data in memory;
+ * npy_intp s_<name> is the number of bytes between successive elements;
+ * <ctype> *_<name> is a correctly cast pointer to the current element;
+ * (<ctype> _<name>, i.e., not a pointer, for status codes and return values)
+ *
+ * Notes:
+ * 1. Some erfa function change elements in-place; in the ufunc, these "inout"
+ *    arguments are treated as separate: data is copied from the input to the
+ *    output, and the output is changed in-place by the erfa function.
+ *    To reproduce the in-place behaviour, the input to the ufunc can be passed
+ *    in as output as well -- as is done in the python wrapper (the copy will
+ *    be omitted for this case).
+ * 2. Any erfa function involving light deflection requires an struct
+ *    eraLDBODY argument with a dimension that is user-defined. Those function
+ *    are implemented as generalized ufuncs, with a signature in which the
+ *    relevant variable is marked (i.e., '(),...,(n), (), ... -> (),...').
+ *    In the inner loops, an appropriate copy is done if in the numpy array
+ *    the n elements are not contiguous.
+ * 3. Similar copies are done for erfa functions that require vectors or
+ *    matrices, if the corresponding axes in the input or output operands are
+ *    not contiguous.
+ */
+
+{%- macro inner_loop_steps_and_copy(arg, arg_name) %}
+  {%- for i in range(arg.ndim or 1) %}
+    npy_intp is_{{ arg_name }}{{ i }} = *steps++;
+  {%- endfor %}
+  {#- /* copy should be made if buffer not contiguous;
+         note: one can only have 1 or 2 dimensions */ #}
+  {%- if arg.ndim == 2 %}
+    int copy_{{ arg_name
+        }} = (is_{{ arg_name }}1 != sizeof({{ arg.ctype }}) &&
+              is_{{ arg_name }}0 != {{ arg.shape[1] }} * sizeof({{ arg.ctype }}));
+  {%- else %}
+    int copy_{{ arg_name }} = (is_{{ arg_name }}0 != sizeof({{ arg.ctype }}));
+  {%- endif %}
+{%- endmacro %}
+
+{%- for func in funcs %}
+
+static void ufunc_loop_{{ func.pyname }}(
+    char **args, npy_intp *dimensions, npy_intp* steps, void* data)
+{
+  {#- /* index and length of loop */ #}
+    npy_intp i_o;
+    npy_intp n_o = *dimensions++;
+  {#- /*
+       * Pointers to each argument, required step size
+       */ #}
+  {#- /* normal input arguments */ #}
+  {%- for arg in func.args_by_inout('in') %}
+    char *{{ arg.name }} = *args++;
+    npy_intp s_{{ arg.name }} = *steps++;
+  {%- endfor -%}
+  {#- /* for in part of in-place arguments, we need a different name */ #}
+  {%- for arg in func.args_by_inout('inout') %}
+    char *{{ arg.name }}_in = *args++;
+    npy_intp s_{{ arg.name }}_in = *steps++;
+  {%- endfor -%}
+  {#- /* out part of input, and output arguments, including status */ #}
+  {%- for arg in func.args_by_inout('inout|out|stat|ret') %}
+    char *{{ arg.name }} = *args++;
+    npy_intp s_{{ arg.name }} = *steps++;
+  {%- endfor -%}
+  {#- /*
+       * Cast pointers and possible contiguous buffers (for gufuncs)
+       */ #}
+  {%- for arg in func.args_by_inout('in|inout|out') %}
+   {%- if arg.signature_shape == '()' or arg.ctype == 'eraLDBODY'  %}
+    {{ arg.ctype }} (*_{{ arg.name }}){{ arg.cshape }};
+   {%- else %}
+    double b_{{ arg.name }}{{ arg.cshape }};
+    {{ arg.ctype }} (*_{{ arg.name }}){{ arg.cshape }} = &b_{{ arg.name }};
+   {%- endif %}
+  {%- endfor %}
+  {#- /* variables to hold status and return values */ #}
+  {%- for arg in func.args_by_inout('stat|ret') %}
+    {{ arg.ctype }} _{{ arg.name }};
+  {%- endfor %}
+  {#- /*
+       * For GENERALIZED UFUNCS - inner loop steps, needs for copying.
+       */ #}
+  {%- if func.signature %}
+   {#- /* loop step sizes and whether copies are needed */ #}
+   {%- for arg in func.args_by_inout('in') %}
+    {#- /* only LDBODY has non-fixed dimension; it is always first */ #}
+    {%- if arg.ctype == 'eraLDBODY' %}
+    npy_intp nb = dimensions[0];
+    {%- endif %}
+    {%- if arg.signature_shape != '()' -%}
+    {{ inner_loop_steps_and_copy(arg, arg.name) }}
+    {%- endif %}
+   {%- endfor %}
+   {%- for arg in func.args_by_inout('inout') %}
+    {%- if arg.signature_shape != '()' -%}
+    {{ inner_loop_steps_and_copy(arg, arg.name + '_in') }}
+    {%- endif %}
+   {%- endfor %}
+   {%- for arg in func.args_by_inout('inout|out') %}
+    {%- if arg.signature_shape != '()' -%}
+    {{ inner_loop_steps_and_copy(arg, arg.name) }}
+    {%- endif %}
+   {%- endfor %}
+   {#- /* if needed, allocate memory for contiguous eraLDBODY copies */ #}
+   {%- if func.user_dtype == 'dt_eraLDBODY' %}
+    if (copy_b) {
+        _b = PyArray_malloc(nb * sizeof(eraLDBODY));
+        if (_b == NULL) {
+            PyErr_NoMemory();
+            return;
+        }
+    }
+    else { {#- /* just to keep compiler happy */ #}
+        _b = NULL;
+    }
+   {%- endif %}
+  {%- endif %} {#- /* end of GUFUNC inner loop definitions */ #}
+  {#- /*
+       * Actual inner loop, increasing all pointers by their steps
+       */ #}
+    for (i_o = 0; i_o < n_o;
+         i_o++ {%- for arg in func.args_by_inout('in|inout|out|stat|ret') -%}
+             , {{ arg.name }} += s_{{ arg.name }}
+             {%- endfor -%}
+             {%- for arg in func.args_by_inout('inout') -%}
+             , {{ arg.name }}_in += s_{{ arg.name }}_in
+             {%- endfor -%}) {
+      {%- if func.signature %}
+       {#- /*
+            * GENERALIZED UFUNC, prepare for call.
+            */ #}
+       {#- /* copy input arguments to buffer if needed */ #}
+       {%- for arg in func.args_by_inout('in') %}
+        {%- if arg.signature_shape != '()' %}
+        if (copy_{{ arg.name }}) {
+            copy_to_{{ arg.ctype }}{{ arg.shape|join('') }}({{ arg.name }}
+                {%- for i in range(arg.ndim or 1) -%}
+                , is_{{ arg.name }}{{ i }}
+                {%- endfor %}, {{ arg.name_for_call}});
+        }
+        else {
+            _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        }
+        {%- else %}
+        _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        {%- endif %}
+       {%- endfor %} {#- end of loop over 'in' #}
+       {#- /* for inout arguments, set up output first,
+              and then copy to it if needed */ #}
+       {%- for arg in func.args_by_inout('inout') %}
+        {%- if arg.signature_shape != '()' %}
+        if (!copy_{{ arg.name }}) {
+            _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        }
+        if (copy_{{ arg.name }}_in || {{ arg.name }} != {{ arg.name }}_in) {
+            copy_to_{{ arg.ctype }}{{ arg.shape|join('') }}({{ arg.name }}_in
+                {%- for i in range(arg.ndim or 1) -%}
+                , is_{{ arg.name }}_in{{ i }}
+                {%- endfor %}, {{ arg.name_for_call}});
+        }
+        {%- else %}
+        _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        if ({{ arg.name }}_in != {{ arg.name }}) {
+            memcpy({{ arg.name }}, {{ arg.name }}_in, {{ arg.size }}*sizeof({{ arg.ctype }}));
+        }
+        {%- endif %}
+       {%- endfor %} {#- end of loop over 'inout' #}
+       {#- /* set up gufunc outputs */ #}
+       {%- for arg in func.args_by_inout('out') %}
+        {%- if arg.signature_shape != '()' %}
+        if (!copy_{{ arg.name }}) {
+            _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        }
+        {%- else %}
+        _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+        {%- endif %}
+       {%- endfor %} {#- end of loop over 'out' #}
+      {%- else %}
+       {#- /*
+            * NORMAL UFUNC, prepare for call
+            */ #}
+       {#- /* set up pointers to input/output arguments */ #}
+       {%- for arg in func.args_by_inout('in|inout|out') %}
+        _{{ arg.name }} = (({{ arg.ctype }} (*){{ arg.cshape }}){{ arg.name }});
+       {%- endfor %}
+       {#- /* copy from in to out for arugments changed in-place */ #}
+       {%- for arg in func.args_by_inout('inout') %}
+        if ({{ arg.name }}_in != {{ arg.name }}) {
+            memcpy({{ arg.name }}, {{ arg.name }}_in, {{ arg.size }}*sizeof({{ arg.ctype }}));
+        }
+       {%- endfor %}
+      {%- endif %} {#- end of gufunc/ufunc preparation #}
+      {#- /*
+           * call the actual erfa function
+           */ #}
+        {{ func.args_by_inout('ret|stat') |
+                    map(attribute='name') |
+                    surround('_', ' = ') |
+                    join
+        }}{{ func.name
+        }}({{ func.args_by_inout('in|inout|out') |
+                    map(attribute='name_for_call') |
+                    join(', ') }});
+      {#- /* store any return values */ #}
+      {%- for arg in func.args_by_inout('ret|stat') %}
+        *(({{ arg.ctype }} *){{ arg.name }}) = _{{ arg.name }};
+      {%- endfor %}
+      {%- if func.signature %}
+       {#- /* for generalized ufunc, copy output from buffer if needed */ #}
+       {%- for arg in func.args_by_inout('inout|out') %}
+        {%- if arg.signature_shape != '()' %}
+        if (copy_{{ arg.name }}) {
+            copy_from_{{ arg.ctype }}{{ arg.shape|join('') }}({{ arg.name }}
+                {%- for i in range(arg.ndim or 1) -%}
+                , is_{{ arg.name }}{{ i }}
+                {%- endfor %}, {{ arg.name_for_call}});
+        }
+        {%- endif %}
+       {%- endfor %}
+      {%- endif %}
+    }
+    {%- if func.user_dtype == 'dt_eraLBODY' %}
+    if (copy_b) {
+        PyArray_free(_b);
+    }
+    {%- endif %}
+}
+
+{%- endfor %}
+
+/*
+ * UFUNC LOOP MATCHING HELPERS
+ * All but ufunc_loop_matches are copies of code needed but not exported.
+ */
+
+/*
+ * Adjusted version of ufunc_loop_matches from
+ * numpy/core/src/umath/ufunc_type_resolution.c.
+ * Here, we special-case the structured dtype check, only allowing
+ * casting of the same dtype or string.  We also do not distinguish
+ * between input and output arguments for casting.
+ */
+static int
+ufunc_loop_matches(PyUFuncObject *self,
+                   PyArrayObject **op,
+                   NPY_CASTING casting,
+                   int *types, PyArray_Descr **dtypes)
+{
+    npy_intp i, nin = self->nin, nop = nin + self->nout;
+    /*
+     * Check if all the inputs can be cast to the types used by this function.
+     */
+    for (i = 0; i < nin; ++i) {
+        PyArray_Descr *op_descr = PyArray_DESCR(op[i]);
+        /*
+         * Check for NPY_VOID with an associated struct dtype.
+         */
+        if (types[i] == NPY_VOID && dtypes != NULL) {
+            int op_descr_type_num = op_descr->type_num;
+            int dtype_elsize = dtypes[i]->elsize;
+            /*
+             * MHvK: we do our own check on casting, since by default
+             * all items can cast to structured dtypes (see gh-11114),
+             * which is not OK. So, we only allow VOID->same VOID,
+             * and STRING -> VOID-of-STRING (which works well; we
+             * recognize VOID-of-STRING by the dtype element size;
+             * it would be rather costly to go look at dtype->fields).
+             */
+            if (op_descr_type_num == NPY_VOID) {
+                /* allow only the same structured to structured */
+                if (!PyArray_EquivTypes(op_descr, dtypes[i])) {
+                    return 0;
+                }
+            }
+            else if (dtypes[i]->elsize == 1 || dtypes[i]->elsize == 12) {
+                /* string structured array; string argument is OK */
+                if (!((op_descr_type_num == NPY_STRING &&
+                       op_descr->elsize <= dtype_elsize) ||
+                      (op_descr_type_num == NPY_UNICODE &&
+                       op_descr->elsize >> 2 <= dtype_elsize))) {
+                    return 0;
+                }
+            }
+            else {
+                return 0;
+            }
+        }
+        else { /* non-void function argument */
+            PyArray_Descr *tmp = PyArray_DescrFromType(types[i]);
+            if (tmp == NULL) {
+                return -1;
+            }
+            if (!PyArray_CanCastTypeTo(op_descr, tmp, casting)) {
+                Py_DECREF(tmp);
+                return 0;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+    /*
+     * All inputs were ok; now check casting back to the outputs.
+     * MHvK: Since no casting from structured to non-structured is
+     * possible, no changes needed here.
+     */
+    for (i = nin; i < nop; ++i) {
+        if (op[i] != NULL) {
+            PyArray_Descr *tmp = PyArray_DescrFromType(types[i]);
+            if (tmp == NULL) {
+                return -1;
+            }
+            if (!PyArray_CanCastTypeTo(tmp, PyArray_DESCR(op[i]),
+                                       casting)) {
+                Py_DECREF(tmp);
+                return 0;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+    return 1;
+}
+/*
+ * Copy from numpy/core/src/umath/ufunc_type_resolution.c,
+ * since this translation function is not exported.
+ */
+static const char *
+npy_casting_to_string(NPY_CASTING casting)
+{
+    switch (casting) {
+        case NPY_NO_CASTING:
+            return "'no'";
+        case NPY_EQUIV_CASTING:
+            return "'equiv'";
+        case NPY_SAFE_CASTING:
+            return "'safe'";
+        case NPY_SAME_KIND_CASTING:
+            return "'same_kind'";
+        case NPY_UNSAFE_CASTING:
+            return "'unsafe'";
+        default:
+            return "<unknown>";
+    }
+}
+
+/*
+ * Copy from numpy/core/src/umath/ufunc_type_resolution.c,
+ * since not exported.
+ */
+static PyArray_Descr *
+ensure_dtype_nbo(PyArray_Descr *type)
+{
+    if (PyArray_ISNBO(type->byteorder)) {
+        Py_INCREF(type);
+        return type;
+    }
+    else {
+        return PyArray_DescrNewByteorder(type, NPY_NATIVE);
+    }
+}
+
+/*
+ * Copy from numpy/core/src/umath/ufunc_type_resolution.c,
+ * since not exported.
+ */
+static int
+set_ufunc_loop_data_types(PyUFuncObject *self, PyArrayObject **op,
+                    PyArray_Descr **out_dtypes,
+                    int *type_nums, PyArray_Descr **dtypes)
+{
+    int i, nin = self->nin, nop = nin + self->nout;
+
+    /*
+     * Fill the dtypes array.
+     * For outputs,
+     * also search the inputs for a matching type_num to copy
+     * instead of creating a new one, similarly to preserve metadata.
+     **/
+    for (i = 0; i < nop; ++i) {
+        if (dtypes != NULL) {
+            out_dtypes[i] = dtypes[i];
+            Py_XINCREF(out_dtypes[i]);
+        /*
+         * Copy the dtype from 'op' if the type_num matches,
+         * to preserve metadata.
+         */
+        }
+        else if (op[i] != NULL &&
+                 PyArray_DESCR(op[i])->type_num == type_nums[i]) {
+            out_dtypes[i] = ensure_dtype_nbo(PyArray_DESCR(op[i]));
+        }
+        /*
+         * For outputs, copy the dtype from op[0] if the type_num
+         * matches, similarly to preserve metdata.
+         */
+        else if (i >= nin && op[0] != NULL &&
+                            PyArray_DESCR(op[0])->type_num == type_nums[i]) {
+            out_dtypes[i] = ensure_dtype_nbo(PyArray_DESCR(op[0]));
+        }
+        /* Otherwise create a plain descr from the type number */
+        else {
+            out_dtypes[i] = PyArray_DescrFromType(type_nums[i]);
+        }
+
+        if (out_dtypes[i] == NULL) {
+            goto fail;
+        }
+    }
+
+    return 0;
+
+fail:
+    while (--i >= 0) {
+        Py_DECREF(out_dtypes[i]);
+        out_dtypes[i] = NULL;
+    }
+    return -1;
+}
+
+/*
+ * UFUNC TYPE RESOLVER
+ *
+ * We provide our own type resolver, since the default one,
+ * PyUFunc_DefaultTypeResolver from
+ * numpy/core/src/umath/ufunc_type_resolution.c, has problems:
+ * 1. It only looks for userloops if any of the operands have a user
+ *    type, which does not work if the inputs are normal and no explicit
+ *    output is given (see https://github.com/numpy/numpy/issues/11109).
+ * 2. It only allows "safe" casting of inputs, which annoyingly prevents
+ *    passing in a python int for int32 input.
+ * The resolver below solves both, and speeds up the process by
+ * explicitly assuming that a ufunc has only one function built in,
+ * either a regular one or a userloop (for structured dtype).
+ *
+ * Combines code from linear_search_type_resolver and
+ * linear_search_userloop_type_resolver from
+ * numpy/core/src/umath/ufunc_type_resolution.c
+ */
+static int ErfaUFuncTypeResolver(PyUFuncObject *ufunc,
+                                 NPY_CASTING casting,
+                                 PyArrayObject **operands,
+                                 PyObject *type_tup,
+                                 PyArray_Descr **out_dtypes)
+{
+    int *types;
+    PyArray_Descr **dtypes;
+
+    if (ufunc->userloops) {
+        Py_ssize_t unused_pos = 0;
+        PyObject *userloop;
+        PyUFunc_Loop1d *funcdata;
+
+        if (ufunc->ntypes > 0 || PyDict_Size(ufunc->userloops) != 1) {
+            goto fail;
+        }
+        /* No iteration needed; only one entry in dict */
+        PyDict_Next(ufunc->userloops, &unused_pos, NULL, &userloop);
+        funcdata = (PyUFunc_Loop1d *)PyCapsule_GetPointer(userloop, NULL);
+        /* There should be only one function */
+        if (funcdata->next != NULL) {
+            goto fail;
+        }
+        types = funcdata->arg_types;
+        dtypes = funcdata->arg_dtypes;
+    }
+    else {
+        npy_intp j;
+        int types_array[NPY_MAXARGS];
+
+        if (ufunc->ntypes != 1) {
+            goto fail;
+        }
+        /* Copy the types into an int array for matching */
+        for (j = 0; j < ufunc->nargs; ++j) {
+            types_array[j] = ufunc->types[j];
+        }
+        types = types_array;
+        dtypes = NULL;
+    }
+    switch (ufunc_loop_matches(ufunc, operands, casting, types, dtypes)) {
+    case 1:  /* Matching types */
+        return set_ufunc_loop_data_types(ufunc, operands, out_dtypes,
+                                         types, dtypes);
+    case -1:   /* Error */
+        return -1;
+    }
+    /* No match */
+    PyErr_Format(PyExc_TypeError,
+                 "ufunc '%s' not supported for the input types, and the "
+                 "inputs could not be safely coerced to any supported "
+                 "types according to the casting rule '%s'",
+                 ufunc->name, npy_casting_to_string(casting));
+    return -1;
+
+fail:
+    /* More than one loop or function */
+    PyErr_Format(PyExc_RuntimeError,
+                 "Unexpected internal error: ufunc '%s' wraps an ERFA "
+                 "function and should have only a single loop with a "
+                 "single function, yet has more.",
+                 ufunc->name);
+    return -1;
+}
+
+{%- if NUMPY_LT_1_16 %}
+/*
+ * The following is only necessary for NUMPY_LT_1_16.  Once we support
+ * only numpy >=1.16, it can be removed here and in the template part.
+ *
+ * For numpy <1.16, this works around the fact that gufuncs could not
+ * have fixed dimensions.
+ *
+ * Rather than just go for our type resolver, we check here whether
+ * any non-void input with core dimensions has dimension equal to 3.  Here,
+ * we already know that all core dimensions are equal, so we have to check
+ * only one.
+ */
+static int ErfaUFuncD3CheckTypeResolver(PyUFuncObject *ufunc,
+                                        NPY_CASTING casting,
+                                        PyArrayObject **operands,
+                                        PyObject *type_tup,
+                                        PyArray_Descr **out_dtypes)
+{
+    int i;
+
+    for (i = 0; i < ufunc->nin; i++) {
+        if (ufunc->core_num_dims[i]) {
+            PyArrayObject *op = operands[i];
+            if (PyArray_DESCR(op)->type_num != NPY_VOID) {
+                /* last dimension is should always be 3 */
+                int last_dim = PyArray_DIMS(op)[PyArray_NDIM(op)-1];
+                if (last_dim != 3) {
+                    PyErr_Format(PyExc_ValueError,
+                        "%s: Input operand %d has a mismatch in its "
+                        "core dimension %d, with gufunc signature %s "
+                        "(size %zd is different from fixed size 3)",
+                        ufunc->name, i, ufunc->core_num_dims[i] - 1,
+                        ufunc->core_signature, last_dim);
+                    return -1;
+                }
+                break;
+            }
+        }
+    }
+    if (i == ufunc->nin) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "no relevant input found; should not happen!");
+    }
+    return ErfaUFuncTypeResolver(ufunc, casting, operands, type_tup,
+                                 out_dtypes);
+}
+{%- endif %}
+
+/*
+ * UFUNC MODULE DEFINITIONS AND INITIALIZATION
+ */
+static PyMethodDef ErfaUFuncMethods[] = {
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "ufunc",
+    MODULE_DOCSTRING,
+    -1,
+    ErfaUFuncMethods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_ufunc(void)
+{
+    /* module and its dict */
+    PyObject *m, *d;
+    /* structured dtypes and their definition */
+    PyObject *dtype_def;
+    PyArray_Descr *dt_double = NULL, *dt_int = NULL;
+    PyArray_Descr *dt_pv = NULL, *dt_pvdpv = NULL;
+    PyArray_Descr *dt_ymdf = NULL, *dt_hmsf = NULL, *dt_dmsf = NULL;
+    PyArray_Descr *dt_sign = NULL, *dt_type = NULL;
+    PyArray_Descr *dt_eraASTROM = NULL, *dt_eraLDBODY = NULL;
+    PyArray_Descr *dtypes[NPY_MAXARGS];
+    /* ufuncs and their definitions */
+    int status;
+    PyUFuncObject *ufunc;
+    static void *data[1] = {NULL};
+    {#- /* for non-structured functions, define there types and functions
+           as these do not get copied */ #}
+    {%- for func in funcs %}
+    {%- if not func.user_dtype %}
+    static char types_{{ func.pyname }}[{{ func.args_by_inout('in|inout|out|ret|stat')|count }}] = { {{ func.args_by_inout('in|inout|out|ret|stat')|map(attribute='npy_type')|join(', ') }} };
+    static PyUFuncGenericFunction funcs_{{ func.pyname }}[1] = { &ufunc_loop_{{ func.pyname }} };
+    {%- endif %}
+    {%- endfor %}
+
+    m = PyModule_Create(&moduledef);
+    if (m == NULL) {
+        return NULL;
+    }
+    d = PyModule_GetDict(m); /* borrowed ref. */
+    if (d == NULL) {
+        goto fail;
+    }
+
+    import_array();
+    import_umath();
+    /*
+     * Define the basic and structured types used in erfa so that
+     * we can use them for definitions of userloops below.
+     */
+    dt_double = PyArray_DescrFromType(NPY_DOUBLE);
+    dt_int = PyArray_DescrFromType(NPY_INT);
+    /* double[2][3] = pv */
+    dtype_def = Py_BuildValue("[(s, s), (s, s)]",
+                              "p", "(3,)f8", "v", "(3,)f8");
+    PyArray_DescrAlignConverter(dtype_def, &dt_pv);
+    Py_DECREF(dtype_def);
+    /* double[2] = pvdpv */
+    dtype_def = Py_BuildValue("[(s, s), (s, s)]",
+                              "pdp", "f8", "pdv", "f8");
+    PyArray_DescrAlignConverter(dtype_def, &dt_pvdpv);
+    Py_DECREF(dtype_def);
+    /* int[4] = ymdf, hmsf, dmsf */
+    dtype_def = Py_BuildValue("[(s, s), (s, s), (s, s), (s, s)]",
+                              "y", "i4", "m", "i4", "d", "i4", "f", "i4");
+    PyArray_DescrAlignConverter(dtype_def, &dt_ymdf);
+    Py_DECREF(dtype_def);
+    dtype_def = Py_BuildValue("[(s, s), (s, s), (s, s), (s, s)]",
+                              "h", "i4", "m", "i4", "s", "i4", "f", "i4");
+    PyArray_DescrAlignConverter(dtype_def, &dt_hmsf);
+    Py_DECREF(dtype_def);
+    dtype_def = Py_BuildValue("[(s, s), (s, s), (s, s), (s, s)]",
+                              "h", "i4", "m", "i4", "s", "i4", "f", "i4");
+    PyArray_DescrAlignConverter(dtype_def, &dt_dmsf);
+    Py_DECREF(dtype_def);
+    /* char1 (have to use structured, otherwise it cannot be a user type) */
+    dtype_def = Py_BuildValue("[(s, s)]", "sign", "S1");
+    PyArray_DescrAlignConverter(dtype_def, &dt_sign);
+    Py_DECREF(dtype_def);
+    /* char12 */
+    dtype_def = Py_BuildValue("[(s, s)]", "type", "S12");
+    PyArray_DescrAlignConverter(dtype_def, &dt_type);
+    Py_DECREF(dtype_def);
+    /* eraLDBODY */
+    dtype_def = Py_BuildValue(
+        "[(s, s), (s, s), (s, s)]",
+        "bm", "f8",     /* mass of the body (solar masses) */
+        "dl", "f8",     /* deflection limiter (radians^2/2) */
+        "pv", "(2,3)f8" /* barycentric PV of the body (au, au/day) */
+        );
+    PyArray_DescrAlignConverter(dtype_def, &dt_eraLDBODY);
+    Py_DECREF(dtype_def);
+    /* eraASTROM */
+    dtype_def = Py_BuildValue(
+        "[(s, s), (s, s), (s, s), (s, s),"
+        " (s, s), (s, s), (s, s), (s, s),"
+        " (s, s), (s, s), (s, s), (s, s),"
+        " (s, s), (s, s), (s, s), (s, s), (s, s)]",
+        "pmt", "f8",       /* PM time interval (SSB, Julian years) */
+        "eb", "(3,)f8",    /* SSB to observer (vector, au) */
+        "eh", "(3,)f8",    /* Sun to observer (unit vector) */
+        "em", "f8",        /* distance from Sun to observer (au) */
+        "v", "(3,)f8",     /* barycentric observer velocity (vector, c) */
+        "bm1", "f8",       /* sqrt(1-|v|^2): reciprocal of Lorenz factor */
+        "bpn", "(3,3)f8",  /* bias-precession-nutation matrix */
+        "along", "f8",     /* longitude + s' + dERA(DUT) (radians) */
+        "phi", "f8",       /* geodetic latitude (radians) */
+        "xpl", "f8",       /* polar motion xp wrt local meridian (radians) */
+        "ypl", "f8",       /* polar motion yp wrt local meridian (radians) */
+        "sphi", "f8",      /* sine of geodetic latitude */
+        "cphi", "f8",      /* cosine of geodetic latitude */
+        "diurab", "f8",    /* magnitude of diurnal aberration vector */
+        "eral", "f8",      /* "local" Earth rotation angle (radians) */
+        "refa", "f8",      /* refraction constant A (radians) */
+        "refb", "f8"       /* refraction constant B (radians) */
+        );
+    PyArray_DescrAlignConverter(dtype_def, &dt_eraASTROM);
+    Py_DECREF(dtype_def);
+    if (dt_double == NULL || dt_int == NULL ||
+        dt_pv == NULL || dt_pvdpv == NULL ||
+        dt_ymdf == NULL || dt_hmsf == NULL || dt_dmsf == NULL ||
+        dt_sign == NULL || dt_type == NULL ||
+        dt_eraLDBODY == NULL || dt_eraASTROM == NULL) {
+        goto fail;
+    }
+    /* Make the structured dtypes available in the module */
+    PyDict_SetItemString(d, "dt_pv", (PyObject *)dt_pv);
+    PyDict_SetItemString(d, "dt_pvdpv", (PyObject *)dt_pvdpv);
+    PyDict_SetItemString(d, "dt_ymdf", (PyObject *)dt_ymdf);
+    PyDict_SetItemString(d, "dt_hmsf", (PyObject *)dt_hmsf);
+    PyDict_SetItemString(d, "dt_dmsf", (PyObject *)dt_dmsf);
+    PyDict_SetItemString(d, "dt_sign", (PyObject *)dt_sign);
+    PyDict_SetItemString(d, "dt_type", (PyObject *)dt_type);
+    PyDict_SetItemString(d, "dt_eraLDBODY", (PyObject *)dt_eraLDBODY);
+    PyDict_SetItemString(d, "dt_eraASTROM", (PyObject *)dt_eraASTROM);
+    /*
+     * Define the ufuncs.  For those without structured dtypes,
+     * the ufunc creation uses the static variables defined above;
+     * for those with structured dtypes, an empty ufunc is created,
+     * and then a userloop is added.  For both, we set the type
+     * resolver to our own, and then add the ufunc to the module.
+     *
+     * Note that for the arguments, any inout arguments, i.e., those
+     * that are changed in-place in the ERFA function, are repeated,
+     * since we want the ufuncs not to do in-place changes (unless
+     * explicitly requested with ufunc(..., in,..., out=in))
+     */
+    {%- for func in funcs %}
+    {%- if not func.user_dtype %}
+    ufunc = (PyUFuncObject *)PyUFunc_FromFuncAndDataAndSignature(
+        funcs_{{ func.pyname }}, data, types_{{ func.pyname }},
+        1, {{ func.args_by_inout('in|inout')|count }}, {{ func.args_by_inout('inout|out|ret|stat')|count }}, PyUFunc_None,
+        "{{ func.pyname }}",
+        "UFunc wrapper for {{ func.name }}",
+        0, {% if func.signature -%} "{{ func.signature }}" {%- else -%} NULL {%- endif -%});
+    if (ufunc == NULL) {
+        goto fail;
+    }
+    {%- else %}
+    ufunc = (PyUFuncObject *)PyUFunc_FromFuncAndDataAndSignature(
+        NULL, NULL, NULL,
+        0, {{ func.args_by_inout('in|inout')|count }}, {{ func.args_by_inout('inout|out|ret|stat')|count }}, PyUFunc_None,
+        "{{ func.pyname }}",
+        "UFunc wrapper for {{ func.name }}",
+        0, {% if func.signature -%} "{{ func.signature }}" {%- else -%} NULL {%- endif -%});
+    if (ufunc == NULL) {
+        goto fail;
+    }
+    {%- for arg in func.args_by_inout('in|inout') %}
+    dtypes[{{ loop.index - 1 }}] = {{ arg.dtype }};
+    {%- endfor %}
+    {%- for arg in func.args_by_inout('inout|out|ret|stat') %}
+    dtypes[{{ loop.index - 1 + func.args_by_inout('in|inout')|count }}] = {{ arg.dtype }};
+    {%- endfor %}
+    status = PyUFunc_RegisterLoopForDescr(
+        ufunc, {{ func.user_dtype }},
+        ufunc_loop_{{ func.pyname }}, dtypes, NULL);
+    if(status != 0){
+        Py_DECREF(ufunc);
+        goto fail;
+    }
+    {%- endif %}
+    {%- if func.signature and 'd3' in func.signature and not func.d3_fix_arg %}
+    ufunc->type_resolver = &ErfaUFuncD3CheckTypeResolver;
+    {%- else %}
+    ufunc->type_resolver = &ErfaUFuncTypeResolver;
+    {%- endif %}
+    PyDict_SetItemString(d, "{{ func.pyname }}", (PyObject *)ufunc);
+    Py_DECREF(ufunc);
+    {%- endfor %}
+
+    goto decref;
+
+fail:
+    Py_XDECREF(m);
+    m = NULL;
+
+decref:
+    Py_XDECREF(dt_double);
+    Py_XDECREF(dt_int);
+    Py_XDECREF(dt_pv);
+    Py_XDECREF(dt_pvdpv);
+    Py_XDECREF(dt_ymdf);
+    Py_XDECREF(dt_hmsf);
+    Py_XDECREF(dt_dmsf);
+    Py_XDECREF(dt_sign);
+    Py_XDECREF(dt_type);
+    Py_XDECREF(dt_eraASTROM);
+    Py_XDECREF(dt_eraLDBODY);
+    return m;
+}

testbed/astropy__astropy/astropy/astropy.cfg

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+
+### CONSOLE SETTINGS
+
+## Use Unicode characters when outputting values, and writing widgets to the
+## console.
+# unicode_output = False
+
+## When True, use ANSI color escape sequences when writing to the console.
+# use_color = True
+
+## Maximum number of lines for the pretty-printer.  If not provided,
+## determine automatically from the size of the terminal.  -1 means no
+## limit.
+# max_lines =
+
+## Maximum number of characters-per-line for the pretty-printer.  If
+## not provided, determine automatically from the size of the
+## terminal, if possible.  -1 means no limit.
+# max_width =
+
+
+### CORE DATA STRUCTURES AND TRANSFORMATIONS
+
+[nddata]
+
+## Whether to issue a warning if NDData arithmetic is performed with
+## uncertainties and the uncertainties do not support the propagation of
+## correlated uncertainties.
+# warn_unsupported_correlated = True
+
+## Whether to issue a warning when the `~astropy.nddata.NDData` unit
+## attribute is changed from a non-``None`` value to another value
+## that data values/uncertainties are not scaled with the unit change.
+# warn_setting_unit_directly = True
+
+[table]
+
+## The template that determines the name of a column if it cannot be
+## determined. Uses new-style (format method) string formatting
+# auto_colname = col{0}
+
+[table.jsviewer]
+
+## The URL to the jQuery library to use.  If not provided, uses the
+## internal copy installed with astropy.
+# jquery_url =
+
+## The URL to the jQuery datatables library to use.  If not provided,
+## uses the internal copy installed with astropy.
+# datatables_url =
+
+### ASTRONOMY COMPUTATIONS AND UTILITIES
+
+[samp]
+
+## Whether to allow astropy.samp to use the internet, if available
+# use_internet = True
+
+## How many times to retry communications when they fail
+# n_retries = 10
+
+
+### INPUT/OUTPUT
+
+[io.fits]
+
+## If True, enable support for record-valued keywords as described by FITS WCS
+## Paper IV. Otherwise they are treated as normal keywords.
+# enable_record_valued_keyword_cards = True
+
+## If True, extension names (i.e. the EXTNAME keyword) should be treated as
+## case-sensitive.
+# extension_name_case_sensitive = False
+
+## If True, automatically remove trailing whitespace for string values in
+## headers.  Otherwise the values are returned verbatim, with all whitespace
+## intact.
+# strip_header_whitespace = True
+
+## If True, use memory-mapped file access to read/write the data in FITS files.
+## This generally provides better performance, especially for large files, but
+## may affect performance in I/O-heavy applications.
+# use_memmap = True
+
+[io.votable]
+
+## When True, treat fixable violations of the VOTable spec as exceptions.
+# pedantic = True
+
+
+### NUTS AND BOLTS OF ASTROPY
+
+
+[logger]
+
+## Threshold for the logging messages. Logging messages that are less severe
+## than this level will be ignored. The levels are 'DEBUG', 'INFO', 'WARNING',
+## 'ERROR'
+# log_level = INFO
+
+## Whether to log warnings.warn calls
+# log_warnings = True
+
+## Whether to log exceptions before raising them
+# log_exceptions = False
+
+## Whether to always log messages to a log file
+# log_to_file = False
+
+## The file to log messages to. When '', it defaults to a file 'astropy.log' in
+## the astropy config directory.
+# log_file_path = ""
+
+## Threshold for logging messages to log_file_path
+# log_file_level = INFO
+
+## Format for log file entries
+# log_file_format = "%(asctime)r, %(origin)r, %(levelname)r, %(message)r"
+
+[utils.data]
+
+## URL for astropy remote data site.
+# dataurl = http://data.astropy.org/
+
+## Time to wait for remote data query (in seconds).
+# remote_timeout = 3.0
+
+## Block size for computing MD5 file hashes.
+# hash_block_size = 65536
+
+## Number of bytes of remote data to download per step.
+# download_block_size = 65536
+
+## Number of times to try to get the lock while accessing the data cache before
+## giving up.
+# download_cache_lock_attempts = 5
+
+## If True, temporary download files created when the cache is inacessible will
+## be deleted at the end of the python session.
+# delete_temporary_downloads_at_exit = True

testbed/astropy__astropy/astropy/conftest.py

@@ -0,0 +1,75 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+This file contains pytest configuration settings that are astropy-specific
+(i.e.  those that would not necessarily be shared by affiliated packages
+making use of astropy's test runner).
+"""
+import os
+import builtins
+import tempfile
+
+from astropy.tests.plugins.display import PYTEST_HEADER_MODULES
+from astropy.tests.helper import enable_deprecations_as_exceptions
+
+try:
+    import matplotlib
+except ImportError:
+    HAS_MATPLOTLIB = False
+else:
+    HAS_MATPLOTLIB = True
+
+enable_deprecations_as_exceptions(
+    include_astropy_deprecations=False,
+    # This is a workaround for the OpenSSL deprecation warning that comes from
+    # the `requests` module. It only appears when both asdf and sphinx are
+    # installed. This can be removed once pyopenssl 1.7.20+ is released.
+    modules_to_ignore_on_import=['requests'])
+
+if HAS_MATPLOTLIB:
+    matplotlib.use('Agg')
+
+matplotlibrc_cache = {}
+
+
+def pytest_configure(config):
+    builtins._pytest_running = True
+    # do not assign to matplotlibrc_cache in function scope
+    if HAS_MATPLOTLIB:
+        matplotlibrc_cache.update(matplotlib.rcParams)
+        matplotlib.rcdefaults()
+
+    # Make sure we use temporary directories for the config and cache
+    # so that the tests are insensitive to local configuration. Note that this
+    # is also set in the test runner, but we need to also set it here for
+    # things to work properly in parallel mode
+
+    builtins._xdg_config_home_orig = os.environ.get('XDG_CONFIG_HOME')
+    builtins._xdg_cache_home_orig = os.environ.get('XDG_CACHE_HOME')
+
+    os.environ['XDG_CONFIG_HOME'] = tempfile.mkdtemp('astropy_config')
+    os.environ['XDG_CACHE_HOME'] = tempfile.mkdtemp('astropy_cache')
+
+    os.mkdir(os.path.join(os.environ['XDG_CONFIG_HOME'], 'astropy'))
+    os.mkdir(os.path.join(os.environ['XDG_CACHE_HOME'], 'astropy'))
+
+
+def pytest_unconfigure(config):
+    builtins._pytest_running = False
+    # do not assign to matplotlibrc_cache in function scope
+    if HAS_MATPLOTLIB:
+        matplotlib.rcParams.update(matplotlibrc_cache)
+        matplotlibrc_cache.clear()
+
+    if builtins._xdg_config_home_orig is None:
+        os.environ.pop('XDG_CONFIG_HOME')
+    else:
+        os.environ['XDG_CONFIG_HOME'] = builtins._xdg_config_home_orig
+
+    if builtins._xdg_cache_home_orig is None:
+        os.environ.pop('XDG_CACHE_HOME')
+    else:
+        os.environ['XDG_CACHE_HOME'] = builtins._xdg_cache_home_orig
+
+
+PYTEST_HEADER_MODULES['Cython'] = 'cython'
+PYTEST_HEADER_MODULES['Scikit-image'] = 'skimage'

testbed/astropy__astropy/astropy/logger.py

@@ -0,0 +1,568 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""This module defines a logging class based on the built-in logging module"""
+
+import inspect
+import os
+import sys
+import logging
+import warnings
+from contextlib import contextmanager
+
+from . import config as _config
+from . import conf as _conf
+from .utils import find_current_module
+from .utils.exceptions import AstropyWarning, AstropyUserWarning
+
+__all__ = ['Conf', 'conf', 'log', 'AstropyLogger', 'LoggingError']
+
+# import the logging levels from logging so that one can do:
+# log.setLevel(log.DEBUG), for example
+logging_levels = ['NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL',
+                  'FATAL', ]
+for level in logging_levels:
+    globals()[level] = getattr(logging, level)
+__all__ += logging_levels
+
+
+# Initialize by calling _init_log()
+log = None
+
+
+class LoggingError(Exception):
+    """
+    This exception is for various errors that occur in the astropy logger,
+    typically when activating or deactivating logger-related features.
+    """
+
+
+class _AstLogIPYExc(Exception):
+    """
+    An exception that is used only as a placeholder to indicate to the
+    IPython exception-catching mechanism that the astropy
+    exception-capturing is activated. It should not actually be used as
+    an exception anywhere.
+    """
+
+
+class Conf(_config.ConfigNamespace):
+    """
+    Configuration parameters for `astropy.logger`.
+    """
+    log_level = _config.ConfigItem(
+        'INFO',
+        "Threshold for the logging messages. Logging "
+        "messages that are less severe than this level "
+        "will be ignored. The levels are ``'DEBUG'``, "
+        "``'INFO'``, ``'WARNING'``, ``'ERROR'``.")
+    log_warnings = _config.ConfigItem(
+        True,
+        "Whether to log `warnings.warn` calls.")
+    log_exceptions = _config.ConfigItem(
+        False,
+        "Whether to log exceptions before raising "
+        "them.")
+    log_to_file = _config.ConfigItem(
+        False,
+        "Whether to always log messages to a log "
+        "file.")
+    log_file_path = _config.ConfigItem(
+        '',
+        "The file to log messages to. When ``''``, "
+        "it defaults to a file ``'astropy.log'`` in "
+        "the astropy config directory.")
+    log_file_level = _config.ConfigItem(
+        'INFO',
+        "Threshold for logging messages to "
+        "`log_file_path`.")
+    log_file_format = _config.ConfigItem(
+        "%(asctime)r, "
+        "%(origin)r, %(levelname)r, %(message)r",
+        "Format for log file entries.")
+
+
+conf = Conf()
+
+
+def _init_log():
+    """Initializes the Astropy log--in most circumstances this is called
+    automatically when importing astropy.
+    """
+
+    global log
+
+    orig_logger_cls = logging.getLoggerClass()
+    logging.setLoggerClass(AstropyLogger)
+    try:
+        log = logging.getLogger('astropy')
+        log._set_defaults()
+    finally:
+        logging.setLoggerClass(orig_logger_cls)
+
+    return log
+
+
+def _teardown_log():
+    """Shut down exception and warning logging (if enabled) and clear all
+    Astropy loggers from the logging module's cache.
+
+    This involves poking some logging module internals, so much if it is 'at
+    your own risk' and is allowed to pass silently if any exceptions occur.
+    """
+
+    global log
+
+    if log.exception_logging_enabled():
+        log.disable_exception_logging()
+
+    if log.warnings_logging_enabled():
+        log.disable_warnings_logging()
+
+    del log
+
+    # Now for the fun stuff...
+    try:
+        logging._acquireLock()
+        try:
+            loggerDict = logging.Logger.manager.loggerDict
+            for key in loggerDict.keys():
+                if key == 'astropy' or key.startswith('astropy.'):
+                    del loggerDict[key]
+        finally:
+            logging._releaseLock()
+    except Exception:
+        pass
+
+
+Logger = logging.getLoggerClass()
+
+
+class AstropyLogger(Logger):
+    '''
+    This class is used to set up the Astropy logging.
+
+    The main functionality added by this class over the built-in
+    logging.Logger class is the ability to keep track of the origin of the
+    messages, the ability to enable logging of warnings.warn calls and
+    exceptions, and the addition of colorized output and context managers to
+    easily capture messages to a file or list.
+    '''
+
+    def makeRecord(self, name, level, pathname, lineno, msg, args, exc_info,
+                   func=None, extra=None, sinfo=None):
+        if extra is None:
+            extra = {}
+        if 'origin' not in extra:
+            current_module = find_current_module(1, finddiff=[True, 'logging'])
+            if current_module is not None:
+                extra['origin'] = current_module.__name__
+            else:
+                extra['origin'] = 'unknown'
+        return Logger.makeRecord(self, name, level, pathname, lineno, msg,
+                                 args, exc_info, func=func, extra=extra,
+                                 sinfo=sinfo)
+
+    _showwarning_orig = None
+
+    def _showwarning(self, *args, **kwargs):
+
+        # Bail out if we are not catching a warning from Astropy
+        if not isinstance(args[0], AstropyWarning):
+            return self._showwarning_orig(*args, **kwargs)
+
+        warning = args[0]
+        # Deliberately not using isinstance here: We want to display
+        # the class name only when it's not the default class,
+        # AstropyWarning.  The name of subclasses of AstropyWarning should
+        # be displayed.
+        if type(warning) not in (AstropyWarning, AstropyUserWarning):
+            message = '{0}: {1}'.format(warning.__class__.__name__, args[0])
+        else:
+            message = str(args[0])
+
+        mod_path = args[2]
+        # Now that we have the module's path, we look through sys.modules to
+        # find the module object and thus the fully-package-specified module
+        # name.  The module.__file__ is the original source file name.
+        mod_name = None
+        mod_path, ext = os.path.splitext(mod_path)
+        for name, mod in list(sys.modules.items()):
+            try:
+                # Believe it or not this can fail in some cases:
+                # https://github.com/astropy/astropy/issues/2671
+                path = os.path.splitext(getattr(mod, '__file__', ''))[0]
+            except Exception:
+                continue
+            if path == mod_path:
+                mod_name = mod.__name__
+                break
+
+        if mod_name is not None:
+            self.warning(message, extra={'origin': mod_name})
+        else:
+            self.warning(message)
+
+    def warnings_logging_enabled(self):
+        return self._showwarning_orig is not None
+
+    def enable_warnings_logging(self):
+        '''
+        Enable logging of warnings.warn() calls
+
+        Once called, any subsequent calls to ``warnings.warn()`` are
+        redirected to this logger and emitted with level ``WARN``. Note that
+        this replaces the output from ``warnings.warn``.
+
+        This can be disabled with ``disable_warnings_logging``.
+        '''
+        if self.warnings_logging_enabled():
+            raise LoggingError("Warnings logging has already been enabled")
+        self._showwarning_orig = warnings.showwarning
+        warnings.showwarning = self._showwarning
+
+    def disable_warnings_logging(self):
+        '''
+        Disable logging of warnings.warn() calls
+
+        Once called, any subsequent calls to ``warnings.warn()`` are no longer
+        redirected to this logger.
+
+        This can be re-enabled with ``enable_warnings_logging``.
+        '''
+        if not self.warnings_logging_enabled():
+            raise LoggingError("Warnings logging has not been enabled")
+        if warnings.showwarning != self._showwarning:
+            raise LoggingError("Cannot disable warnings logging: "
+                               "warnings.showwarning was not set by this "
+                               "logger, or has been overridden")
+        warnings.showwarning = self._showwarning_orig
+        self._showwarning_orig = None
+
+    _excepthook_orig = None
+
+    def _excepthook(self, etype, value, traceback):
+
+        if traceback is None:
+            mod = None
+        else:
+            tb = traceback
+            while tb.tb_next is not None:
+                tb = tb.tb_next
+            mod = inspect.getmodule(tb)
+
+        # include the the error type in the message.
+        if len(value.args) > 0:
+            message = '{0}: {1}'.format(etype.__name__, str(value))
+        else:
+            message = str(etype.__name__)
+
+        if mod is not None:
+            self.error(message, extra={'origin': mod.__name__})
+        else:
+            self.error(message)
+        self._excepthook_orig(etype, value, traceback)
+
+    def exception_logging_enabled(self):
+        '''
+        Determine if the exception-logging mechanism is enabled.
+
+        Returns
+        -------
+        exclog : bool
+            True if exception logging is on, False if not.
+        '''
+        try:
+            ip = get_ipython()
+        except NameError:
+            ip = None
+
+        if ip is None:
+            return self._excepthook_orig is not None
+        else:
+            return _AstLogIPYExc in ip.custom_exceptions
+
+    def enable_exception_logging(self):
+        '''
+        Enable logging of exceptions
+
+        Once called, any uncaught exceptions will be emitted with level
+        ``ERROR`` by this logger, before being raised.
+
+        This can be disabled with ``disable_exception_logging``.
+        '''
+        try:
+            ip = get_ipython()
+        except NameError:
+            ip = None
+
+        if self.exception_logging_enabled():
+            raise LoggingError("Exception logging has already been enabled")
+
+        if ip is None:
+            # standard python interpreter
+            self._excepthook_orig = sys.excepthook
+            sys.excepthook = self._excepthook
+        else:
+            # IPython has its own way of dealing with excepthook
+
+            # We need to locally define the function here, because IPython
+            # actually makes this a member function of their own class
+            def ipy_exc_handler(ipyshell, etype, evalue, tb, tb_offset=None):
+                # First use our excepthook
+                self._excepthook(etype, evalue, tb)
+
+                # Now also do IPython's traceback
+                ipyshell.showtraceback((etype, evalue, tb), tb_offset=tb_offset)
+
+            # now register the function with IPython
+            # note that we include _AstLogIPYExc so `disable_exception_logging`
+            # knows that it's disabling the right thing
+            ip.set_custom_exc((BaseException, _AstLogIPYExc), ipy_exc_handler)
+
+            # and set self._excepthook_orig to a no-op
+            self._excepthook_orig = lambda etype, evalue, tb: None
+
+    def disable_exception_logging(self):
+        '''
+        Disable logging of exceptions
+
+        Once called, any uncaught exceptions will no longer be emitted by this
+        logger.
+
+        This can be re-enabled with ``enable_exception_logging``.
+        '''
+        try:
+            ip = get_ipython()
+        except NameError:
+            ip = None
+
+        if not self.exception_logging_enabled():
+            raise LoggingError("Exception logging has not been enabled")
+
+        if ip is None:
+            # standard python interpreter
+            if sys.excepthook != self._excepthook:
+                raise LoggingError("Cannot disable exception logging: "
+                                   "sys.excepthook was not set by this logger, "
+                                   "or has been overridden")
+            sys.excepthook = self._excepthook_orig
+            self._excepthook_orig = None
+        else:
+            # IPython has its own way of dealing with exceptions
+            ip.set_custom_exc(tuple(), None)
+
+    def enable_color(self):
+        '''
+        Enable colorized output
+        '''
+        _conf.use_color = True
+
+    def disable_color(self):
+        '''
+        Disable colorized output
+        '''
+        _conf.use_color = False
+
+    @contextmanager
+    def log_to_file(self, filename, filter_level=None, filter_origin=None):
+        '''
+        Context manager to temporarily log messages to a file.
+
+        Parameters
+        ----------
+        filename : str
+            The file to log messages to.
+        filter_level : str
+            If set, any log messages less important than ``filter_level`` will
+            not be output to the file. Note that this is in addition to the
+            top-level filtering for the logger, so if the logger has level
+            'INFO', then setting ``filter_level`` to ``INFO`` or ``DEBUG``
+            will have no effect, since these messages are already filtered
+            out.
+        filter_origin : str
+            If set, only log messages with an origin starting with
+            ``filter_origin`` will be output to the file.
+
+        Notes
+        -----
+
+        By default, the logger already outputs log messages to a file set in
+        the Astropy configuration file. Using this context manager does not
+        stop log messages from being output to that file, nor does it stop log
+        messages from being printed to standard output.
+
+        Examples
+        --------
+
+        The context manager is used as::
+
+            with logger.log_to_file('myfile.log'):
+                # your code here
+        '''
+
+        fh = logging.FileHandler(filename)
+        if filter_level is not None:
+            fh.setLevel(filter_level)
+        if filter_origin is not None:
+            fh.addFilter(FilterOrigin(filter_origin))
+        f = logging.Formatter(conf.log_file_format)
+        fh.setFormatter(f)
+        self.addHandler(fh)
+        yield
+        fh.close()
+        self.removeHandler(fh)
+
+    @contextmanager
+    def log_to_list(self, filter_level=None, filter_origin=None):
+        '''
+        Context manager to temporarily log messages to a list.
+
+        Parameters
+        ----------
+        filename : str
+            The file to log messages to.
+        filter_level : str
+            If set, any log messages less important than ``filter_level`` will
+            not be output to the file. Note that this is in addition to the
+            top-level filtering for the logger, so if the logger has level
+            'INFO', then setting ``filter_level`` to ``INFO`` or ``DEBUG``
+            will have no effect, since these messages are already filtered
+            out.
+        filter_origin : str
+            If set, only log messages with an origin starting with
+            ``filter_origin`` will be output to the file.
+
+        Notes
+        -----
+
+        Using this context manager does not stop log messages from being
+        output to standard output.
+
+        Examples
+        --------
+
+        The context manager is used as::
+
+            with logger.log_to_list() as log_list:
+                # your code here
+        '''
+        lh = ListHandler()
+        if filter_level is not None:
+            lh.setLevel(filter_level)
+        if filter_origin is not None:
+            lh.addFilter(FilterOrigin(filter_origin))
+        self.addHandler(lh)
+        yield lh.log_list
+        self.removeHandler(lh)
+
+    def _set_defaults(self):
+        '''
+        Reset logger to its initial state
+        '''
+
+        # Reset any previously installed hooks
+        if self.warnings_logging_enabled():
+            self.disable_warnings_logging()
+        if self.exception_logging_enabled():
+            self.disable_exception_logging()
+
+        # Remove all previous handlers
+        for handler in self.handlers[:]:
+            self.removeHandler(handler)
+
+        # Set levels
+        self.setLevel(conf.log_level)
+
+        # Set up the stdout handler
+        sh = StreamHandler()
+        self.addHandler(sh)
+
+        # Set up the main log file handler if requested (but this might fail if
+        # configuration directory or log file is not writeable).
+        if conf.log_to_file:
+            log_file_path = conf.log_file_path
+
+            # "None" as a string because it comes from config
+            try:
+                _ASTROPY_TEST_
+                testing_mode = True
+            except NameError:
+                testing_mode = False
+
+            try:
+                if log_file_path == '' or testing_mode:
+                    log_file_path = os.path.join(
+                        _config.get_config_dir(), "astropy.log")
+                else:
+                    log_file_path = os.path.expanduser(log_file_path)
+
+                fh = logging.FileHandler(log_file_path)
+            except OSError as e:
+                warnings.warn(
+                    'log file {0!r} could not be opened for writing: '
+                    '{1}'.format(log_file_path, str(e)), RuntimeWarning)
+            else:
+                formatter = logging.Formatter(conf.log_file_format)
+                fh.setFormatter(formatter)
+                fh.setLevel(conf.log_file_level)
+                self.addHandler(fh)
+
+        if conf.log_warnings:
+            self.enable_warnings_logging()
+
+        if conf.log_exceptions:
+            self.enable_exception_logging()
+
+
+class StreamHandler(logging.StreamHandler):
+    """
+    A specialized StreamHandler that logs INFO and DEBUG messages to
+    stdout, and all other messages to stderr.  Also provides coloring
+    of the output, if enabled in the parent logger.
+    """
+
+    def emit(self, record):
+        '''
+        The formatter for stderr
+        '''
+        if record.levelno <= logging.INFO:
+            stream = sys.stdout
+        else:
+            stream = sys.stderr
+
+        if record.levelno < logging.DEBUG or not _conf.use_color:
+            print(record.levelname, end='', file=stream)
+        else:
+            # Import utils.console only if necessary and at the latest because
+            # the import takes a significant time [#4649]
+            from .utils.console import color_print
+            if record.levelno < logging.INFO:
+                color_print(record.levelname, 'magenta', end='', file=stream)
+            elif record.levelno < logging.WARN:
+                color_print(record.levelname, 'green', end='', file=stream)
+            elif record.levelno < logging.ERROR:
+                color_print(record.levelname, 'brown', end='', file=stream)
+            else:
+                color_print(record.levelname, 'red', end='', file=stream)
+        record.message = "{0} [{1:s}]".format(record.msg, record.origin)
+        print(": " + record.message, file=stream)
+
+
+class FilterOrigin:
+    '''A filter for the record origin'''
+
+    def __init__(self, origin):
+        self.origin = origin
+
+    def filter(self, record):
+        return record.origin.startswith(self.origin)
+
+
+class ListHandler(logging.Handler):
+    '''A handler that can be used to capture the records in a list'''
+
+    def __init__(self, filter_level=None, filter_origin=None):
+        logging.Handler.__init__(self)
+        self.log_list = []
+
+    def emit(self, record):
+        self.log_list.append(record)

testbed/astropy__astropy/astropy/setup_package.py

@@ -0,0 +1,18 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import os
+import glob
+
+
+def get_package_data():
+
+    # Find all files in data/ sub-directories since this is a standard location
+    # for data files. We then need to adjust the paths to be relative to here
+    # (otherwise glob will be evaluated relative to setup.py)
+    data_files = glob.glob('**/data/**/*', recursive=True)
+    data_files = [os.path.relpath(x, os.path.dirname(__file__)) for x in data_files]
+
+    # Glob doesn't recognize hidden files
+    data_files.append('utils/tests/data/.hidden_file.txt')
+
+    return {'astropy': ['astropy.cfg', 'CITATION'] + data_files}

testbed/astropy__astropy/astropy/timeseries/__init__.py

@@ -0,0 +1,12 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+"""
+This subpackage contains classes and functions for work with time series.
+"""
+
+from astropy.timeseries.core import *  # noqa
+from astropy.timeseries.sampled import *  # noqa
+from astropy.timeseries.binned import *  # noqa
+from astropy.timeseries import io  # noqa
+from astropy.timeseries.downsample import *  # noqa
+from astropy.timeseries.periodograms import *  # noqa

testbed/astropy__astropy/astropy/timeseries/binned.py

@@ -0,0 +1,334 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from copy import deepcopy
+
+import numpy as np
+
+from astropy.table import groups, Table, QTable
+from astropy.time import Time, TimeDelta
+from astropy import units as u
+from astropy.units import Quantity
+from astropy.utils.misc import InheritDocstrings
+
+from astropy.timeseries.core import BaseTimeSeries, autocheck_required_columns
+
+__all__ = ['BinnedTimeSeries']
+
+
+@autocheck_required_columns
+class BinnedTimeSeries(BaseTimeSeries, metaclass=InheritDocstrings):
+    """
+    A class to represent binned time series data in tabular form.
+
+    `~astropy.timeseries.BinnedTimeSeries` provides a class for representing
+    time series as a collection of values of different quantities measured in
+    time bins (for time series with values sampled at specific times, see the
+    `~astropy.timeseries.TimeSeries` class).
+    `~astropy.timeseries.BinnedTimeSeries` is a sub-class of `~astropy.table.QTable`
+    and thus provides all the standard table maniplation methods available to
+    tables, but it also provides additional conveniences for dealing with time
+    series, such as a flexible initializer for setting up the times, and
+    attributes to access the start/center/end time of bins.
+
+    See also: http://docs.astropy.org/en/stable/timeseries/
+
+    Parameters
+    ----------
+    data : numpy ndarray, dict, list, Table, or table-like object, optional
+        Data to initialize time series. This does not need to contain the times,
+        which can be provided separately, but if it does contain the times they
+        should be in columns called ``'time_bin_start'`` and ``'time_bin_size'``
+        to be automatically recognized.
+    time_bin_start : `~astropy.time.Time` or iterable
+        The times of the start of each bin - this can be either given
+        directly as a `~astropy.time.Time` array or as any iterable that
+        initializes the `~astropy.time.Time` class. If this is given, then
+        the remaining time-related arguments should not be used. This can also
+        be a scalar value if ``time_bin_size`` is provided.
+    time_bin_end : `~astropy.time.Time` or iterable
+        The times of the end of each bin - this can be either given directly as
+        a `~astropy.time.Time` array or as any value or iterable that
+        initializes the `~astropy.time.Time` class. If this is given, then the
+        remaining time-related arguments should not be used. This can only be
+        given if ``time_bin_start`` is an array of values. If ``time_bin_end``
+        is a scalar, time bins are assumed to be contiguous, such that the end
+        of each bin is the start of the next one, and ``time_bin_end`` gives the
+        end time for the last bin. If ``time_bin_end`` is an array, the time
+        bins do not need to be contiguous. If this argument is provided,
+        ``time_bin_size`` should not be provided.
+    time_bin_size : `~astropy.time.TimeDelta` or `~astropy.units.Quantity`
+        The size of the time bins, either as a scalar value (in which case all
+        time bins will be assumed to have the same duration) or as an array of
+        values (in which case each time bin can have a different duration).
+        If this argument is provided, ``time_bin_end`` should not be provided.
+    n_bins : int
+        The number of time bins for the series. This is only used if both
+        ``time_bin_start`` and ``time_bin_size`` are provided and are scalar
+        values.
+    **kwargs : dict, optional
+        Additional keyword arguments are passed to `~astropy.table.QTable`.
+    """
+
+    _required_columns = ['time_bin_start', 'time_bin_size']
+
+    def __init__(self, data=None, *, time_bin_start=None, time_bin_end=None,
+                 time_bin_size=None, n_bins=None, **kwargs):
+
+        super().__init__(data=data, **kwargs)
+
+        # For some operations, an empty time series needs to be created, then
+        # columns added one by one. We should check that when columns are added
+        # manually, time is added first and is of the right type.
+        if (data is None and time_bin_start is None and time_bin_end is None and
+                time_bin_size is None and n_bins is None):
+            self._required_columns_relax = True
+            return
+
+        # First if time_bin_start and time_bin_end have been given in the table data, we
+        # should extract them and treat them as if they had been passed as
+        # keyword arguments.
+
+        if 'time_bin_start' in self.colnames:
+            if time_bin_start is None:
+                time_bin_start = self.columns['time_bin_start']
+            else:
+                raise TypeError("'time_bin_start' has been given both in the table "
+                                "and as a keyword argument")
+
+        if 'time_bin_size' in self.colnames:
+            if time_bin_size is None:
+                time_bin_size = self.columns['time_bin_size']
+            else:
+                raise TypeError("'time_bin_size' has been given both in the table "
+                                "and as a keyword argument")
+
+        if time_bin_start is None:
+            raise TypeError("'time_bin_start' has not been specified")
+
+        if time_bin_end is None and time_bin_size is None:
+            raise TypeError("Either 'time_bin_size' or 'time_bin_end' should be specified")
+
+        if not isinstance(time_bin_start, Time):
+            time_bin_start = Time(time_bin_start)
+
+        if time_bin_end is not None and not isinstance(time_bin_end, Time):
+            time_bin_end = Time(time_bin_end)
+
+        if time_bin_size is not None and not isinstance(time_bin_size, (Quantity, TimeDelta)):
+            raise TypeError("'time_bin_size' should be a Quantity or a TimeDelta")
+
+        if isinstance(time_bin_size, TimeDelta):
+            time_bin_size = time_bin_size.sec * u.s
+
+        if time_bin_start.isscalar:
+
+            # We interpret this as meaning that this is the start of the
+            # first bin and that the bins are contiguous. In this case,
+            # we require time_bin_size to be specified.
+
+            if time_bin_size is None:
+                raise TypeError("'time_bin_start' is scalar, so 'time_bin_size' is required")
+
+            if time_bin_size.isscalar:
+                if data is not None:
+                    if n_bins is not None:
+                        if n_bins != len(self):
+                            raise TypeError("'n_bins' has been given and it is not the "
+                                            "same length as the input data.")
+                    else:
+                        n_bins = len(self)
+
+                time_bin_size = np.repeat(time_bin_size, n_bins)
+
+            time_delta = np.cumsum(time_bin_size)
+            time_bin_end = time_bin_start + time_delta
+
+            # Now shift the array so that the first entry is 0
+            time_delta = np.roll(time_delta, 1)
+            time_delta[0] = 0. * u.s
+
+            # Make time_bin_start into an array
+            time_bin_start = time_bin_start + time_delta
+
+        else:
+
+            if len(self.colnames) > 0 and len(time_bin_start) != len(self):
+                raise ValueError("Length of 'time_bin_start' ({0}) should match "
+                                 "table length ({1})".format(len(time_bin_start), len(self)))
+
+            if time_bin_end is not None:
+                if time_bin_end.isscalar:
+                    times = time_bin_start.copy()
+                    times[:-1] = times[1:]
+                    times[-1] = time_bin_end
+                    time_bin_end = times
+                time_bin_size = (time_bin_end - time_bin_start).sec * u.s
+
+        if time_bin_size.isscalar:
+            time_bin_size = np.repeat(time_bin_size, len(self))
+
+        with self._delay_required_column_checks():
+
+            if 'time_bin_start' in self.colnames:
+                self.remove_column('time_bin_start')
+
+            if 'time_bin_size' in self.colnames:
+                self.remove_column('time_bin_size')
+
+            self.add_column(time_bin_start, index=0, name='time_bin_start')
+            self.add_index('time_bin_start')
+            self.add_column(time_bin_size, index=1, name='time_bin_size')
+
+    @property
+    def time_bin_start(self):
+        """
+        The start times of all the time bins.
+        """
+        return self['time_bin_start']
+
+    @property
+    def time_bin_center(self):
+        """
+        The center times of all the time bins.
+        """
+        return self['time_bin_start'] + self['time_bin_size'] * 0.5
+
+    @property
+    def time_bin_end(self):
+        """
+        The end times of all the time bins.
+        """
+        return self['time_bin_start'] + self['time_bin_size']
+
+    @property
+    def time_bin_size(self):
+        """
+        The sizes of all the time bins.
+        """
+        return self['time_bin_size']
+
+    def __getitem__(self, item):
+        if self._is_list_or_tuple_of_str(item):
+            if 'time_bin_start' not in item or 'time_bin_size' not in item:
+                out = QTable([self[x] for x in item],
+                             meta=deepcopy(self.meta),
+                             copy_indices=self._copy_indices)
+                out._groups = groups.TableGroups(out, indices=self.groups._indices,
+                                                 keys=self.groups._keys)
+                return out
+        return super().__getitem__(item)
+
+    @classmethod
+    def read(self, filename, time_bin_start_column=None, time_bin_end_column=None,
+             time_bin_size_column=None, time_bin_size_unit=None, time_format=None, time_scale=None,
+             format=None, *args, **kwargs):
+        """
+        Read and parse a file and returns a `astropy.timeseries.BinnedTimeSeries`.
+
+        This method uses the unified I/O infrastructure in Astropy which makes
+        it easy to define readers/writers for various classes
+        (http://docs.astropy.org/en/stable/io/unified.html). By default, this
+        method will try and use readers defined specifically for the
+        `astropy.timeseries.BinnedTimeSeries` class - however, it is also
+        possible to use the ``format`` keyword to specify formats defined for
+        the `astropy.table.Table` class - in this case, you will need to also
+        provide the column names for column containing the start times for the
+        bins, as well as other column names (see the Parameters section below
+        for details)::
+
+            >>> from astropy.timeseries.binned import BinnedTimeSeries
+            >>> ts = BinnedTimeSeries.read('binned.dat', format='ascii.ecsv',
+            ...                            time_bin_start_column='date_start',
+            ...                            time_bin_end_column='date_end')  # doctest: +SKIP
+
+        Parameters
+        ----------
+        filename : str
+            File to parse.
+        format : str
+            File format specifier.
+        time_bin_start_column : str
+            The name of the column with the start time for each bin.
+        time_bin_end_column : str, optional
+            The name of the column with the end time for each bin. Either this
+            option or ``time_bin_size_column`` should be specified.
+        time_bin_size_column : str, optional
+            The name of the column with the size for each bin. Either this
+            option or ``time_bin_end_column`` should be specified.
+        time_bin_size_unit : `astropy.units.Unit`, optional
+            If ``time_bin_size_column`` is specified but does not have a unit
+            set in the table, you can specify the unit manually.
+        time_format : str, optional
+            The time format for the start and end columns.
+        time_scale : str, optional
+            The time scale for the start and end columns.
+        *args : tuple, optional
+            Positional arguments passed through to the data reader.
+        **kwargs : dict, optional
+            Keyword arguments passed through to the data reader.
+
+        Returns
+        -------
+        out : `astropy.timeseries.binned.BinnedTimeSeries`
+            BinnedTimeSeries corresponding to the file.
+
+        """
+
+        try:
+
+            # First we try the readers defined for the BinnedTimeSeries class
+            return super().read(filename, format=format, *args, **kwargs)
+
+        except TypeError:
+
+            # Otherwise we fall back to the default Table readers
+
+            if time_bin_start_column is None:
+                raise ValueError("``time_bin_start_column`` should be provided since the default Table readers are being used.")
+            if time_bin_end_column is None and time_bin_size_column is None:
+                raise ValueError("Either `time_bin_end_column` or `time_bin_size_column` should be provided.")
+            elif time_bin_end_column is not None and time_bin_size_column is not None:
+                raise ValueError("Cannot specify both `time_bin_end_column` and `time_bin_size_column`.")
+
+            table = Table.read(filename, format=format, *args, **kwargs)
+
+            if time_bin_start_column in table.colnames:
+                time_bin_start = Time(table.columns[time_bin_start_column],
+                                      scale=time_scale, format=time_format)
+                table.remove_column(time_bin_start_column)
+            else:
+                raise ValueError("Bin start time column '{}' not found in the input data.".format(time_bin_start_column))
+
+            if time_bin_end_column is not None:
+
+                if time_bin_end_column in table.colnames:
+                    time_bin_end = Time(table.columns[time_bin_end_column],
+                                        scale=time_scale, format=time_format)
+                    table.remove_column(time_bin_end_column)
+                else:
+                    raise ValueError("Bin end time column '{}' not found in the input data.".format(time_bin_end_column))
+
+                time_bin_size = None
+
+            elif time_bin_size_column is not None:
+
+                if time_bin_size_column in table.colnames:
+                    time_bin_size = table.columns[time_bin_size_column]
+                    table.remove_column(time_bin_size_column)
+                else:
+                    raise ValueError("Bin size column '{}' not found in the input data.".format(time_bin_size_column))
+
+                if time_bin_size.unit is None:
+                    if time_bin_size_unit is None or not isinstance(time_bin_size_unit, u.UnitBase):
+                        raise ValueError("The bin size unit should be specified as an astropy Unit using ``time_bin_size_unit``.")
+                    time_bin_size = time_bin_size * time_bin_size_unit
+                else:
+                    time_bin_size = u.Quantity(time_bin_size)
+
+                time_bin_end = None
+
+            return BinnedTimeSeries(data=table,
+                                    time_bin_start=time_bin_start,
+                                    time_bin_end=time_bin_end,
+                                    time_bin_size=time_bin_size,
+                                    n_bins=len(table))

testbed/astropy__astropy/astropy/timeseries/core.py

@@ -0,0 +1,92 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from types import FunctionType
+from contextlib import contextmanager
+from functools import wraps
+
+from astropy.table import QTable
+
+__all__ = ['BaseTimeSeries', 'autocheck_required_columns']
+
+COLUMN_RELATED_METHODS = ['add_column',
+                          'add_columns',
+                          'keep_columns',
+                          'remove_column',
+                          'remove_columns',
+                          'rename_column']
+
+
+def autocheck_required_columns(cls):
+    """
+    This is a decorator that ensures that the table contains specific
+    methods indicated by the _required_columns attribute. The aim is to
+    decorate all methods that might affect the columns in the table and check
+    for consistency after the methods have been run.
+    """
+
+    def decorator_method(method):
+
+        @wraps(method)
+        def wrapper(self, *args, **kwargs):
+            result = method(self, *args, **kwargs)
+            self._check_required_columns()
+            return result
+
+        return wrapper
+
+    for name in COLUMN_RELATED_METHODS:
+        if (not hasattr(cls, name) or
+                not isinstance(getattr(cls, name), FunctionType)):
+            raise ValueError("{0} is not a valid method".format(name))
+        setattr(cls, name, decorator_method(getattr(cls, name)))
+
+    return cls
+
+
+class BaseTimeSeries(QTable):
+
+    _required_columns = None
+    _required_columns_enabled = True
+
+    # If _required_column_relax is True, we don't require the columns to be
+    # present but we do require them to be the correct ones IF present. Note
+    # that this is a temporary state - as soon as the required columns
+    # are all present, we toggle this to False
+    _required_columns_relax = False
+
+    def _check_required_columns(self):
+
+        if not self._required_columns_enabled:
+            return
+
+        if self._required_columns is not None:
+
+            if self._required_columns_relax:
+                required_columns = self._required_columns[:len(self.colnames)]
+            else:
+                required_columns = self._required_columns
+
+            plural = 's' if len(required_columns) > 1 else ''
+
+            if not self._required_columns_relax and len(self.colnames) == 0:
+
+                raise ValueError("{0} object is invalid - expected '{1}' "
+                                 "as the first column{2} but time series has no columns"
+                                 .format(self.__class__.__name__, required_columns[0], plural))
+
+            elif self.colnames[:len(required_columns)] != required_columns:
+
+                raise ValueError("{0} object is invalid - expected '{1}' "
+                                 "as the first column{2} but found '{3}'"
+                                 .format(self.__class__.__name__, required_columns[0], plural, self.colnames[0]))
+
+            if (self._required_columns_relax
+                    and self._required_columns == self.colnames[:len(self._required_columns)]):
+                self._required_columns_relax = False
+
+    @contextmanager
+    def _delay_required_column_checks(self):
+        self._required_columns_enabled = False
+        yield
+        self._required_columns_enabled = True
+        self._check_required_columns()

testbed/astropy__astropy/astropy/timeseries/downsample.py

@@ -0,0 +1,137 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import warnings
+
+import numpy as np
+from astropy import units as u
+from astropy.utils.exceptions import AstropyUserWarning
+
+from astropy.timeseries.sampled import TimeSeries
+from astropy.timeseries.binned import BinnedTimeSeries
+
+__all__ = ['aggregate_downsample']
+
+
+def reduceat(array, indices, function):
+    """
+    Manual reduceat functionality for cases where Numpy functions don't have a reduceat.
+    It will check if the input function has a reduceat and call that if it does.
+    """
+    if hasattr(function, 'reduceat'):
+        return np.array(function.reduceat(array, indices))
+    else:
+        result = []
+        for i in range(len(indices) - 1):
+            if indices[i+1] <= indices[i]+1:
+                result.append(function(array[indices[i]]))
+            else:
+                result.append(function(array[indices[i]:indices[i+1]]))
+        result.append(function(array[indices[-1]:]))
+        return np.array(result)
+
+
+def aggregate_downsample(time_series, *, time_bin_size=None, time_bin_start=None,
+                      n_bins=None, aggregate_func=None):
+    """
+    Downsample a time series by binning values into bins with a fixed size,
+    using a single function to combine the values in the bin.
+
+    Parameters
+    ----------
+    time_series : :class:`~astropy.timeseries.TimeSeries`
+        The time series to downsample.
+    time_bin_size : `~astropy.units.Quantity`
+        The time interval for the binned time series.
+    time_bin_start : `~astropy.time.Time`, optional
+        The start time for the binned time series. Defaults to the first
+        time in the sampled time series.
+    n_bins : int, optional
+        The number of bins to use. Defaults to the number needed to fit all
+        the original points.
+    aggregate_func : callable, optional
+        The function to use for combining points in the same bin. Defaults
+        to np.nanmean.
+
+    Returns
+    -------
+    binned_time_series : :class:`~astropy.timeseries.BinnedTimeSeries`
+        The downsampled time series.
+    """
+
+    if not isinstance(time_series, TimeSeries):
+        raise TypeError("time_series should be a TimeSeries")
+
+    if not isinstance(time_bin_size, u.Quantity):
+        raise TypeError("time_bin_size should be a astropy.unit quantity")
+
+    bin_size_sec = time_bin_size.to_value(u.s)
+
+    # Use the table sorted by time
+    sorted = time_series.iloc[:]
+
+    # Determine start time if needed
+    if time_bin_start is None:
+        time_bin_start = sorted.time[0]
+
+    # Find the relative time since the start time, in seconds
+    relative_time_sec = (sorted.time - time_bin_start).sec
+
+    # Determine the number of bins if needed
+    if n_bins is None:
+        n_bins = int(np.ceil(relative_time_sec[-1] / bin_size_sec))
+
+    if aggregate_func is None:
+        aggregate_func = np.nanmean
+
+    # Determine the bins
+    relative_bins_sec = np.cumsum(np.hstack([0, np.repeat(bin_size_sec, n_bins)]))
+    bins = time_bin_start + relative_bins_sec * u.s
+
+    # Find the subset of the table that is inside the bins
+    keep = ((relative_time_sec >= relative_bins_sec[0]) &
+            (relative_time_sec < relative_bins_sec[-1]))
+    subset = sorted[keep]
+
+    # Figure out which bin each row falls in - the -1 is because items
+    # falling in the first bins will have index 1 but we want that to be 0
+    indices = np.searchsorted(relative_bins_sec, relative_time_sec[keep]) - 1
+    # Add back the first time.
+    indices[relative_time_sec[keep] == relative_bins_sec[0]] = 0
+
+    # Create new binned time series
+    binned = BinnedTimeSeries(time_bin_start=bins[:-1], time_bin_end=bins[-1])
+
+    # Determine rows where values are defined
+    groups = np.hstack([0, np.nonzero(np.diff(indices))[0] + 1])
+
+    # Find unique indices to determine which rows in the final time series
+    # will not be empty.
+    unique_indices = np.unique(indices)
+
+    # Add back columns
+
+    for colname in subset.colnames:
+
+        if colname == 'time':
+            continue
+
+        values = subset[colname]
+
+        # FIXME: figure out how to avoid the following, if possible
+        if not isinstance(values, (np.ndarray, u.Quantity)):
+            warnings.warn("Skipping column {0} since it has a mix-in type", AstropyUserWarning)
+            continue
+
+        if isinstance(values, u.Quantity):
+            data = u.Quantity(np.repeat(np.nan,  n_bins), unit=values.unit)
+            data[unique_indices] = u.Quantity(reduceat(values.value, groups, aggregate_func),
+                                              values.unit, copy=False)
+        else:
+            data = np.ma.zeros(n_bins, dtype=values.dtype)
+            data.mask = 1
+            data[unique_indices] = reduceat(values, groups, aggregate_func)
+            data.mask[unique_indices] = 0
+
+        binned[colname] = data
+
+    return binned

testbed/astropy__astropy/astropy/timeseries/io/__init__.py

@@ -0,0 +1,3 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from .kepler import *

testbed/astropy__astropy/astropy/timeseries/io/kepler.py

@@ -0,0 +1,93 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+import warnings
+
+import numpy as np
+
+from astropy.io import registry, fits
+from astropy.table import Table
+from astropy.time import Time, TimeDelta
+
+from astropy.timeseries.sampled import TimeSeries
+
+__all__ = ["kepler_fits_reader"]
+
+
+def kepler_fits_reader(filename):
+    """
+    This serves as the FITS reader for KEPLER or TESS files within
+    astropy-timeseries.
+
+    This function should generally not be called directly, and instead this
+    time series reader should be accessed with the
+    :meth:`~astropy.timeseries.TimeSeries.read` method::
+
+        >>> from astropy.timeseries import TimeSeries
+        >>> ts = TimeSeries.read('kplr33122.fits', format='kepler.fits')  # doctest: +SKIP
+
+    Parameters
+    ----------
+    filename : `str` or `pathlib.Path`
+        File to load.
+
+    Returns
+    -------
+    ts : `~astropy.timeseries.TimeSeries`
+        Data converted into a TimeSeries.
+    """
+    hdulist = fits.open(filename)
+    # Get the lightcurve HDU
+    telescope = hdulist[0].header['telescop'].lower()
+
+    if telescope == 'tess':
+        hdu = hdulist['LIGHTCURVE']
+    elif telescope == 'kepler':
+        hdu = hdulist[1]
+    else:
+        raise NotImplementedError("{} is not implemented, only KEPLER or TESS are "
+                                  "supported through this reader".format(hdulist[0].header['telescop']))
+
+    if hdu.header['EXTVER'] > 1:
+        raise NotImplementedError("Support for {0} v{1} files not yet "
+                                  "implemented".format(hdu.header['TELESCOP'], hdu.header['EXTVER']))
+
+    # Check time scale
+    if hdu.header['TIMESYS'] != 'TDB':
+        raise NotImplementedError("Support for {0} time scale not yet "
+                                  "implemented in {1} reader".format(hdu.header['TIMESYS'], hdu.header['TELESCOP']))
+
+    tab = Table.read(hdu, format='fits')
+
+    # Some KEPLER files have a T column instead of TIME.
+    if "T" in tab.colnames:
+        tab.rename_column("T", "TIME")
+
+    for colname in tab.colnames:
+        # Fix units
+        if tab[colname].unit == 'e-/s':
+            tab[colname].unit = 'electron/s'
+        if tab[colname].unit == 'pixels':
+            tab[colname].unit = 'pixel'
+
+        # Rename columns to lowercase
+        tab.rename_column(colname, colname.lower())
+
+    # Filter out NaN rows
+    nans = np.isnan(tab['time'].data)
+    if np.any(nans):
+        warnings.warn('Ignoring {0} rows with NaN times'.format(np.sum(nans)))
+    tab = tab[~nans]
+
+    # Time column is dependent on source and we correct it here
+    reference_date = Time(hdu.header['BJDREFI'], hdu.header['BJDREFF'],
+                          scale=hdu.header['TIMESYS'].lower(), format='jd')
+    time = reference_date + TimeDelta(tab['time'].data)
+    time.format = 'isot'
+
+    # Remove original time column
+    tab.remove_column('time')
+
+    return TimeSeries(time=time, data=tab)
+
+
+registry.register_reader('kepler.fits', TimeSeries, kepler_fits_reader)
+registry.register_reader('tess.fits', TimeSeries, kepler_fits_reader)

testbed/astropy__astropy/astropy/timeseries/io/tests/__init__.py

@@ -0,0 +1 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst

testbed/astropy__astropy/astropy/timeseries/io/tests/test_kepler.py

@@ -0,0 +1,88 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+from unittest import mock
+
+import pytest
+
+from astropy.io.fits import HDUList, Header, PrimaryHDU, BinTableHDU
+from astropy.utils.data import get_pkg_data_filename
+
+from astropy.timeseries.io.kepler import kepler_fits_reader
+
+
+def fake_header(extver, version, timesys, telescop):
+    return Header({"SIMPLE": "T",
+                   "BITPIX": 8,
+                   "NAXIS": 0,
+                   "EXTVER": extver,
+                   "VERSION": version,
+                   'TIMESYS': "{}".format(timesys),
+                   "TELESCOP": "{}".format(telescop)})
+
+
+def fake_hdulist(extver=1, version=2, timesys="TDB", telescop="KEPLER"):
+    new_header = fake_header(extver, version, timesys, telescop)
+    return [HDUList(hdus=[PrimaryHDU(header=new_header),
+                    BinTableHDU(header=new_header, name="LIGHTCURVE")])]
+
+
+@mock.patch("astropy.io.fits.open", side_effect=fake_hdulist(telescop="MadeUp"))
+def test_raise_telescop_wrong(mock_file):
+    with pytest.raises(NotImplementedError) as exc:
+        kepler_fits_reader(None)
+    assert exc.value.args[0] == ("MadeUp is not implemented, only KEPLER or TESS are "
+                                 "supported through this reader")
+
+
+@mock.patch("astropy.io.fits.open", side_effect=fake_hdulist(extver=2))
+def test_raise_extversion_kepler(mock_file):
+    with pytest.raises(NotImplementedError) as exc:
+        kepler_fits_reader(None)
+    assert exc.value.args[0] == ("Support for KEPLER v2 files not yet "
+                                 "implemented")
+
+
+@mock.patch("astropy.io.fits.open", side_effect=fake_hdulist(extver=2, telescop="TESS"))
+def test_raise_extversion_tess(mock_file):
+    with pytest.raises(NotImplementedError) as exc:
+        kepler_fits_reader(None)
+    assert exc.value.args[0] == ("Support for TESS v2 files not yet "
+                                 "implemented")
+
+
+@mock.patch("astropy.io.fits.open", side_effect=fake_hdulist(timesys="TCB"))
+def test_raise_timesys_kepler(mock_file):
+    with pytest.raises(NotImplementedError) as exc:
+        kepler_fits_reader(None)
+    assert exc.value.args[0] == ("Support for TCB time scale not yet "
+                                 "implemented in KEPLER reader")
+
+
+@mock.patch("astropy.io.fits.open", side_effect=fake_hdulist(timesys="TCB", telescop="TESS"))
+def test_raise_timesys_tess(mock_file):
+    with pytest.raises(NotImplementedError) as exc:
+        kepler_fits_reader(None)
+    assert exc.value.args[0] == ("Support for TCB time scale not yet "
+                                 "implemented in TESS reader")
+
+
+@pytest.mark.remote_data(source='astropy')
+def test_kepler_astropy():
+    filename = get_pkg_data_filename('timeseries/kplr010666592-2009131110544_slc.fits')
+    timeseries = kepler_fits_reader(filename)
+    assert timeseries["time"].format == 'isot'
+    assert timeseries["time"].scale == 'tdb'
+    assert timeseries["sap_flux"].unit.to_string() == 'electron / s'
+    assert len(timeseries) == 14280
+    assert len(timeseries.columns) == 20
+
+
+@pytest.mark.remote_data(source='astropy')
+def test_tess_astropy():
+    filename = get_pkg_data_filename('timeseries/hlsp_tess-data-alerts_tess_phot_00025155310-s01_tess_v1_lc.fits')
+    timeseries = kepler_fits_reader(filename)
+    assert timeseries["time"].format == 'isot'
+    assert timeseries["time"].scale == 'tdb'
+    assert timeseries["sap_flux"].unit.to_string() == 'electron / s'
+    assert len(timeseries) == 19261
+    assert len(timeseries.columns) == 20

testbed/astropy__astropy/astropy/timeseries/periodograms/__init__.py

@@ -0,0 +1,3 @@
+from astropy.timeseries.periodograms.base import *  # noqa
+from astropy.timeseries.periodograms.lombscargle import *  # noqa
+from astropy.timeseries.periodograms.bls import *  # noqa

testbed/astropy__astropy/astropy/timeseries/periodograms/base.py

@@ -0,0 +1,56 @@
+import abc
+import numpy as np
+from astropy.timeseries import TimeSeries, BinnedTimeSeries
+
+__all__ = ['BasePeriodogram']
+
+
+class BasePeriodogram:
+
+    @abc.abstractmethod
+    def __init__(self, t, y, dy=None):
+        pass
+
+    @classmethod
+    def from_timeseries(cls, timeseries, signal_column_name=None, uncertainty=None, **kwargs):
+        """
+        Initialize a periodogram from a time series object.
+
+        If a binned time series is passed, the time at the center of the bins is
+        used. Also note that this method automatically gets rid of NaN/undefined
+        values when initalizing the periodogram.
+
+        Parameters
+        ----------
+        signal_column_name : str
+            The name of the column containing the signal values to use.
+        uncertainty : str or float or `~astropy.units.Quantity`, optional
+            The name of the column containing the errors on the signal, or the
+            value to use for the error, if a scalar.
+        **kwargs
+            Additional keyword arguments are passed to the initializer for this
+            periodogram class.
+        """
+
+        if signal_column_name is None:
+            raise ValueError('signal_column_name should be set to a valid column name')
+
+        y = timeseries[signal_column_name]
+        keep = ~np.isnan(y)
+
+        if isinstance(uncertainty, str):
+            dy = timeseries[uncertainty]
+            keep &= ~np.isnan(dy)
+            dy = dy[keep]
+        else:
+            dy = uncertainty
+
+        if isinstance(timeseries, TimeSeries):
+            time = timeseries.time
+        elif isinstance(timeseries, BinnedTimeSeries):
+            time = timeseries.time_bin_center
+        else:
+            raise TypeError('Input time series should be an instance of '
+                            'TimeSeries or BinnedTimeSeries')
+
+        return cls(time[keep], y[keep], dy=dy, **kwargs)

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/__init__.py

@@ -0,0 +1,14 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+"""
+Box Least Squares
+=================
+
+AstroPy-compatible reference implementation of the transit periorogram used
+to discover transiting exoplanets.
+
+"""
+
+__all__ = ["BoxLeastSquares", "BoxLeastSquaresResults"]
+
+from .core import BoxLeastSquares, BoxLeastSquaresResults

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/_impl.pyx

@@ -0,0 +1,96 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+#cython: language_level=3
+
+import numpy as np
+cimport numpy as np
+
+cimport cython
+
+from libc.math cimport sqrt
+from libc.stdlib cimport malloc, free
+
+DTYPE = np.float64
+ctypedef np.float64_t DTYPE_t
+
+IDTYPE = np.int64
+ctypedef np.int64_t IDTYPE_t
+
+cdef extern int run_bls (
+    int N,                   # Length of the time array
+    double* t,               # The list of timestamps
+    double* y,               # The y measured at ``t``
+    double* ivar,            # The inverse variance of the y array
+
+    int n_periods,           #
+    double* periods,         # The period to test in units of ``t``
+
+    int n_durations,         # Length of the durations array
+    double* durations,       # The durations to test in units of ``bin_duration``
+    int oversample,          # The number of ``bin_duration`` bins in the maximum duration
+
+    int obj_flag,            # A flag indicating the periodogram type
+                             # 0 - depth signal-to-noise
+                             # 1 - log likelihood
+
+    # Outputs
+    double* best_objective,  # The value of the periodogram at maximum
+    double* best_depth,      # The estimated depth at maximum
+    double* best_depth_std,  # The uncertainty on ``best_depth``
+    double* best_duration,   # The best fitting duration in units of ``t``
+    double* best_phase,      # The phase of the mid-transit time in units of
+                             # ``t``
+    double* best_depth_snr,  # The signal-to-noise ratio of the depth estimate
+    double* best_log_like    # The log likelihood at maximum
+) nogil
+
+
+@cython.cdivision(True)
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def bls_impl(
+    np.ndarray[DTYPE_t, mode='c'] t_array,
+    np.ndarray[DTYPE_t, mode='c'] y_array,
+    np.ndarray[DTYPE_t, mode='c'] ivar_array,
+    np.ndarray[DTYPE_t, mode='c'] period_array,
+    np.ndarray[DTYPE_t, mode='c'] duration_array,
+    int oversample,
+    int obj_flag
+):
+
+    cdef np.ndarray[DTYPE_t, mode='c'] out_objective = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_depth     = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_depth_err = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_duration  = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_phase     = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_depth_snr = np.empty_like(period_array, dtype=DTYPE)
+    cdef np.ndarray[DTYPE_t, mode='c'] out_log_like  = np.empty_like(period_array, dtype=DTYPE)
+    cdef int flag, N = len(t_array), n_periods = len(period_array), n_durations = len(duration_array)
+
+    with nogil:
+        flag = run_bls(
+            N,
+            <double*>t_array.data,
+            <double*>y_array.data,
+            <double*>ivar_array.data,
+            n_periods,
+            <double*>period_array.data,
+            n_durations,
+            <double*>duration_array.data,
+            oversample,
+            obj_flag,
+            <double*>out_objective.data,
+            <double*>out_depth.data,
+            <double*>out_depth_err.data,
+            <double*>out_duration.data,
+            <double*>out_phase.data,
+            <double*>out_depth_snr.data,
+            <double*>out_log_like.data
+        )
+
+    if flag < 0:
+        raise MemoryError()
+    if flag > 0:
+        raise ValueError("Invalid inputs for period and/or duration")
+
+    return (out_objective, out_depth, out_depth_err, out_duration, out_phase,
+            out_depth_snr, out_log_like)

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/bls.c

@@ -0,0 +1,224 @@
+/* Licensed under a 3-clause BSD style license - see LICENSE.rst */
+
+#include <math.h>
+#include <float.h>
+#include <stdlib.h>
+
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+
+#ifndef INFINITY
+#define INFINITY (1.0 / 0.0)
+#endif
+
+void compute_objective(
+    double y_in,
+    double y_out,
+    double ivar_in,
+    double ivar_out,
+    int obj_flag,
+    double* objective,
+    double* log_likelihood,
+    double* depth,
+    double* depth_err,
+    double* depth_snr
+) {
+    if (obj_flag) {
+        double arg = y_out - y_in;
+        *log_likelihood = 0.5*ivar_in*arg*arg;
+        *objective = *log_likelihood;
+    } else {
+        *depth = y_out - y_in;
+        *depth_err = sqrt(1.0 / ivar_in + 1.0 / ivar_out);
+        *depth_snr = *depth / *depth_err;
+        *objective = *depth_snr;
+    }
+}
+
+inline double wrap_into (double x, double period)
+{
+    return x - period * floor(x / period);
+}
+
+int run_bls (
+    // Inputs
+    int N,                   // Length of the time array
+    double* t,               // The list of timestamps
+    double* y,               // The y measured at ``t``
+    double* ivar,            // The inverse variance of the y array
+
+    int n_periods,
+    double* periods,         // The period to test in units of ``t``
+
+    int n_durations,         // Length of the durations array
+    double* durations,       // The durations to test in units of ``bin_duration``
+    int oversample,          // The number of ``bin_duration`` bins in the maximum duration
+
+    int obj_flag,            // A flag indicating the periodogram type
+                             // 0 - depth signal-to-noise
+                             // 1 - log likelihood
+
+    // Outputs
+    double* best_objective,  // The value of the periodogram at maximum
+    double* best_depth,      // The estimated depth at maximum
+    double* best_depth_err,  // The uncertainty on ``best_depth``
+    double* best_duration,   // The best fitting duration in units of ``t``
+    double* best_phase,      // The phase of the mid-transit time in units of
+                             // ``t``
+    double* best_depth_snr,  // The signal-to-noise ratio of the depth estimate
+    double* best_log_like    // The log likelihood at maximum
+) {
+    // Start by finding the period and duration ranges
+    double max_period = periods[0], min_period = periods[0];
+    int k;
+    for (k = 1; k < n_periods; ++k) {
+        if (periods[k] < min_period) min_period = periods[k];
+        if (periods[k] > max_period) max_period = periods[k];
+    }
+    if (min_period < DBL_EPSILON) return 1;
+    double min_duration = durations[0], max_duration = durations[0];
+    for (k = 1; k < n_durations; ++k) {
+        if (durations[k] < min_duration) min_duration = durations[k];
+        if (durations[k] > max_duration) max_duration = durations[k];
+    }
+    if ((max_duration > min_period) || (min_duration < DBL_EPSILON)) return 2;
+
+    // Compute the durations in terms of bin_duration
+    double bin_duration = min_duration / ((double)oversample);
+    int max_n_bins = (int)(ceil(max_period / bin_duration)) + oversample;
+
+    int nthreads, blocksize = max_n_bins+1;
+#pragma omp parallel
+{
+#if defined(_OPENMP)
+    nthreads = omp_get_num_threads();
+#else
+    nthreads = 1;
+#endif
+}
+
+    // Allocate the work arrays
+    double* mean_y_0 = (double*)malloc(nthreads*blocksize*sizeof(double));
+    if (mean_y_0 == NULL) {
+        return -2;
+    }
+    double* mean_ivar_0 = (double*)malloc(nthreads*blocksize*sizeof(double));
+    if (mean_ivar_0 == NULL) {
+        free(mean_y_0);
+        return -3;
+    }
+
+    // Pre-accumulate some factors.
+    double min_t = INFINITY;
+    double sum_y = 0.0, sum_ivar = 0.0;
+    int i;
+    #pragma omp parallel for reduction(+:sum_y), reduction(+:sum_ivar)
+    for (i = 0; i < N; ++i) {
+        min_t = fmin(min_t, t[i]);
+        sum_y += y[i] * ivar[i];
+        sum_ivar += ivar[i];
+    }
+
+    // Loop over periods and do the search
+    int p;
+    #pragma omp parallel for
+    for (p = 0; p < n_periods; ++p) {
+#if defined(_OPENMP)
+        int ithread = omp_get_thread_num();
+#else
+        int ithread = 0;
+#endif
+        int block = blocksize * ithread;
+        double period = periods[p];
+        int n_bins = (int)(ceil(period / bin_duration)) + oversample;
+
+        double* mean_y = mean_y_0 + block;
+        double* mean_ivar = mean_ivar_0 + block;
+
+        // This first pass bins the data into a fine-grain grid in phase from zero
+        // to period and computes the weighted sum and inverse variance for each
+        // bin.
+        int n, ind;
+        for (n = 0; n < n_bins+1; ++n) {
+            mean_y[n] = 0.0;
+            mean_ivar[n] = 0.0;
+        }
+        for (n = 0; n < N; ++n) {
+            int ind = (int)(wrap_into(t[n] - min_t, period) / bin_duration) + 1;
+            mean_y[ind] += y[n] * ivar[n];
+            mean_ivar[ind] += ivar[n];
+        }
+
+        // To simplify calculations below, we wrap the binned values around and pad
+        // the end of the array with the first ``oversample`` samples.
+        for (n = 1, ind = n_bins - oversample; n <= oversample; ++n, ++ind) {
+            mean_y[ind] = mean_y[n];
+            mean_ivar[ind] = mean_ivar[n];
+        }
+
+        // To compute the estimates of the in-transit flux, we need the sum of
+        // mean_y and mean_ivar over a given set of transit points. To get this
+        // fast, we can compute the cumulative sum and then use differences between
+        // points separated by ``duration`` bins. Here we convert the mean arrays
+        // to cumulative sums.
+        for (n = 1; n <= n_bins; ++n) {
+            mean_y[n] += mean_y[n-1];
+            mean_ivar[n] += mean_ivar[n-1];
+        }
+
+        // Then we loop over phases (in steps of n_bin) and durations and find the
+        // best fit value. By looping over durations here, we get to reuse a lot of
+        // the computations that we did above.
+        double objective, log_like, depth, depth_err, depth_snr;
+        best_objective[p] = -INFINITY;
+        int k;
+        for (k = 0; k < n_durations; ++k) {
+            int dur = (int)(round(durations[k] / bin_duration));
+            int n_max = n_bins-dur;
+            for (n = 0; n <= n_max; ++n) {
+                // Estimate the in-transit and out-of-transit flux
+                double y_in = mean_y[n+dur] - mean_y[n];
+                double ivar_in = mean_ivar[n+dur] - mean_ivar[n];
+                double y_out = sum_y - y_in;
+                double ivar_out = sum_ivar - ivar_in;
+
+                // Skip this model if there are no points in transit
+                if ((ivar_in < DBL_EPSILON) || (ivar_out < DBL_EPSILON)) {
+                    continue;
+                }
+
+                // Normalize to compute the actual value of the flux
+                y_in /= ivar_in;
+                y_out /= ivar_out;
+
+                // Either compute the log likelihood or the signal-to-noise
+                // ratio
+                compute_objective(y_in, y_out, ivar_in, ivar_out, obj_flag,
+                        &objective, &log_like, &depth, &depth_err, &depth_snr);
+
+                // If this is the best result seen so far, keep it
+                if (y_out >= y_in && objective > best_objective[p]) {
+                    best_objective[p] = objective;
+
+                    // Compute the other parameters
+                    compute_objective(y_in, y_out, ivar_in, ivar_out, (obj_flag == 0),
+                            &objective, &log_like, &depth, &depth_err, &depth_snr);
+
+                    best_depth[p]     = depth;
+                    best_depth_err[p] = depth_err;
+                    best_depth_snr[p] = depth_snr;
+                    best_log_like[p]  = log_like;
+                    best_duration[p]  = dur * bin_duration;
+                    best_phase[p]     = fmod(n*bin_duration + 0.5*best_duration[p] + min_t, period);
+                }
+            }
+        }
+    }
+
+    // Clean up
+    free(mean_y_0);
+    free(mean_ivar_0);
+
+    return 0;
+}

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/core.py

@@ -0,0 +1,817 @@
+# -*- coding: utf-8 -*-
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+__all__ = ["BoxLeastSquares", "BoxLeastSquaresResults"]
+
+import numpy as np
+
+from astropy import units
+from astropy.time import Time, TimeDelta
+from astropy.timeseries.periodograms.lombscargle.core import has_units, strip_units
+from astropy import units as u
+from . import methods
+from astropy.timeseries.periodograms.base import BasePeriodogram
+
+
+def validate_unit_consistency(reference_object, input_object):
+    if has_units(reference_object):
+        input_object = units.Quantity(input_object, unit=reference_object.unit)
+    else:
+        if has_units(input_object):
+            input_object = units.Quantity(input_object, unit=units.one)
+            input_object = input_object.value
+    return input_object
+
+
+class BoxLeastSquares(BasePeriodogram):
+    """Compute the box least squares periodogram
+
+    This method is a commonly used tool for discovering transiting exoplanets
+    or eclipsing binaries in photometric time series datasets. This
+    implementation is based on the "box least squares (BLS)" method described
+    in [1]_ and [2]_.
+
+    Parameters
+    ----------
+    t : array-like, `~astropy.units.Quantity`, `~astropy.time.Time`, or `~astropy.time.TimeDelta`
+        Sequence of observation times.
+    y : array-like or `~astropy.units.Quantity`
+        Sequence of observations associated with times ``t``.
+    dy : float, array-like or `~astropy.units.Quantity`, optional
+        Error or sequence of observational errors associated with times ``t``.
+
+    Examples
+    --------
+    Generate noisy data with a transit:
+
+    >>> rand = np.random.RandomState(42)
+    >>> t = rand.uniform(0, 10, 500)
+    >>> y = np.ones_like(t)
+    >>> y[np.abs((t + 1.0)%2.0-1)<0.08] = 1.0 - 0.1
+    >>> y += 0.01 * rand.randn(len(t))
+
+    Compute the transit periodogram on a heuristically determined period grid
+    and find the period with maximum power:
+
+    >>> model = BoxLeastSquares(t, y)
+    >>> results = model.autopower(0.16)
+    >>> results.period[np.argmax(results.power)]  # doctest: +FLOAT_CMP
+    1.9923406038842544
+
+    Compute the periodogram on a user-specified period grid:
+
+    >>> periods = np.linspace(1.9, 2.1, 5)
+    >>> results = model.power(periods, 0.16)
+    >>> results.power  # doctest: +FLOAT_CMP
+    array([0.01421067, 0.02842475, 0.10867671, 0.05117755, 0.01783253])
+
+    If the inputs are AstroPy Quantities with units, the units will be
+    validated and the outputs will also be Quantities with appropriate units:
+
+    >>> from astropy import units as u
+    >>> t = t * u.day
+    >>> y = y * u.dimensionless_unscaled
+    >>> model = BoxLeastSquares(t, y)
+    >>> results = model.autopower(0.16 * u.day)
+    >>> results.period.unit
+    Unit("d")
+    >>> results.power.unit
+    Unit(dimensionless)
+
+    References
+    ----------
+    .. [1] Kovacs, Zucker, & Mazeh (2002), A&A, 391, 369
+        (arXiv:astro-ph/0206099)
+    .. [2] Hartman & Bakos (2016), Astronomy & Computing, 17, 1
+        (arXiv:1605.06811)
+
+    """
+
+    def __init__(self, t, y, dy=None):
+
+        # If t is a TimeDelta, convert it to a quantity. The units we convert
+        # to don't really matter since the user gets a Quantity back at the end
+        # so can convert to any units they like.
+        if isinstance(t, TimeDelta):
+            t = t.to('day')
+
+        # We want to expose self.t as being the times the user passed in, but
+        # if the times are absolute, we need to convert them to relative times
+        # internally, so we use self._trel and self._tstart for this.
+
+        self.t = t
+
+        if isinstance(self.t, Time):
+            self._tstart = self.t[0]
+            trel = (self.t - self._tstart).to(u.day)
+        else:
+            self._tstart = None
+            trel = self.t
+
+        self._trel, self.y, self.dy = self._validate_inputs(trel, y, dy)
+
+    def autoperiod(self, duration,
+                   minimum_period=None, maximum_period=None,
+                   minimum_n_transit=3, frequency_factor=1.0):
+        """Determine a suitable grid of periods
+
+        This method uses a set of heuristics to select a conservative period
+        grid that is uniform in frequency. This grid might be too fine for
+        some user's needs depending on the precision requirements or the
+        sampling of the data. The grid can be made coarser by increasing
+        ``frequency_factor``.
+
+        Parameters
+        ----------
+        duration : float, array-like or `~astropy.units.Quantity`
+            The set of durations that will be considered.
+        minimum_period, maximum_period : float or `~astropy.units.Quantity`, optional
+            The minimum/maximum periods to search. If not provided, these will
+            be computed as described in the notes below.
+        minimum_n_transits : int, optional
+            If ``maximum_period`` is not provided, this is used to compute the
+            maximum period to search by asserting that any systems with at
+            least ``minimum_n_transits`` will be within the range of searched
+            periods. Note that this is not the same as requiring that
+            ``minimum_n_transits`` be required for detection. The default
+            value is ``3``.
+        frequency_factor : float, optional
+            A factor to control the frequency spacing as described in the
+            notes below. The default value is ``1.0``.
+
+        Returns
+        -------
+        period : array-like or `~astropy.units.Quantity`
+            The set of periods computed using these heuristics with the same
+            units as ``t``.
+
+        Notes
+        -----
+        The default minimum period is chosen to be twice the maximum duration
+        because there won't be much sensitivity to periods shorter than that.
+
+        The default maximum period is computed as
+
+        .. code-block:: python
+
+            maximum_period = (max(t) - min(t)) / minimum_n_transits
+
+        ensuring that any systems with at least ``minimum_n_transits`` are
+        within the range of searched periods.
+
+        The frequency spacing is given by
+
+        .. code-block:: python
+
+            df = frequency_factor * min(duration) / (max(t) - min(t))**2
+
+        so the grid can be made finer by decreasing ``frequency_factor`` or
+        coarser by increasing ``frequency_factor``.
+
+        """
+
+        duration = self._validate_duration(duration)
+        baseline = strip_units((self._trel.max() - self._trel.min()))
+        min_duration = strip_units(np.min(duration))
+
+        # Estimate the required frequency spacing
+        # Because of the sparsity of a transit, this must be much finer than
+        # the frequency resolution for a sinusoidal fit. For a sinusoidal fit,
+        # df would be 1/baseline (see LombScargle), but here this should be
+        # scaled proportionally to the duration in units of baseline.
+        df = frequency_factor * min_duration / baseline**2
+
+        # If a minimum period is not provided, choose one that is twice the
+        # maximum duration because we won't be sensitive to any periods
+        # shorter than that.
+        if minimum_period is None:
+            minimum_period = 2.0 * strip_units(np.max(duration))
+        else:
+            minimum_period = validate_unit_consistency(self._trel, minimum_period)
+            minimum_period = strip_units(minimum_period)
+
+        # If no maximum period is provided, choose one by requiring that
+        # all signals with at least minimum_n_transit should be detectable.
+        if maximum_period is None:
+            if minimum_n_transit <= 1:
+                raise ValueError("minimum_n_transit must be greater than 1")
+            maximum_period = baseline / (minimum_n_transit-1)
+        else:
+            maximum_period = validate_unit_consistency(self._trel, maximum_period)
+            maximum_period = strip_units(maximum_period)
+
+        if maximum_period < minimum_period:
+            minimum_period, maximum_period = maximum_period, minimum_period
+        if minimum_period <= 0.0:
+            raise ValueError("minimum_period must be positive")
+
+        # Convert bounds to frequency
+        minimum_frequency = 1.0/strip_units(maximum_period)
+        maximum_frequency = 1.0/strip_units(minimum_period)
+
+        # Compute the number of frequencies and the frequency grid
+        nf = 1 + int(np.round((maximum_frequency - minimum_frequency)/df))
+        return 1.0/(maximum_frequency-df*np.arange(nf)) * self._t_unit()
+
+    def autopower(self, duration, objective=None, method=None, oversample=10,
+                  minimum_n_transit=3, minimum_period=None,
+                  maximum_period=None, frequency_factor=1.0):
+        """Compute the periodogram at set of heuristically determined periods
+
+        This method calls :func:`BoxLeastSquares.autoperiod` to determine
+        the period grid and then :func:`BoxLeastSquares.power` to compute
+        the periodogram. See those methods for documentation of the arguments.
+
+        """
+        period = self.autoperiod(duration,
+                                 minimum_n_transit=minimum_n_transit,
+                                 minimum_period=minimum_period,
+                                 maximum_period=maximum_period,
+                                 frequency_factor=frequency_factor)
+        return self.power(period, duration, objective=objective, method=method,
+                          oversample=oversample)
+
+    def power(self, period, duration, objective=None, method=None,
+              oversample=10):
+        """Compute the periodogram for a set of periods
+
+        Parameters
+        ----------
+        period : array-like or `~astropy.units.Quantity`
+            The periods where the power should be computed
+        duration : float, array-like or `~astropy.units.Quantity`
+            The set of durations to test
+        objective : {'likelihood', 'snr'}, optional
+            The scalar that should be optimized to find the best fit phase,
+            duration, and depth. This can be either ``'likelihood'`` (default)
+            to optimize the log-likelihood of the model, or ``'snr'`` to
+            optimize the signal-to-noise with which the transit depth is
+            measured.
+        method : {'fast', 'slow'}, optional
+            The computational method used to compute the periodogram. This is
+            mainly included for the purposes of testing and most users will
+            want to use the optimized ``'fast'`` method (default) that is
+            implemented in Cython.  ``'slow'`` is a brute-force method that is
+            used to test the results of the ``'fast'`` method.
+        oversample : int, optional
+            The number of bins per duration that should be used. This sets the
+            time resolution of the phase fit with larger values of
+            ``oversample`` yielding a finer grid and higher computational cost.
+
+        Returns
+        -------
+        results : BoxLeastSquaresResults
+            The periodogram results as a :class:`BoxLeastSquaresResults`
+            object.
+
+        Raises
+        ------
+        ValueError
+            If ``oversample`` is not an integer greater than 0 or if
+            ``objective`` or ``method`` are not valid.
+
+        """
+        period, duration = self._validate_period_and_duration(period, duration)
+
+        # Check for absurdities in the ``oversample`` choice
+        try:
+            oversample = int(oversample)
+        except TypeError:
+            raise ValueError("oversample must be an int, got {0}"
+                             .format(oversample))
+        if oversample < 1:
+            raise ValueError("oversample must be greater than or equal to 1")
+
+        # Select the periodogram objective
+        if objective is None:
+            objective = "likelihood"
+        allowed_objectives = ["snr", "likelihood"]
+        if objective not in allowed_objectives:
+            raise ValueError(("Unrecognized method '{0}'\n"
+                              "allowed methods are: {1}")
+                             .format(objective, allowed_objectives))
+        use_likelihood = (objective == "likelihood")
+
+        # Select the computational method
+        if method is None:
+            method = "fast"
+        allowed_methods = ["fast", "slow"]
+        if method not in allowed_methods:
+            raise ValueError(("Unrecognized method '{0}'\n"
+                              "allowed methods are: {1}")
+                             .format(method, allowed_methods))
+
+        # Format and check the input arrays
+        t = np.ascontiguousarray(strip_units(self._trel), dtype=np.float64)
+        y = np.ascontiguousarray(strip_units(self.y), dtype=np.float64)
+        if self.dy is None:
+            ivar = np.ones_like(y)
+        else:
+            ivar = 1.0 / np.ascontiguousarray(strip_units(self.dy),
+                                              dtype=np.float64)**2
+
+        # Make sure that the period and duration arrays are C-order
+        period_fmt = np.ascontiguousarray(strip_units(period),
+                                          dtype=np.float64)
+        duration = np.ascontiguousarray(strip_units(duration),
+                                        dtype=np.float64)
+
+        # Select the correct implementation for the chosen method
+        if method == "fast":
+            bls = methods.bls_fast
+        else:
+            bls = methods.bls_slow
+
+        # Run the implementation
+        results = bls(
+            t, y - np.median(y), ivar, period_fmt, duration,
+            oversample, use_likelihood)
+
+        return self._format_results(objective, period, results)
+
+    def _as_relative_time(self, name, times):
+        """
+        Convert the provided times (if absolute) to relative times using the
+        current _tstart value. If the times provided are relative, they are
+        returned without conversion (though we still do some checks).
+        """
+
+        if isinstance(times, TimeDelta):
+            times = times.to('day')
+
+        if self._tstart is None:
+            if isinstance(times, Time):
+                raise TypeError('{0} was provided as an absolute time but '
+                                'the BoxLeastSquares class was initialized '
+                                'with relative times.'.format(name))
+        else:
+            if isinstance(times, Time):
+                times = (times - self._tstart).to(u.day)
+            else:
+                raise TypeError('{0} was provided as a relative time but '
+                                'the BoxLeastSquares class was initialized '
+                                'with absolute times.'.format(name))
+
+        times = validate_unit_consistency(self._trel, times)
+
+        return times
+
+    def _as_absolute_time_if_needed(self, name, times):
+        """
+        Convert the provided times to absolute times using the current _tstart
+        value, if needed.
+        """
+        if self._tstart is not None:
+            # Some time formats/scales can't represent dates/times too far
+            # off from the present, so we need to mask values offset by
+            # more than 100,000 yr (the periodogram algorithm can return
+            # transit times of e.g 1e300 for some periods).
+            reset = np.abs(times.to_value(u.year)) > 100000
+            times[reset] = 0
+            times = self._tstart + times
+            times[reset] = np.nan
+        return times
+
+    def model(self, t_model, period, duration, transit_time):
+        """Compute the transit model at the given period, duration, and phase
+
+        Parameters
+        ----------
+        t_model : array-like or `~astropy.units.Quantity` or `~astropy.time.Time`
+            Times at which to compute the model.
+        period : float or `~astropy.units.Quantity`
+            The period of the transits.
+        duration : float or `~astropy.units.Quantity`
+            The duration of the transit.
+        transit_time : float or `~astropy.units.Quantity` or `~astropy.time.Time`
+            The mid-transit time of a reference transit.
+
+        Returns
+        -------
+        y_model : array-like or `~astropy.units.Quantity`
+            The model evaluated at the times ``t_model`` with units of ``y``.
+
+        """
+
+        period, duration = self._validate_period_and_duration(period, duration)
+
+        transit_time = self._as_relative_time('transit_time', transit_time)
+        t_model = strip_units(self._as_relative_time('t_model', t_model))
+
+        period = float(strip_units(period))
+        duration = float(strip_units(duration))
+        transit_time = float(strip_units(transit_time))
+
+        t = np.ascontiguousarray(strip_units(self._trel), dtype=np.float64)
+        y = np.ascontiguousarray(strip_units(self.y), dtype=np.float64)
+        if self.dy is None:
+            ivar = np.ones_like(y)
+        else:
+            ivar = 1.0 / np.ascontiguousarray(strip_units(self.dy),
+                                              dtype=np.float64)**2
+
+        # Compute the depth
+        hp = 0.5*period
+        m_in = np.abs((t-transit_time+hp) % period - hp) < 0.5*duration
+        m_out = ~m_in
+        y_in = np.sum(y[m_in] * ivar[m_in]) / np.sum(ivar[m_in])
+        y_out = np.sum(y[m_out] * ivar[m_out]) / np.sum(ivar[m_out])
+
+        # Evaluate the model
+        y_model = y_out + np.zeros_like(t_model)
+        m_model = np.abs((t_model-transit_time+hp) % period-hp) < 0.5*duration
+        y_model[m_model] = y_in
+
+        return y_model * self._y_unit()
+
+    def compute_stats(self, period, duration, transit_time):
+        """Compute descriptive statistics for a given transit model
+
+        These statistics are commonly used for vetting of transit candidates.
+
+        Parameters
+        ----------
+        period : float or `~astropy.units.Quantity`
+            The period of the transits.
+        duration : float or `~astropy.units.Quantity`
+            The duration of the transit.
+        transit_time : float or `~astropy.units.Quantity` or `~astropy.time.Time`
+            The mid-transit time of a reference transit.
+
+        Returns
+        -------
+        stats : dict
+            A dictionary containing several descriptive statistics:
+
+            - ``depth``: The depth and uncertainty (as a tuple with two
+                values) on the depth for the fiducial model.
+            - ``depth_odd``: The depth and uncertainty on the depth for a
+                model where the period is twice the fiducial period.
+            - ``depth_even``: The depth and uncertainty on the depth for a
+                model where the period is twice the fiducial period and the
+                phase is offset by one orbital period.
+            - ``depth_half``: The depth and uncertainty for a model with a
+                period of half the fiducial period.
+            - ``depth_phased``: The depth and uncertainty for a model with the
+                fiducial period and the phase offset by half a period.
+            - ``harmonic_amplitude``: The amplitude of the best fit sinusoidal
+                model.
+            - ``harmonic_delta_log_likelihood``: The difference in log
+                likelihood between a sinusoidal model and the transit model.
+                If ``harmonic_delta_log_likelihood`` is greater than zero, the
+                sinusoidal model is preferred.
+            - ``transit_times``: The mid-transit time for each transit in the
+                baseline.
+            - ``per_transit_count``: An array with a count of the number of
+                data points in each unique transit included in the baseline.
+            - ``per_transit_log_likelihood``: An array with the value of the
+                log likelihood for each unique transit included in the
+                baseline.
+
+        """
+
+        period, duration = self._validate_period_and_duration(period, duration)
+        transit_time = self._as_relative_time('transit_time', transit_time)
+
+        period = float(strip_units(period))
+        duration = float(strip_units(duration))
+        transit_time = float(strip_units(transit_time))
+
+        t = np.ascontiguousarray(strip_units(self._trel), dtype=np.float64)
+        y = np.ascontiguousarray(strip_units(self.y), dtype=np.float64)
+        if self.dy is None:
+            ivar = np.ones_like(y)
+        else:
+            ivar = 1.0 / np.ascontiguousarray(strip_units(self.dy),
+                                              dtype=np.float64)**2
+
+        # This a helper function that will compute the depth for several
+        # different hypothesized transit models with different parameters
+        def _compute_depth(m, y_out=None, var_out=None):
+            if np.any(m) and (var_out is None or np.isfinite(var_out)):
+                var_m = 1.0 / np.sum(ivar[m])
+                y_m = np.sum(y[m] * ivar[m]) * var_m
+                if y_out is None:
+                    return y_m, var_m
+                return y_out - y_m, np.sqrt(var_m + var_out)
+            return 0.0, np.inf
+
+        # Compute the depth of the fiducial model and the two models at twice
+        # the period
+        hp = 0.5*period
+        m_in = np.abs((t-transit_time+hp) % period - hp) < 0.5*duration
+        m_out = ~m_in
+        m_odd = np.abs((t-transit_time) % (2*period) - period) \
+            < 0.5*duration
+        m_even = np.abs((t-transit_time+period) % (2*period) - period) \
+            < 0.5*duration
+
+        y_out, var_out = _compute_depth(m_out)
+        depth = _compute_depth(m_in, y_out, var_out)
+        depth_odd = _compute_depth(m_odd, y_out, var_out)
+        depth_even = _compute_depth(m_even, y_out, var_out)
+        y_in = y_out - depth[0]
+
+        # Compute the depth of the model at a phase of 0.5*period
+        m_phase = np.abs((t-transit_time) % period - hp) < 0.5*duration
+        depth_phase = _compute_depth(m_phase,
+                                     *_compute_depth((~m_phase) & m_out))
+
+        # Compute the depth of a model with a period of 0.5*period
+        m_half = np.abs((t-transit_time+0.25*period) % (0.5*period)
+                        - 0.25*period) < 0.5*duration
+        depth_half = _compute_depth(m_half, *_compute_depth(~m_half))
+
+        # Compute the number of points in each transit
+        transit_id = np.round((t[m_in]-transit_time) / period).astype(int)
+        transit_times = period * np.arange(transit_id.min(),
+                                           transit_id.max()+1) + transit_time
+        unique_ids, unique_counts = np.unique(transit_id,
+                                              return_counts=True)
+        unique_ids -= np.min(transit_id)
+        transit_id -= np.min(transit_id)
+        counts = np.zeros(np.max(transit_id) + 1, dtype=int)
+        counts[unique_ids] = unique_counts
+
+        # Compute the per-transit log likelihood
+        ll = -0.5 * ivar[m_in] * ((y[m_in] - y_in)**2 - (y[m_in] - y_out)**2)
+        lls = np.zeros(len(counts))
+        for i in unique_ids:
+            lls[i] = np.sum(ll[transit_id == i])
+        full_ll = -0.5*np.sum(ivar[m_in] * (y[m_in] - y_in)**2)
+        full_ll -= 0.5*np.sum(ivar[m_out] * (y[m_out] - y_out)**2)
+
+        # Compute the log likelihood of a sine model
+        A = np.vstack((
+            np.sin(2*np.pi*t/period), np.cos(2*np.pi*t/period),
+            np.ones_like(t)
+        )).T
+        w = np.linalg.solve(np.dot(A.T, A * ivar[:, None]),
+                            np.dot(A.T, y * ivar))
+        mod = np.dot(A, w)
+        sin_ll = -0.5*np.sum((y-mod)**2*ivar)
+
+        # Format the results
+        y_unit = self._y_unit()
+        ll_unit = 1
+        if self.dy is None:
+            ll_unit = y_unit * y_unit
+        return dict(
+            transit_times=self._as_absolute_time_if_needed('transit_times', transit_times * self._t_unit()),
+            per_transit_count=counts,
+            per_transit_log_likelihood=lls * ll_unit,
+            depth=(depth[0] * y_unit, depth[1] * y_unit),
+            depth_phased=(depth_phase[0] * y_unit, depth_phase[1] * y_unit),
+            depth_half=(depth_half[0] * y_unit, depth_half[1] * y_unit),
+            depth_odd=(depth_odd[0] * y_unit, depth_odd[1] * y_unit),
+            depth_even=(depth_even[0] * y_unit, depth_even[1] * y_unit),
+            harmonic_amplitude=np.sqrt(np.sum(w[:2]**2)) * y_unit,
+            harmonic_delta_log_likelihood=(sin_ll - full_ll) * ll_unit,
+        )
+
+    def transit_mask(self, t, period, duration, transit_time):
+        """Compute which data points are in transit for a given parameter set
+
+        Parameters
+        ----------
+        t_model : array-like or `~astropy.units.Quantity`
+            Times where the mask should be evaluated.
+        period : float or `~astropy.units.Quantity`
+            The period of the transits.
+        duration : float or `~astropy.units.Quantity`
+            The duration of the transit.
+        transit_time : float or `~astropy.units.Quantity` or `~astropy.time.Time`
+            The mid-transit time of a reference transit.
+
+        Returns
+        -------
+        transit_mask : array-like
+            A boolean array where ``True`` indicates and in transit point and
+            ``False`` indicates and out-of-transit point.
+
+        """
+
+        period, duration = self._validate_period_and_duration(period, duration)
+        transit_time = self._as_relative_time('transit_time', transit_time)
+        t = strip_units(self._as_relative_time('t', t))
+
+        period = float(strip_units(period))
+        duration = float(strip_units(duration))
+        transit_time = float(strip_units(transit_time))
+
+        hp = 0.5*period
+        return np.abs((t-transit_time+hp) % period - hp) < 0.5*duration
+
+    def _validate_inputs(self, t, y, dy):
+        """Private method used to check the consistency of the inputs
+
+        Parameters
+        ----------
+        t : array-like, `~astropy.units.Quantity`, `~astropy.time.Time`, or `~astropy.time.TimeDelta`
+            Sequence of observation times.
+        y : array-like or `~astropy.units.Quantity`
+            Sequence of observations associated with times t.
+        dy : float, array-like or `~astropy.units.Quantity`
+            Error or sequence of observational errors associated with times t.
+
+        Returns
+        -------
+        t, y, dy : array-like or `~astropy.units.Quantity` or `~astropy.time.Time`
+            The inputs with consistent shapes and units.
+        Raises
+        ------
+        ValueError
+            If the dimensions are incompatible or if the units of dy cannot be
+            converted to the units of y.
+
+        """
+
+        # Validate shapes of inputs
+        if dy is None:
+            t, y = np.broadcast_arrays(t, y, subok=True)
+        else:
+            t, y, dy = np.broadcast_arrays(t, y, dy, subok=True)
+        if t.ndim != 1:
+            raise ValueError("Inputs (t, y, dy) must be 1-dimensional")
+
+        # validate units of inputs if any is a Quantity
+        if dy is not None:
+            dy = validate_unit_consistency(y, dy)
+
+        return t, y, dy
+
+    def _validate_duration(self, duration):
+        """Private method used to check a set of test durations
+
+        Parameters
+        ----------
+        duration : float, array-like or `~astropy.units.Quantity`
+            The set of durations that will be considered.
+
+        Returns
+        -------
+        duration : array-like or `~astropy.units.Quantity`
+            The input reformatted with the correct shape and units.
+
+        Raises
+        ------
+        ValueError
+            If the units of duration cannot be converted to the units of t.
+
+        """
+        duration = np.atleast_1d(np.abs(duration))
+        if duration.ndim != 1 or duration.size == 0:
+            raise ValueError("duration must be 1-dimensional")
+        return validate_unit_consistency(self._trel, duration)
+
+    def _validate_period_and_duration(self, period, duration):
+        """Private method used to check a set of periods and durations
+
+        Parameters
+        ----------
+        period : float, array-like or `~astropy.units.Quantity`
+            The set of test periods.
+        duration : float, array-like or `~astropy.units.Quantity`
+            The set of durations that will be considered.
+
+        Returns
+        -------
+        period, duration : array-like or `~astropy.units.Quantity`
+            The inputs reformatted with the correct shapes and units.
+
+        Raises
+        ------
+        ValueError
+            If the units of period or duration cannot be converted to the
+            units of t.
+
+        """
+        duration = self._validate_duration(duration)
+        period = np.atleast_1d(np.abs(period))
+        if period.ndim != 1 or period.size == 0:
+            raise ValueError("period must be 1-dimensional")
+        period = validate_unit_consistency(self._trel, period)
+
+        if not np.min(period) > np.max(duration):
+            raise ValueError("The maximum transit duration must be shorter "
+                             "than the minimum period")
+
+        return period, duration
+
+    def _format_results(self, objective, period, results):
+        """A private method used to wrap and add units to the periodogram
+
+        Parameters
+        ----------
+        objective : string
+            The name of the objective used in the optimization.
+        period : array-like or `~astropy.units.Quantity`
+            The set of trial periods.
+        results : tuple
+            The output of one of the periodogram implementations.
+
+        """
+        (power, depth, depth_err, duration, transit_time, depth_snr,
+         log_likelihood) = results
+
+        if has_units(self._trel):
+            transit_time = units.Quantity(transit_time, unit=self._trel.unit)
+            transit_time = self._as_absolute_time_if_needed('transit_time', transit_time)
+            duration = units.Quantity(duration, unit=self._trel.unit)
+
+        if has_units(self.y):
+            depth = units.Quantity(depth, unit=self.y.unit)
+            depth_err = units.Quantity(depth_err, unit=self.y.unit)
+
+            depth_snr = units.Quantity(depth_snr, unit=units.one)
+
+            if self.dy is None:
+                if objective == "likelihood":
+                    power = units.Quantity(power, unit=self.y.unit**2)
+                else:
+                    power = units.Quantity(power, unit=units.one)
+                log_likelihood = units.Quantity(log_likelihood,
+                                                unit=self.y.unit**2)
+            else:
+                power = units.Quantity(power, unit=units.one)
+                log_likelihood = units.Quantity(log_likelihood, unit=units.one)
+
+        return BoxLeastSquaresResults(
+            objective, period, power, depth, depth_err, duration, transit_time,
+            depth_snr, log_likelihood)
+
+    def _t_unit(self):
+        if has_units(self._trel):
+            return self._trel.unit
+        else:
+            return 1
+
+    def _y_unit(self):
+        if has_units(self.y):
+            return self.y.unit
+        else:
+            return 1
+
+
+class BoxLeastSquaresResults(dict):
+    """The results of a BoxLeastSquares search
+
+    Attributes
+    ----------
+    objective : string
+        The scalar used to optimize to find the best fit phase, duration, and
+        depth. See :func:`BoxLeastSquares.power` for more information.
+    period : array-like or `~astropy.units.Quantity`
+        The set of test periods.
+    power : array-like or `~astropy.units.Quantity`
+        The periodogram evaluated at the periods in ``period``. If
+        ``objective`` is:
+
+        * ``'likelihood'``: the values of ``power`` are the
+          log likelihood maximized over phase, depth, and duration, or
+        * ``'snr'``: the values of ``power`` are the signal-to-noise with
+          which the depth is measured maximized over phase, depth, and
+          duration.
+
+    depth : array-like or `~astropy.units.Quantity`
+        The estimated depth of the maximum power model at each period.
+    depth_err : array-like or `~astropy.units.Quantity`
+        The 1-sigma uncertainty on ``depth``.
+    duration : array-like or `~astropy.units.Quantity`
+        The maximum power duration at each period.
+    transit_time : array-like or `~astropy.units.Quantity` or `~astropy.time.Time`
+        The maximum power phase of the transit in units of time. This
+        indicates the mid-transit time and it will always be in the range
+        (0, period).
+    depth_snr : array-like or `~astropy.units.Quantity`
+        The signal-to-noise with which the depth is measured at maximum power.
+    log_likelihood : array-like or `~astropy.units.Quantity`
+        The log likelihood of the maximum power model.
+
+    """
+    def __init__(self, *args):
+        super().__init__(zip(
+            ("objective", "period", "power", "depth", "depth_err",
+             "duration", "transit_time", "depth_snr", "log_likelihood"),
+            args
+        ))
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+    def __repr__(self):
+        if self.keys():
+            m = max(map(len, list(self.keys()))) + 1
+            return '\n'.join([k.rjust(m) + ': ' + repr(v)
+                              for k, v in sorted(self.items())])
+        else:
+            return self.__class__.__name__ + "()"
+
+    def __dir__(self):
+        return list(self.keys())

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/methods.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+__all__ = ["bls_fast", "bls_slow"]
+
+import numpy as np
+from functools import partial
+
+from ._impl import bls_impl
+
+
+def bls_slow(t, y, ivar, period, duration, oversample, use_likelihood):
+    """Compute the periodogram using a brute force reference method
+
+    t : array-like
+        Sequence of observation times.
+    y : array-like
+        Sequence of observations associated with times t.
+    ivar : array-like
+        The inverse variance of ``y``.
+    period : array-like
+        The trial periods where the periodogram should be computed.
+    duration : array-like
+        The durations that should be tested.
+    oversample :
+        The resolution of the phase grid in units of durations.
+    use_likeliood : bool
+        If true, maximize the log likelihood over phase, duration, and depth.
+
+    Returns
+    -------
+    power : array-like
+        The periodogram evaluated at the periods in ``period``.
+    depth : array-like
+        The estimated depth of the maximum power model at each period.
+    depth_err : array-like
+        The 1-sigma uncertainty on ``depth``.
+    duration : array-like
+        The maximum power duration at each period.
+    transit_time : array-like
+        The maximum power phase of the transit in units of time. This
+        indicates the mid-transit time and it will always be in the range
+        (0, period).
+    depth_snr : array-like
+        The signal-to-noise with which the depth is measured at maximum power.
+    log_likelihood : array-like
+        The log likelihood of the maximum power model.
+
+    """
+    f = partial(_bls_slow_one, t, y, ivar, duration,
+                oversample, use_likelihood)
+    return _apply(f, period)
+
+
+def bls_fast(t, y, ivar, period, duration, oversample, use_likelihood):
+    """Compute the periodogram using an optimized Cython implementation
+
+    t : array-like
+        Sequence of observation times.
+    y : array-like
+        Sequence of observations associated with times t.
+    ivar : array-like
+        The inverse variance of ``y``.
+    period : array-like
+        The trial periods where the periodogram should be computed.
+    duration : array-like
+        The durations that should be tested.
+    oversample :
+        The resolution of the phase grid in units of durations.
+    use_likeliood : bool
+        If true, maximize the log likelihood over phase, duration, and depth.
+
+    Returns
+    -------
+    power : array-like
+        The periodogram evaluated at the periods in ``period``.
+    depth : array-like
+        The estimated depth of the maximum power model at each period.
+    depth_err : array-like
+        The 1-sigma uncertainty on ``depth``.
+    duration : array-like
+        The maximum power duration at each period.
+    transit_time : array-like
+        The maximum power phase of the transit in units of time. This
+        indicates the mid-transit time and it will always be in the range
+        (0, period).
+    depth_snr : array-like
+        The signal-to-noise with which the depth is measured at maximum power.
+    log_likelihood : array-like
+        The log likelihood of the maximum power model.
+
+    """
+    return bls_impl(
+        t, y, ivar, period, duration, oversample, use_likelihood
+    )
+
+
+def _bls_slow_one(t, y, ivar, duration, oversample, use_likelihood, period):
+    """A private function to compute the brute force periodogram result"""
+    best = (-np.inf, None)
+    hp = 0.5*period
+    min_t = np.min(t)
+    for dur in duration:
+
+        # Compute the phase grid (this is set by the duration and oversample).
+        d_phase = dur / oversample
+        phase = np.arange(0, period+d_phase, d_phase)
+
+        for t0 in phase:
+            # Figure out which data points are in and out of transit.
+            m_in = np.abs((t-min_t-t0+hp) % period - hp) < 0.5*dur
+            m_out = ~m_in
+
+            # Compute the estimates of the in and out-of-transit flux.
+            ivar_in = np.sum(ivar[m_in])
+            ivar_out = np.sum(ivar[m_out])
+            y_in = np.sum(y[m_in] * ivar[m_in]) / ivar_in
+            y_out = np.sum(y[m_out] * ivar[m_out]) / ivar_out
+
+            # Use this to compute the best fit depth and uncertainty.
+            depth = y_out - y_in
+            depth_err = np.sqrt(1.0 / ivar_in + 1.0 / ivar_out)
+            snr = depth / depth_err
+
+            # Compute the log likelihood of this model.
+            loglike = -0.5*np.sum((y_in - y[m_in])**2 * ivar[m_in])
+            loglike += 0.5*np.sum((y_out - y[m_in])**2 * ivar[m_in])
+
+            # Choose which objective should be used for the optimization.
+            if use_likelihood:
+                objective = loglike
+            else:
+                objective = snr
+
+            # If this model is better than any before, keep it.
+            if depth > 0 and objective > best[0]:
+                best = (
+                    objective,
+                    (objective, depth, depth_err, dur, (t0+min_t) % period,
+                     snr, loglike)
+                )
+
+    return best[1]
+
+
+def _apply(f, period):
+    return tuple(map(np.array, zip(*map(f, period))))

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/setup_package.py

@@ -0,0 +1,21 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+
+import os
+from os.path import join
+
+from distutils.core import Extension
+
+
+BLS_ROOT = os.path.relpath(os.path.dirname(__file__))
+
+
+def get_extensions():
+    ext = Extension(
+        "astropy.timeseries.periodograms.bls._impl",
+        sources=[
+            join(BLS_ROOT, "bls.c"),
+            join(BLS_ROOT, "_impl.pyx"),
+        ],
+        include_dirs=["numpy"],
+    )
+    return [ext]

testbed/astropy__astropy/astropy/timeseries/periodograms/bls/tests/__init__.py

@@ -0,0 +1 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst