sunpy-0.7.4/0000755000175000001440000000000013011056504013374 5ustar stuartusers00000000000000sunpy-0.7.4/README.md0000644000175000001440000000577512753153421014701 0ustar stuartusers00000000000000# [SunPy](http://sunpy.org) [![Downloads](https://img.shields.io/pypi/dm/sunpy.svg)](https://pypi.python.org/pypi/sunpy/) [![Latest Version](https://img.shields.io/pypi/v/sunpy.svg)](https://pypi.python.org/pypi/sunpy/) [![Build Status](https://secure.travis-ci.org/sunpy/sunpy.svg)] (http://travis-ci.org/sunpy/sunpy)[![Build status](https://ci.appveyor.com/api/projects/status/xow461iejsjvp9vl?svg=true)](https://ci.appveyor.com/project/sunpy/sunpy)[![Coverage Status](https://coveralls.io/repos/sunpy/sunpy/badge.svg?branch=master)](https://coveralls.io/r/sunpy/sunpy?branch=master) [![Code Health](https://landscape.io/github/sunpy/sunpy/master/landscape.svg)](https://landscape.io/github/sunpy/sunpy/master) [![Code Issues](https://www.quantifiedcode.com/api/v1/project/9edd3e28230840038713e1c7dc3eb141/badge.svg)](https://www.quantifiedcode.com/app/project/9edd3e28230840038713e1c7dc3eb141)[![Research software impact](http://depsy.org/api/package/pypi/sunpy/badge.svg)](http://depsy.org/package/python/sunpy) SunPy is an open-source Python library for solar physics data analysis. [![Visit our IRC channel](https://kiwiirc.com/buttons/chat.freenode.com/sunpy.png)](https://kiwiirc.com/client/chat.freenode.com/#sunpy) Installation ------------ To begin, install the following requirements: * [Python](http://www.python.org) (2.7) * [Astropy](http://astropy.org) (1.0.0) * [NumPy](http://numpy.scipy.org/) * [SciPy](http://www.scipy.org/) * [Matplotlib](http://matplotlib.sourceforge.net/) (1.1+) * [suds-jurko](https://bitbucket.org/jurko/suds) * [pandas](http://pandas.pydata.org/) (0.10.0+) * [beautifulsoup4](http://www.crummy.com/software/BeautifulSoup/) * [sqlalchemy](http://www.sqlalchemy.org/) Next, use git to grab the latest version of SunPy: git clone https://github.com/sunpy/sunpy.git cd sunpy python setup.py install Done! For detailed installation instructions, see the [installation guide](http://docs.sunpy.org/en/latest/guide/installation/index.html) in the SunPy docs. Usage ----- Here is a quick example of plotting an AIA image: ```python >>> import sunpy.map >>> import sunpy.data.sample >>> import matplotlib.cm as cm >>> aia = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE) >>> aia.peek() ``` Getting Help ------------ For more information or to ask questions about SunPy, check out: * [SunPy Documentation](http://docs.sunpy.org/en/latest/) * [SunPy Mailing List](https://groups.google.com/forum/#!forum/sunpy) * IRC: #sunpy on [freenode.net](http://webchat.freenode.net/) Contributing ------------ If you would like to get involved, start by joining the [SunPy mailing list](https://groups.google.com/forum/#!forum/sunpy) and check out the [Developer's Guide](http://docs.sunpy.org/en/latest/dev.html) section of the SunPy docs. Stop by our IRC chat room named #sunpy on irc.freenode.net if you have any questions. Help is always welcome so let us know what you like to work on, or check out the [issues page](https://github.com/sunpy/sunpy/issues) for a list of some known outstanding items. sunpy-0.7.4/CHANGELOG.md0000644000175000001440000003456513011055565015230 0ustar stuartusers000000000000000.7.4 ------ * Remove Map always forcing warnings on. * `Map.center` now uses `Map.wcs` to correctly handle rotation. * Fix link in coordinates documentation. * Update helioviewer URL to HTTPS (fixes access to Helioviewer). * Fix processing of TRACE and YOHKOH measurement properties. * Remove warnings when using `Map.peek(basic_plot=True)` * Update docstrings for HPC and HCC frames. 0.7.3 ------ * Fix ConfigParser for Python 3.5.2 - This allows SunPy to run under Python 3.5.2 * Fix incorrect ordering of keys in `MapMeta` * Add `sunpy.util.scraper` to the API documentation. 0.7.2 ----- * Fixed bugs in `sun` equations 0.7.1 ----- * Fix bug in `wcs.convert_data_to_pixel` where crpix[1] was used for both axes. * Fix some leftover instances of `GenericMap.units` * Fixed bugs in `sun` equations * Now the `sunpy.database.tables.display_entries()` prints an astropy table. * Additional methods added inside the `sunpy.database` class to make it easier to display the database contents. * `sunpy.io.fits.read` will now return any parse-able HDUs even if some raise an error. * `VSOClient` no longer prints a lot of XML junk if the query fails. * Remove unused `sunpy.visualization.plotting` module * `Map.peek(basic_plot=True)` no longer issues warnings 0.7.0 ----- * Added `timeout` parameter in `sunpy.data.download_sample_data()` * Fixed `aiaprep` to return properly sized map. * Deprecation warnings fixed when using image coalignment. * Sunpy is now Python 3.x compatible (3.4 and 3.5). * Added a unit check and warnings for map metadata. * Added IRIS SJI color maps. * Updated `show_colormaps()` with new string filter to show a subset of color maps. * Fixed MapCube animations by working around a bug in Astropy's ImageNormalize * Remove ``vso.QueryResponse.num_records()`` in favour of `len(qr)` * Add a `draw_rectangle` helper to `GenericMap` which can plot rectangles in the native coordinate system of the map. * Added the ability to shift maps to correct for incorrect map location, for example. * Bug fix for RHESSI summary light curve values. * Mapcube solar derotation and coalignment now pass keywords to the routine used to shift the images, scipy.ndimage.interpolation.shift. * Add automatic registration of ``GenericMap`` subclasses with the factory as long as they define an ``is_datasource_for`` method. * Added functions ``flareclass_to_flux`` and ``flux_to_flareclass`` which convert between GOES flux to GOES class numbers (e.g. X12, M3.4). * Removed old ``sunpy.util.goes_flare_class()`` * Bug fix for RHESSI summary light curve values. * The ``MapCube.as_array`` function now returns a masked numpy array if at least one of the input maps in the MapCube has a mask. * Map superpixel method now respects maps that have masks. * Map superpixel method now accepts numpy functions as an argument, or any user-defined function. * Map superpixel method no longer has the restriction that the number of original pixels in the x (or y) side of the superpixel exactly divides the number of original pixels in the x (or y) side of the original map data. * `sunpy.physics.transforms` has been deprecated and the code moved into `sunpy.physics`. * Add the `sunpy.coordinates` module, this adds the core physical solar coordinates frame within the astropy coordinates framework. * Added ability of maps to draw contours on top of themselves (`draw_contours`) * Added concatenate functionality to lightcurve base class. * Fix Map to allow astropy.io.fits Header objects as valid input for meta arguments. * Added an examples gallery using `sphinx-gallery`. * API clean up to constants. Removed constant() function which is now replaced by get(). * Prevent helioviewer tests from checking access to the API endpoint when running tests offline. * `GenericMap.units` is renamed to `GenericMap.spatial_units` to avoid confusion with `NDData.unit`. * `GenericMap` now has a `coordinate_frame` property which returns an `astropy.coordinates` frame with all the meta data from the map populated. * `GenericMap` now has a `_mpl_axes` method which allows it to be specified as a projection to `matplotlib` methods and will return a `WCSAxes` object with `WCS` projection. 0.6.0 ----- * Enforced the use of Astropy Quantities through out most of SunPy. * Dropped Support for Python 2.6. * Remove old style string formatting and other 2.6 compatibility lines. * Added vso like querying feature to JSOC Client. * Refactor the JSOC client so that it follows the .query() .get() interface of VSOClient and UnifedDownloader. * Provide `__str__` and `__repr__` methods on vso `QueryResponse` deprecate `.show()`. * Downloaded files now keep file extensions rather than replacing all periods with underscores. * Update to TimeRange API, removed t1 and t0, start and end are now read-only attributes. * Added ability to download level3 data for lyra Light Curve along with corresponding tests. * Added support for gzipped FITS files. * Add STEREO HI Map subclass and color maps. * Map.rotate() no longer crops any image data. * For accuracy, default Map.rotate() transformation is set to bi-quartic. * `sunpy.image.transform.affine_transform` now casts integer data to float64 and sets NaN values to 0 for all transformations except scikit-image rotation with order <= 3. * CD matrix now updated, if present, when Map pixel size is changed. * Removed now-redundant method for rotating IRIS maps since the functionality exists in Map.rotate() * Provide `__str__` and `__repr__` methods on vso `QueryResponse` deprecate `.show()` * SunPy colormaps are now registered with matplotlib on import of `sunpy.cm` * `sunpy.cm.get_cmap` no longer defaults to 'sdoaia94' * Added database url config setting to be setup by default as a sqlite database in the sunpy working directory * Added a few tests for the sunpy.roi module * Added capability for figure-based tests * Removed now-redundant method for rotating IRIS maps since the functionality exists in Map.rotate(). * SunPy colormaps are now registered with matplotlib on import of `sunpy.cm`. * `sunpy.cm.get_cmap` no longer defaults to 'sdoaia94'. * Added database url config setting to be setup by default as a sqlite database in the sunpy working directory. * Added a few tests for the sunpy.roi module. * Refactored mapcube co-alignment functionality. * Removed sample data from distribution and added ability to download sample files * Changed start of GOES 2 operational time range back to 1980-01-04 so data from 1980 can be read into GOESLightCurve object * Require JSOC request data calls have an email address attached. * Calculation of the solar rotation of a point on the Sun as seen from Earth, and its application to the de-rotation of mapcubes. * Downloaded files now keep file extensions rather than replacing all periods with underscores * Fixed the downloading of files with duplicate names in sunpy.database * Removed sample data from distribution and added ability to download sample files. * Added the calculation of the solar rotation of a point on the Sun as seen from Earth, and its application to the de-rotation of mapcubes. * Changed default for GOESLightCurve.create() so that it gets the data from the most recent existing GOES fits file. * Map plot functionality now uses the mask property if it is present, allowing the plotting of masked map data * Map Expects Quantities and returns quantities for most parameters. * Map now used Astropy.wcs for world <-> pixel conversions. * map.data_to_pixel now has a similar API to map.pixel_to_data. * map.shape has been replaced with map.dimensions, which is ordered x first. * map.rsun_arcseconds is now map.rsun_obs as it returns a quantity. * Map properties are now named tuples rather than dictionaries. * Improvement for Map plots, standardization and improved color tables, better access to plot variables through new plot_settings variable. * Huge improvements in Instrument Map doc strings. Now contain instrument descriptions as well as reference links for more info. * net.jsoc can query data series with time sampling by a Sample attribute implemented in vso. * MapCube.plot and MapCube.peek now support a user defined plot_function argument for customising the animation. * Added new sample data file, an AIA cutout file. * Moved documentation build directory to doc/build 0.5.0 ----- * Added additional functionality to the GOES module i.e. the ability to calculate GOES temperature and emission measure from GOES fluxes. * changed _maps attribute in MapCube to a non-hidden type * Added Nobeyama Radioheliograph data support to Lightcurve object. * Fixed some tests on map method to support Windows * Added a window/split method to time range * Updates to spectrogram documentation * Added method Database.add_from_hek_query_result to HEK database * Added method Database.download_from_vso_query_result * GOES Lightcurve now makes use of a new source of GOES data, provides metadata, and data back to 1981. * Removed sqlalchemy as a requirement for SunPy * Added support for NOAA solar cycle prediction in lightcurves * Some basic tests for GenericLightCurve on types of expected input. * Fix algorithm in sunpy.sun.equation_of_center * Added Docstrings to LightCurve methods. * Added tests for classes in sunpy.map.sources. Note that some classes (TRACE, RHESSI) were left out because SunPy is not able to read their FITS files. * Added functions that implement image coalignment with support for MapCubes. * Cleaned up the sunpy namespace, removed .units, /ssw and .sphinx. Also moved .coords .physics.transforms. * Added contains functionality to TimeRange module * Added t='now' to parse_time to privide utcnow datetime. * Fixed time dependant functions (.sun) to default to t='now' * Fixed solar_semidiameter_angular_size * Improved line quality and performances issues with map.draw_grid() * Remove deprecated make_map command. 0.4.1 ----- Bug Fixes: * Fix map.rotate() functionality * Change of source for GOES data. * Fix EIT test data and sunpy FITS saving * Some documentation fixes * fix file paths to use os.path.join for platform independance. 0.4.0 ----- Features: * **Major** documentation refactor. A far reaching re-write and restructure. * Add a SunPy Database to store and search local data. * Add beta support for querying the HELIO HEC * Add beta HEK to VSO query translation. * Add the ability to download the GOES event list. * Add support for downloading and querying the LYTAF database. * Add support for ANA data. * Updated sun.constants to use astropy.constants objects which include units, source, and error instide. For more info check out http://docs.astropy.org/en/latest/constants/index.html * Add some beta support for IRIS data products * Add a new MapCubeAnimator class with interactive widgets which is returned by mapcube.peek(). * The Glymur library is now used to read JPEG2000 files. * GOESLightCurve now supports all satellites. Bug Fixes: * Add support for VSO queries through proxies. * Fix apparent Right Ascension calulations. * LightCurve meta data member now an OrderedDict Instance 0.3.2 ----- Bug Fixes: * Pass draw_limb arguments to patches.Circle * Pass graw_grid arguments to pyplot.plot() * Fix README code example * Fix Documentation links in potting guide * Update to new EVE data URL * Update LogicalLightcurve example in docs * Improved InteractiveVSOClient documentation * GOESLightCurve now fails politely if no data is avalible. Known Bugs: * sunpy.util.unit_conversion.to_angstrom does not work if 'nm' is passed in. 0.3.1 ----- * Bug Fix: Fix a regression in CompositeMap that made contor plots fail. * Bug Fix: Allow Map() to accept dict as metadata. * Bug Fix: Pass arguments from Map() to io.read_file. 0.3.0 ===== Major Changes: * Removal of Optional PIL dependancy * Parse_time now looks through nested lists/tuples * Draw_limb and draw_grid are now implemented on MapCube and CompositeMap * Caculations for differential roation added * mapcube.plot() now runs a mpl animation with optional controls * A basic Region of Interest framework now exists under sunpy.roi * STEREO COR colour maps have been ported from solarsoft. * sunpy.time.timerange has a split() method that divides up a time range into n equal parts. * Added download progress bar * pyfits is depricated in favor of Astropy spectra: * Plotting has been refactorted to use a consistent interface * spectra now no-longer inherits from numpy.ndarray instead has a .data attribute. Map: * map now no-longer inherits from numpy.ndarray instead has a .data attribute. * make_map is deprecated in favor of Map which is a new factory class * sunpy.map.Map is now sunpy.map.GenericMap * mymap.header is now mymap.meta * attributes of the map class are now read only, changes have to be made through map.meta * new MapMeta class to replace MapHeader, MapMeta is not returned by sunpy.io * The groundwork for GenericMap inherting from astropy.NDData has been done, there is now a NDDataStandin class to provide basic functionality. io: * top level file_tools improved to be more flexible and support multiple HDUs * all functions in sunpy.io now assume mutliple HDUs, even JP2 ones. * there is now a way to override the automatic filetype detection * Automatic fits file detection improved * extract_waveunit added to io.fits for detection of common ways of storing wavelength unit in fits files. Bug fixes or under the hood changes: * A major re-work of all interal imports has resulted in a much cleaner namespace, i.e. sunpy.util.util is no longer used to import util. * Some SOHO and STEREO files were not reading properly due to a date_obs parameter. * Sunpy will now read JP2 files without a comment parameter. * Memory leak in Crotate patched * Callisto: Max gap between files removed 0.2.0 ===== Below are the main features that have been added for this release: * Completely re-written plotting routines for most of the core datatypes. * JPEG 2000 support as an input file type. * Improved documentation for much of the code base, including re-written installation instructions. * New lightcurve object * LYRA support * GOES/XRS support * SDO/EVE support * New Spectrum and Spectrogram object (in development) * Spectrogram plotting routines * Callisto spectrum type and support * STEREO/SWAVES support * Map Object * Added support for LASCO, Yohkoh/XRT maps * A new CompositeMap object for overlaying maps * Resample method * Superpixel method * The addition of the rotate() method for 2D maps. sunpy-0.7.4/setup.py0000755000175000001440000001106713011054536015121 0ustar stuartusers00000000000000#!/usr/bin/env python # This file is based havily on the astropy version here: # https://github.com/astropy/package-template/blob/master/setup.py # Which is licensed under the astropy license. import glob import os import sys import ah_bootstrap from setuptools import setup # A dirty hack to get around some early import/configurations ambiguities if sys.version_info[0] >= 3: import builtins else: import __builtin__ as builtins builtins._ASTROPY_SETUP_ = True # -- Read the Docs Setup ----------------------------------------------------- on_rtd = os.environ.get('READTHEDOCS', None) == 'True' if on_rtd: os.environ['HOME'] = '/home/docs/' os.environ['SUNPY_CONFIGDIR'] = '/home/docs/' from astropy_helpers.setup_helpers import ( register_commands, get_debug_option, get_package_info) from astropy_helpers.git_helpers import get_git_devstr from astropy_helpers.version_helpers import generate_version_py # Get some values from the setup.cfg try: from ConfigParser import ConfigParser except ImportError: from configparser import ConfigParser conf = ConfigParser() conf.read(['setup.cfg']) metadata = dict(conf.items('metadata')) PACKAGENAME = metadata.get('package_name', 'packagename') DESCRIPTION = metadata.get('description', 'SunPy: Python for Solar Physics') AUTHOR = metadata.get('author', 'The SunPy Community') AUTHOR_EMAIL = metadata.get('author_email', 'sunpy@googlegroups.com') LICENSE = metadata.get('license', 'BSD 2-Clause') URL = metadata.get('url', 'http://sunpy.org') LONG_DESCRIPTION = "SunPy is a Python library for solar physics data analysis." # Store the package name in a built-in variable so it's easy # to get from other parts of the setup infrastructure builtins._ASTROPY_PACKAGE_NAME_ = PACKAGENAME # VERSION should be PEP386 compatible (http://www.python.org/dev/peps/pep-0386) VERSION = '0.7.4' # Indicates if this version is a release version RELEASE = 'dev' not in VERSION if not RELEASE: VERSION += get_git_devstr(False) # Populate the dict of setup command overrides; this should be done before # invoking any other functionality from distutils since it can potentially # modify distutils' behavior. cmdclassd = register_commands(PACKAGENAME, VERSION, RELEASE) try: from sunpy.tests.setup_command import SunPyTest # Overwrite the Astropy Testing framework cmdclassd['test'] = type('SunPyTest', (SunPyTest,), {'package_name': 'sunpy'}) except Exception: # Catch everything, if it doesn't work, we still want SunPy to install. pass # Freeze build information in version.py generate_version_py(PACKAGENAME, VERSION, RELEASE, get_debug_option(PACKAGENAME)) # Treat everything in scripts except README.rst as a script to be installed scripts = [fname for fname in glob.glob(os.path.join('scripts', '*')) if os.path.basename(fname) != 'README.rst'] # Get configuration information from all of the various subpackages. # See the docstring for setup_helpers.update_package_files for more # details. package_info = get_package_info() # Add the project-global data package_info['package_data'].setdefault(PACKAGENAME, []) # Include all .c files, recursively, including those generated by # Cython, since we can not do this in MANIFEST.in with a "dynamic" # directory name. c_files = [] for root, dirs, files in os.walk(PACKAGENAME): for filename in files: if filename.endswith('.c'): c_files.append( os.path.join( os.path.relpath(root, PACKAGENAME), filename)) package_info['package_data'][PACKAGENAME].extend(c_files) extras_require = {'database': ["sqlalchemy"], 'image': ["scikit-image"], 'jpeg2000': ["glymur"], 'net': ["suds-jurko", "beautifulsoup4", "requests"]} extras_require['all'] = extras_require['database'] + extras_require['image'] + \ extras_require['net'] + ["wcsaxes>=0.8"] setup(name=PACKAGENAME, version=VERSION, description=DESCRIPTION, scripts=scripts, setup_requires=['numpy>1.7.1'], install_requires=['numpy>1.7.1', 'astropy>=1.0.0', 'scipy', 'pandas>=0.12.0', 'matplotlib>=1.1'], extras_require=extras_require, provides=[PACKAGENAME], author=AUTHOR, author_email=AUTHOR_EMAIL, license=LICENSE, url=URL, long_description=LONG_DESCRIPTION, cmdclass=cmdclassd, zip_safe=False, use_2to3=False, include_package_data=True, **package_info ) sunpy-0.7.4/PKG-INFO0000644000175000001440000000045713011056504014477 0ustar stuartusers00000000000000Metadata-Version: 1.1 Name: sunpy Version: 0.7.4 Summary: SunPy: Python for Solar Physics Home-page: http://sunpy.org/ Author: The SunPy Community Author-email: sunpy@googlegroups.com License: BSD Description: SunPy is a Python library for solar physics data analysis. Platform: UNKNOWN Provides: sunpy sunpy-0.7.4/astropy_helpers/0000755000175000001440000000000013011056504016617 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/0000755000175000001440000000000013011056504023534 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/PKG-INFO0000644000175000001440000000564412753326222024653 0ustar stuartusers00000000000000Metadata-Version: 1.1 Name: astropy-helpers Version: 1.2.dev572 Summary: Utilities for building and installing Astropy, Astropy affiliated packages, and their respective documentation. Home-page: http://astropy.org Author: The Astropy Developers Author-email: astropy.team@gmail.com License: BSD Download-URL: http://pypi.python.org/packages/source/a/astropy-helpers/astropy-helpers-1.2.dev572.tar.gz Description: astropy-helpers =============== This project provides a Python package, ``astropy_helpers``, which includes many build, installation, and documentation-related tools used by the Astropy project, but packaged separately for use by other projects that wish to leverage this work. The motivation behind this package and details of its implementation are in the accepted `Astropy Proposal for Enhancement (APE) 4 `_. ``astropy_helpers`` includes a special "bootstrap" module called ``ah_bootstrap.py`` which is intended to be used by a project's setup.py in order to ensure that the ``astropy_helpers`` package is available for build/installation. This is similar to the ``ez_setup.py`` module that is shipped with some projects to bootstrap `setuptools `_. As described in APE4, the version numbers for ``astropy_helpers`` follow the corresponding major/minor version of the `astropy core package `_, but with an independent sequence of micro (bugfix) version numbers. Hence, the initial release is 0.4, in parallel with Astropy v0.4, which will be the first version of Astropy to use ``astropy-helpers``. For examples of how to implement ``astropy-helpers`` in a project, see the ``setup.py`` and ``setup.cfg`` files of the `Affiliated package template `_. .. image:: https://travis-ci.org/astropy/astropy-helpers.png :target: https://travis-ci.org/astropy/astropy-helpers .. image:: https://coveralls.io/repos/astropy/astropy-helpers/badge.png :target: https://coveralls.io/r/astropy/astropy-helpers Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: Framework :: Setuptools Plugin Classifier: Framework :: Sphinx :: Extension Classifier: Framework :: Sphinx :: Theme Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Build Tools Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Archiving :: Packaging sunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/SOURCES.txt0000644000175000001440000000663612753326222025444 0ustar stuartusers00000000000000CHANGES.rst LICENSE.rst MANIFEST.in README.rst ah_bootstrap.py ez_setup.py setup.cfg setup.py astropy_helpers/__init__.py astropy_helpers/distutils_helpers.py astropy_helpers/git_helpers.py astropy_helpers/setup_helpers.py astropy_helpers/test_helpers.py astropy_helpers/utils.py astropy_helpers/version.py astropy_helpers/version_helpers.py astropy_helpers.egg-info/PKG-INFO astropy_helpers.egg-info/SOURCES.txt astropy_helpers.egg-info/dependency_links.txt astropy_helpers.egg-info/not-zip-safe astropy_helpers.egg-info/top_level.txt astropy_helpers/commands/__init__.py astropy_helpers/commands/_dummy.py astropy_helpers/commands/_test_compat.py astropy_helpers/commands/build_ext.py astropy_helpers/commands/build_py.py astropy_helpers/commands/build_sphinx.py astropy_helpers/commands/install.py astropy_helpers/commands/install_lib.py astropy_helpers/commands/register.py astropy_helpers/commands/setup_package.py astropy_helpers/commands/test.py astropy_helpers/commands/src/compiler.c astropy_helpers/compat/__init__.py astropy_helpers/compat/subprocess.py astropy_helpers/sphinx/__init__.py astropy_helpers/sphinx/conf.py astropy_helpers/sphinx/setup_package.py astropy_helpers/sphinx/ext/__init__.py astropy_helpers/sphinx/ext/astropyautosummary.py astropy_helpers/sphinx/ext/autodoc_enhancements.py astropy_helpers/sphinx/ext/automodapi.py astropy_helpers/sphinx/ext/automodsumm.py astropy_helpers/sphinx/ext/changelog_links.py astropy_helpers/sphinx/ext/comment_eater.py astropy_helpers/sphinx/ext/compiler_unparse.py astropy_helpers/sphinx/ext/docscrape.py astropy_helpers/sphinx/ext/docscrape_sphinx.py astropy_helpers/sphinx/ext/doctest.py astropy_helpers/sphinx/ext/edit_on_github.py astropy_helpers/sphinx/ext/numpydoc.py astropy_helpers/sphinx/ext/phantom_import.py astropy_helpers/sphinx/ext/smart_resolver.py astropy_helpers/sphinx/ext/tocdepthfix.py astropy_helpers/sphinx/ext/traitsdoc.py astropy_helpers/sphinx/ext/utils.py astropy_helpers/sphinx/ext/viewcode.py astropy_helpers/sphinx/ext/templates/autosummary_core/base.rst astropy_helpers/sphinx/ext/templates/autosummary_core/class.rst astropy_helpers/sphinx/ext/templates/autosummary_core/module.rst astropy_helpers/sphinx/ext/tests/__init__.py astropy_helpers/sphinx/ext/tests/test_autodoc_enhancements.py astropy_helpers/sphinx/ext/tests/test_automodapi.py astropy_helpers/sphinx/ext/tests/test_automodsumm.py astropy_helpers/sphinx/ext/tests/test_docscrape.py astropy_helpers/sphinx/ext/tests/test_utils.py astropy_helpers/sphinx/local/python3links.inv astropy_helpers/sphinx/themes/bootstrap-astropy/globaltoc.html astropy_helpers/sphinx/themes/bootstrap-astropy/layout.html astropy_helpers/sphinx/themes/bootstrap-astropy/localtoc.html astropy_helpers/sphinx/themes/bootstrap-astropy/searchbox.html astropy_helpers/sphinx/themes/bootstrap-astropy/theme.conf astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout.svg astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_linkout_20.png astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.ico astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo.svg astropy_helpers/sphinx/themes/bootstrap-astropy/static/astropy_logo_32.png astropy_helpers/sphinx/themes/bootstrap-astropy/static/bootstrap-astropy.css astropy_helpers/sphinx/themes/bootstrap-astropy/static/copybutton.js astropy_helpers/sphinx/themes/bootstrap-astropy/static/sidebar.js licenses/LICENSE_COPYBUTTON.rst licenses/LICENSE_NUMPYDOC.rstsunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/not-zip-safe0000644000175000001440000000000112753326222025773 0ustar stuartusers00000000000000 sunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/dependency_links.txt0000644000175000001440000000000112753326222027613 0ustar stuartusers00000000000000 sunpy-0.7.4/astropy_helpers/astropy_helpers.egg-info/top_level.txt0000644000175000001440000000002012753326222026267 0ustar stuartusers00000000000000astropy_helpers sunpy-0.7.4/astropy_helpers/LICENSE.rst0000644000175000001440000000272312753326222020450 0ustar stuartusers00000000000000Copyright (c) 2014, 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. sunpy-0.7.4/astropy_helpers/CHANGES.rst0000644000175000001440000003260013011054225020420 0ustar stuartusers00000000000000astropy-helpers Changelog ========================= 1.2 (unreleased) ---------------- - Added sphinx configuration value ``automodsumm_inherited_members``. If ``True`` this will include members that are inherited from a base class in the generated API docs. Defaults to ``False`` which matches the previous behavior. [#215] 1.1.3 (unreleased) ------------------ - Fixed ``build_sphinx`` to recognize builds that succeeded but have output *after* the "build succeeded." statement. This only applies when ``--warnings-returncode`` is given (which is primarily relevant for Travis documentation builds). [#223] 1.1.2 (2016-03-9) ----------------- - The CSS for the sphinx documentation was altered to prevent some text overflow problems. [#217] 1.1.1 (2015-12-23) ------------------ - Fixed crash in build with ``AttributeError: cython_create_listing`` with older versions of setuptools. [#209] 1.1 (2015-12-10) ---------------- - The original ``AstropyTest`` class in ``astropy_helpers``, which implements the ``setup.py test`` command, is deprecated in favor of moving the implementation of that command closer to the actual Astropy test runner in ``astropy.tests``. Now a dummy ``test`` command is provided solely for informing users that they need ``astropy`` installed to run the tests (however, the previous, now deprecated implementation is still provided and continues to work with older versions of Astropy). See the related issue for more details. [#184] - Added a useful new utility function to ``astropy_helpers.utils`` called ``find_data_files``. This is similar to the ``find_packages`` function in setuptools in that it can be used to search a package for data files (matching a pattern) that can be passed to the ``package_data`` argument for ``setup()``. See the docstring to ``astropy_helpers.utils.find_data_files`` for more details. [#42] - The ``astropy_helpers`` module now sets the global ``_ASTROPY_SETUP_`` flag upon import (from within a ``setup.py``) script, so it's not necessary to have this in the ``setup.py`` script explicitly. If in doubt though, there's no harm in setting it twice. Putting it in ``astropy_helpers`` just ensures that any other imports that occur during build will have this flag set. [#191] - It is now possible to use Cython as a ``setup_requires`` build requirement, and still build Cython extensions even if Cython wasn't available at the beginning of the build processes (that is, is automatically downloaded via setuptools' processing of ``setup_requires``). [#185] - Moves the ``adjust_compiler`` check into the ``build_ext`` command itself, so it's only used when actually building extension modules. This also deprecates the stand-alone ``adjust_compiler`` function. [#76] - When running the ``build_sphinx`` / ``build_docs`` command with the ``-w`` option, the output from Sphinx is streamed as it runs instead of silently buffering until the doc build is complete. [#197] 1.0.6 (2015-12-04) ------------------ - Fixed bug where running ``./setup.py build_sphinx`` could return successfully even when the build was not successful (and should have returned a non-zero error code). [#199] 1.0.5 (2015-10-02) ------------------ - Fixed a regression in the ``./setup.py test`` command that was introduced in v1.0.4. 1.0.4 (2015-10-02) ------------------ - Fixed issue with the sphinx documentation css where the line numbers for code blocks were not aligned with the code. [#179] - Fixed crash that could occur when trying to build Cython extension modules when Cython isn't installed. Normally this still results in a failed build, but was supposed to provide a useful error message rather than crash outright (this was a regression introduced in v1.0.3). [#181] - Fixed a crash that could occur on Python 3 when a working C compiler isn't found. [#182] - Quieted warnings about deprecated Numpy API in Cython extensions, when building Cython extensions against Numpy >= 1.7. [#183] - Improved support for py.test >= 2.7--running the ``./setup.py test`` command now copies all doc pages into the temporary test directory as well, so that all test files have a "common root directory". [#189] 1.0.3 (2015-07-22) ------------------ - Added workaround for sphinx-doc/sphinx#1843, a but in Sphinx which prevented descriptor classes with a custom metaclass from being documented correctly. [#158] - Added an alias for the ``./setup.py build_sphinx`` command as ``./setup.py build_docs`` which, to a new contributor, should hopefully be less cryptic. [#161] - The fonts in graphviz diagrams now match the font of the HTML content. [#169] - When the documentation is built on readthedocs.org, MathJax will be used for math rendering. When built elsewhere, the "pngmath" extension is still used for math rendering. [#170] - Fix crash when importing astropy_helpers when running with ``python -OO`` [#171] - The ``build`` and ``build_ext`` stages now correctly recognize the presence of C++ files in Cython extensions (previously only vanilla C worked). [#173] 1.0.2 (2015-04-02) ------------------ - Various fixes enabling the astropy-helpers Sphinx build command and Sphinx extensions to work with Sphinx 1.3. [#148] - More improvement to the ability to handle multiple versions of astropy-helpers being imported in the same Python interpreter session in the (somewhat rare) case of nested installs. [#147] - To better support high resolution displays, use SVG for the astropy logo and linkout image, falling back to PNGs for browsers that support it. [#150, #151] - Improve ``setup_helpers.get_compiler_version`` to work with more compilers, and to return more info. This will help fix builds of Astropy on less common compilers, like Sun C. [#153] 1.0.1 (2015-03-04) ------------------ - Released in concert with v0.4.8 to address the same issues. - Improved the ``ah_bootstrap`` script's ability to override existing installations of astropy-helpers with new versions in the context of installing multiple packages simultaneously within the same Python interpreter (e.g. when one package has in its ``setup_requires`` another package that uses a different version of astropy-helpers. [#144] - Added a workaround to an issue in matplotlib that can, in rare cases, lead to a crash when installing packages that import matplotlib at build time. [#144] 0.4.8 (2015-03-04) ------------------ - Improved the ``ah_bootstrap`` script's ability to override existing installations of astropy-helpers with new versions in the context of installing multiple packages simultaneously within the same Python interpreter (e.g. when one package has in its ``setup_requires`` another package that uses a different version of astropy-helpers. [#144] - Added a workaround to an issue in matplotlib that can, in rare cases, lead to a crash when installing packages that import matplotlib at build time. [#144] 1.0 (2015-02-17) ---------------- - Added new pre-/post-command hook points for ``setup.py`` commands. Now any package can define code to run before and/or after any ``setup.py`` command without having to manually subclass that command by adding ``pre__hook`` and ``post__hook`` callables to the package's ``setup_package.py`` module. See the PR for more details. [#112] - The following objects in the ``astropy_helpers.setup_helpers`` module have been relocated: - ``get_dummy_distribution``, ``get_distutils_*``, ``get_compiler_option``, ``add_command_option``, ``is_distutils_display_option`` -> ``astropy_helpers.distutils_helpers`` - ``should_build_with_cython``, ``generate_build_ext_command`` -> ``astropy_helpers.commands.build_ext`` - ``AstropyBuildPy`` -> ``astropy_helpers.commands.build_py`` - ``AstropyBuildSphinx`` -> ``astropy_helpers.commands.build_sphinx`` - ``AstropyInstall`` -> ``astropy_helpers.commands.install`` - ``AstropyInstallLib`` -> ``astropy_helpers.commands.install_lib`` - ``AstropyRegister`` -> ``astropy_helpers.commands.register`` - ``get_pkg_version_module`` -> ``astropy_helpers.version_helpers`` - ``write_if_different``, ``import_file``, ``get_numpy_include_path`` -> ``astropy_helpers.utils`` All of these are "soft" deprecations in the sense that they are still importable from ``astropy_helpers.setup_helpers`` for now, and there is no (easy) way to produce deprecation warnings when importing these objects from ``setup_helpers`` rather than directly from the modules they are defined in. But please consider updating any imports to these objects. [#110] - Use of the ``astropy.sphinx.ext.astropyautosummary`` extension is deprecated for use with Sphinx < 1.2. Instead it should suffice to remove this extension for the ``extensions`` list in your ``conf.py`` and add the stock ``sphinx.ext.autosummary`` instead. [#131] 0.4.7 (2015-02-17) ------------------ - Fixed incorrect/missing git hash being added to the generated ``version.py`` when creating a release. [#141] 0.4.6 (2015-02-16) ------------------ - Fixed problems related to the automatically generated _compiler module not being created properly. [#139] 0.4.5 (2015-02-11) ------------------ - Fixed an issue where ah_bootstrap.py could blow up when astropy_helper's version number is 1.0. - Added a workaround for documentation of properties in the rare case where the class's metaclass has a property of the same name. [#130] - Fixed an issue on Python 3 where importing a package using astropy-helper's generated version.py module would crash when the current working directory is an empty git repository. [#114] - Fixed an issue where the "revision count" appended to .dev versions by the generated version.py did not accurately reflect the revision count for the package it belongs to, and could be invalid if the current working directory is an unrelated git repository. [#107] - Likewise, fixed a confusing warning message that could occur in the same circumstances as the above issue. [#121] 0.4.4 (2014-12-31) ------------------ - More improvements for building the documentation using Python 3.x. [#100] - Additional minor fixes to Python 3 support. [#115] - Updates to support new test features in Astropy [#92, #106] 0.4.3 (2014-10-22) ------------------ - The generated ``version.py`` file now preserves the git hash of installed copies of the package as well as when building a source distribution. That is, the git hash of the changeset that was installed/released is preserved. [#87] - In smart resolver add resolution for class links when they exist in the intersphinx inventory, but not the mapping of the current package (e.g. when an affiliated package uses an astropy core class of which "actual" and "documented" location differs) [#88] - Fixed a bug that could occur when running ``setup.py`` for the first time in a repository that uses astropy-helpers as a submodule: ``AttributeError: 'NoneType' object has no attribute 'mkdtemp'`` [#89] - Fixed a bug where optional arguments to the ``doctest-skip`` Sphinx directive were sometimes being left in the generated documentation output. [#90] - Improved support for building the documentation using Python 3.x. [#96] - Avoid error message if .git directory is not present. [#91] 0.4.2 (2014-08-09) ------------------ - Fixed some CSS issues in generated API docs. [#69] - Fixed the warning message that could be displayed when generating a version number with some older versions of git. [#77] - Fixed automodsumm to work with new versions of Sphinx (>= 1.2.2). [#80] 0.4.1 (2014-08-08) ------------------ - Fixed git revision count on systems with git versions older than v1.7.2. [#70] - Fixed display of warning text when running a git command fails (previously the output of stderr was not being decoded properly). [#70] - The ``--offline`` flag to ``setup.py`` understood by ``ah_bootstrap.py`` now also prevents git from going online to fetch submodule updates. [#67] - The Sphinx extension for converting issue numbers to links in the changelog now supports working on arbitrary pages via a new ``conf.py`` setting: ``changelog_links_docpattern``. By default it affects the ``changelog`` and ``whatsnew`` pages in one's Sphinx docs. [#61] - Fixed crash that could result from users with missing/misconfigured locale settings. [#58] - The font used for code examples in the docs is now the system-defined ``monospace`` font, rather than ``Minaco``, which is not available on all platforms. [#50] 0.4 (2014-07-15) ---------------- - Initial release of astropy-helpers. See `APE4 `_ for details of the motivation and design of this package. - The ``astropy_helpers`` package replaces the following modules in the ``astropy`` package: - ``astropy.setup_helpers`` -> ``astropy_helpers.setup_helpers`` - ``astropy.version_helpers`` -> ``astropy_helpers.version_helpers`` - ``astropy.sphinx`` - > ``astropy_helpers.sphinx`` These modules should be considered deprecated in ``astropy``, and any new, non-critical changes to those modules will be made in ``astropy_helpers`` instead. Affiliated packages wishing to make use those modules (as in the Astropy package-template) should use the versions from ``astropy_helpers`` instead, and include the ``ah_bootstrap.py`` script in their project, for bootstrapping the ``astropy_helpers`` package in their setup.py script. sunpy-0.7.4/astropy_helpers/setup.py0000755000175000001440000000402513011054225020333 0ustar stuartusers00000000000000#!/usr/bin/env python # Licensed under a 3-clause BSD style license - see LICENSE.rst import ah_bootstrap import pkg_resources from setuptools import setup from astropy_helpers.setup_helpers import register_commands, get_package_info from astropy_helpers.version_helpers import generate_version_py NAME = 'astropy_helpers' VERSION = '1.2.dev' RELEASE = 'dev' not in VERSION DOWNLOAD_BASE_URL = 'http://pypi.python.org/packages/source/a/astropy-helpers' generate_version_py(NAME, VERSION, RELEASE, False, uses_git=not RELEASE) # Use the updated version including the git rev count from astropy_helpers.version import version as VERSION cmdclass = register_commands(NAME, VERSION, RELEASE) # This package actually doesn't use the Astropy test command del cmdclass['test'] setup( name=pkg_resources.safe_name(NAME), # astropy_helpers -> astropy-helpers version=VERSION, description='Utilities for building and installing Astropy, Astropy ' 'affiliated packages, and their respective documentation.', author='The Astropy Developers', author_email='astropy.team@gmail.com', license='BSD', url='http://astropy.org', long_description=open('README.rst').read(), download_url='{0}/astropy-helpers-{1}.tar.gz'.format(DOWNLOAD_BASE_URL, VERSION), classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'Framework :: Setuptools Plugin', 'Framework :: Sphinx :: Extension', 'Framework :: Sphinx :: Theme', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Topic :: Software Development :: Build Tools', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: System :: Archiving :: Packaging' ], cmdclass=cmdclass, zip_safe=False, **get_package_info(exclude=['astropy_helpers.tests']) ) sunpy-0.7.4/astropy_helpers/astropy_helpers/0000755000175000001440000000000013011056504022042 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers/distutils_helpers.py0000644000175000001440000001735512753326222026206 0ustar stuartusers00000000000000""" This module contains various utilities for introspecting the distutils module and the setup process. Some of these utilities require the `astropy_helpers.setup_helpers.register_commands` function to be called first, as it will affect introspection of setuptools command-line arguments. Other utilities in this module do not have that restriction. """ import os import sys from distutils import ccompiler from distutils.dist import Distribution from distutils.errors import DistutilsError from .utils import silence # This function, and any functions that call it, require the setup in # `astropy_helpers.setup_helpers.register_commands` to be run first. def get_dummy_distribution(): """ Returns a distutils Distribution object used to instrument the setup environment before calling the actual setup() function. """ from .setup_helpers import _module_state if _module_state['registered_commands'] is None: raise RuntimeError( 'astropy_helpers.setup_helpers.register_commands() must be ' 'called before using ' 'astropy_helpers.setup_helpers.get_dummy_distribution()') # Pre-parse the Distutils command-line options and config files to if # the option is set. dist = Distribution({'script_name': os.path.basename(sys.argv[0]), 'script_args': sys.argv[1:]}) dist.cmdclass.update(_module_state['registered_commands']) with silence(): try: dist.parse_config_files() dist.parse_command_line() except (DistutilsError, AttributeError, SystemExit): # Let distutils handle DistutilsErrors itself AttributeErrors can # get raise for ./setup.py --help SystemExit can be raised if a # display option was used, for example pass return dist def get_distutils_option(option, commands): """ Returns the value of the given distutils option. Parameters ---------- option : str The name of the option commands : list of str The list of commands on which this option is available Returns ------- val : str or None the value of the given distutils option. If the option is not set, returns None. """ dist = get_dummy_distribution() for cmd in commands: cmd_opts = dist.command_options.get(cmd) if cmd_opts is not None and option in cmd_opts: return cmd_opts[option][1] else: return None def get_distutils_build_option(option): """ Returns the value of the given distutils build option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build option. If the option is not set, returns None. """ return get_distutils_option(option, ['build', 'build_ext', 'build_clib']) def get_distutils_install_option(option): """ Returns the value of the given distutils install option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build option. If the option is not set, returns None. """ return get_distutils_option(option, ['install']) def get_distutils_build_or_install_option(option): """ Returns the value of the given distutils build or install option. Parameters ---------- option : str The name of the option Returns ------- val : str or None The value of the given distutils build or install option. If the option is not set, returns None. """ return get_distutils_option(option, ['build', 'build_ext', 'build_clib', 'install']) def get_compiler_option(): """ Determines the compiler that will be used to build extension modules. Returns ------- compiler : str The compiler option specified for the build, build_ext, or build_clib command; or the default compiler for the platform if none was specified. """ compiler = get_distutils_build_option('compiler') if compiler is None: return ccompiler.get_default_compiler() return compiler def add_command_option(command, name, doc, is_bool=False): """ Add a custom option to a setup command. Issues a warning if the option already exists on that command. Parameters ---------- command : str The name of the command as given on the command line name : str The name of the build option doc : str A short description of the option, for the `--help` message is_bool : bool, optional When `True`, the option is a boolean option and doesn't require an associated value. """ dist = get_dummy_distribution() cmdcls = dist.get_command_class(command) if (hasattr(cmdcls, '_astropy_helpers_options') and name in cmdcls._astropy_helpers_options): return attr = name.replace('-', '_') if hasattr(cmdcls, attr): raise RuntimeError( '{0!r} already has a {1!r} class attribute, barring {2!r} from ' 'being usable as a custom option name.'.format(cmdcls, attr, name)) for idx, cmd in enumerate(cmdcls.user_options): if cmd[0] == name: log.warn('Overriding existing {0!r} option ' '{1!r}'.format(command, name)) del cmdcls.user_options[idx] if name in cmdcls.boolean_options: cmdcls.boolean_options.remove(name) break cmdcls.user_options.append((name, None, doc)) if is_bool: cmdcls.boolean_options.append(name) # Distutils' command parsing requires that a command object have an # attribute with the same name as the option (with '-' replaced with '_') # in order for that option to be recognized as valid setattr(cmdcls, attr, None) # This caches the options added through add_command_option so that if it is # run multiple times in the same interpreter repeated adds are ignored # (this way we can still raise a RuntimeError if a custom option overrides # a built-in option) if not hasattr(cmdcls, '_astropy_helpers_options'): cmdcls._astropy_helpers_options = set([name]) else: cmdcls._astropy_helpers_options.add(name) def get_distutils_display_options(): """ Returns a set of all the distutils display options in their long and short forms. These are the setup.py arguments such as --name or --version which print the project's metadata and then exit. Returns ------- opts : set The long and short form display option arguments, including the - or -- """ short_display_opts = set('-' + o[1] for o in Distribution.display_options if o[1]) long_display_opts = set('--' + o[0] for o in Distribution.display_options) # Include -h and --help which are not explicitly listed in # Distribution.display_options (as they are handled by optparse) short_display_opts.add('-h') long_display_opts.add('--help') # This isn't the greatest approach to hardcode these commands. # However, there doesn't seem to be a good way to determine # whether build *will be* run as part of the command at this # phase. display_commands = set([ 'clean', 'register', 'setopt', 'saveopts', 'egg_info', 'alias']) return short_display_opts.union(long_display_opts.union(display_commands)) def is_distutils_display_option(): """ Returns True if sys.argv contains any of the distutils display options such as --version or --name. """ display_options = get_distutils_display_options() return bool(set(sys.argv[1:]).intersection(display_options)) sunpy-0.7.4/astropy_helpers/astropy_helpers/git_helpers.py0000644000175000001440000001372713011054225024731 0ustar stuartusers00000000000000# Licensed under a 3-clause BSD style license - see LICENSE.rst """ Utilities for retrieving revision information from a project's git repository. """ # Do not remove the following comment; it is used by # astropy_helpers.version_helpers to determine the beginning of the code in # this module # BEGIN import locale import os import subprocess import warnings def _decode_stdio(stream): try: stdio_encoding = locale.getdefaultlocale()[1] or 'utf-8' except ValueError: stdio_encoding = 'utf-8' try: text = stream.decode(stdio_encoding) except UnicodeDecodeError: # Final fallback text = stream.decode('latin1') return text def update_git_devstr(version, path=None): """ Updates the git revision string if and only if the path is being imported directly from a git working copy. This ensures that the revision number in the version string is accurate. """ try: # Quick way to determine if we're in git or not - returns '' if not devstr = get_git_devstr(sha=True, show_warning=False, path=path) except OSError: return version if not devstr: # Probably not in git so just pass silently return version if 'dev' in version: # update to the current git revision version_base = version.split('.dev', 1)[0] devstr = get_git_devstr(sha=False, show_warning=False, path=path) return version_base + '.dev' + devstr else: #otherwise it's already the true/release version return version def get_git_devstr(sha=False, show_warning=True, path=None): """ Determines the number of revisions in this repository. Parameters ---------- sha : bool If True, the full SHA1 hash will be returned. Otherwise, the total count of commits in the repository will be used as a "revision number". show_warning : bool If True, issue a warning if git returns an error code, otherwise errors pass silently. path : str or None If a string, specifies the directory to look in to find the git repository. If `None`, the current working directory is used, and must be the root of the git repository. If given a filename it uses the directory containing that file. Returns ------- devversion : str Either a string with the revision number (if `sha` is False), the SHA1 hash of the current commit (if `sha` is True), or an empty string if git version info could not be identified. """ if path is None: path = os.getcwd() if not _get_repo_path(path, levels=0): return '' if not os.path.isdir(path): path = os.path.abspath(os.path.dirname(path)) if sha: # Faster for getting just the hash of HEAD cmd = ['rev-parse', 'HEAD'] else: cmd = ['rev-list', '--count', 'HEAD'] def run_git(cmd): try: p = subprocess.Popen(['git'] + cmd, cwd=path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) stdout, stderr = p.communicate() except OSError as e: if show_warning: warnings.warn('Error running git: ' + str(e)) return (None, b'', b'') if p.returncode == 128: if show_warning: warnings.warn('No git repository present at {0!r}! Using ' 'default dev version.'.format(path)) return (p.returncode, b'', b'') if p.returncode == 129: if show_warning: warnings.warn('Your git looks old (does it support {0}?); ' 'consider upgrading to v1.7.2 or ' 'later.'.format(cmd[0])) return (p.returncode, stdout, stderr) elif p.returncode != 0: if show_warning: warnings.warn('Git failed while determining revision ' 'count: {0}'.format(_decode_stdio(stderr))) return (p.returncode, stdout, stderr) return p.returncode, stdout, stderr returncode, stdout, stderr = run_git(cmd) if not sha and returncode == 129: # git returns 129 if a command option failed to parse; in # particular this could happen in git versions older than 1.7.2 # where the --count option is not supported # Also use --abbrev-commit and --abbrev=0 to display the minimum # number of characters needed per-commit (rather than the full hash) cmd = ['rev-list', '--abbrev-commit', '--abbrev=0', 'HEAD'] returncode, stdout, stderr = run_git(cmd) # Fall back on the old method of getting all revisions and counting # the lines if returncode == 0: return str(stdout.count(b'\n')) else: return '' elif sha: return _decode_stdio(stdout)[:40] else: return _decode_stdio(stdout).strip() def _get_repo_path(pathname, levels=None): """ Given a file or directory name, determine the root of the git repository this path is under. If given, this won't look any higher than ``levels`` (that is, if ``levels=0`` then the given path must be the root of the git repository and is returned if so. Returns `None` if the given path could not be determined to belong to a git repo. """ if os.path.isfile(pathname): current_dir = os.path.abspath(os.path.dirname(pathname)) elif os.path.isdir(pathname): current_dir = os.path.abspath(pathname) else: return None current_level = 0 while levels is None or current_level <= levels: if os.path.exists(os.path.join(current_dir, '.git')): return current_dir current_level += 1 if current_dir == os.path.dirname(current_dir): break current_dir = os.path.dirname(current_dir) return None sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/0000755000175000001440000000000013011056504023643 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/build_py.pyc0000644000175000001440000000320612775203577026214 0ustar stuartusers00000000000000ó ’¬­Wc@s:ddlmZddlmZdefd„ƒYZdS(iÿÿÿÿ(tbuild_pyi(t_get_platlib_dirtAstropyBuildPycBs:eZejZejZd„Zed„Zd„ZRS(cCsG|jdƒ}t|ƒ}||_||_||_tj|ƒdS(Ntbuild(tget_finalized_commandRt build_purelibt build_libtSetuptoolsBuildPytfinalize_options(tselft build_cmdt platlib_dir((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pyR s     cCs||jj}g}xP|D]H}x?|D]*}|t|jƒdj|ƒr&Pq&q&W|j|ƒqWtj|||ƒdS(Ni(t distributiont skip_2to3tlenRt startswithtappendRtrun_2to3(R tfilestdoctestsR tfiltered_filestfilenametpackage((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pyRs    cCstj|ƒdS(N(Rtrun(R ((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pyR%s( t__name__t __module__Rt user_optionstboolean_optionsRtFalseRR(((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pyRs     N(tsetuptools.command.build_pyRRtutilsRR(((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pytssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/_dummy.py0000644000175000001440000000557412753326222025533 0ustar stuartusers00000000000000""" Provides a base class for a 'dummy' setup.py command that has no functionality (probably due to a missing requirement). This dummy command can raise an exception when it is run, explaining to the user what dependencies must be met to use this command. The reason this is at all tricky is that we want the command to be able to provide this message even when the user passes arguments to the command. If we don't know ahead of time what arguments the command can take, this is difficult, because distutils does not allow unknown arguments to be passed to a setup.py command. This hacks around that restriction to provide a useful error message even when a user passes arguments to the dummy implementation of a command. Use this like: try: from some_dependency import SetupCommand except ImportError: from ._dummy import _DummyCommand class SetupCommand(_DummyCommand): description = \ 'Implementation of SetupCommand from some_dependency; ' 'some_dependency must be installed to run this command' # This is the message that will be raised when a user tries to # run this command--define it as a class attribute. error_msg = \ "The 'setup_command' command requires the some_dependency " "package to be installed and importable." """ import sys from setuptools import Command from distutils.errors import DistutilsArgError from textwrap import dedent class _DummyCommandMeta(type): """ Causes an exception to be raised on accessing attributes of a command class so that if ``./setup.py command_name`` is run with additional command-line options we can provide a useful error message instead of the default that tells users the options are unrecognized. """ def __init__(cls, name, bases, members): if bases == (Command, object): # This is the _DummyCommand base class, presumably return if not hasattr(cls, 'description'): raise TypeError( "_DummyCommand subclass must have a 'description' " "attribute.") if not hasattr(cls, 'error_msg'): raise TypeError( "_DummyCommand subclass must have an 'error_msg' " "attribute.") def __getattribute__(cls, attr): if attr in ('description', 'error_msg'): # Allow cls.description to work so that `./setup.py # --help-commands` still works return super(_DummyCommandMeta, cls).__getattribute__(attr) raise DistutilsArgError(cls.error_msg) if sys.version_info[0] < 3: exec(dedent(""" class _DummyCommand(Command, object): __metaclass__ = _DummyCommandMeta """)) else: exec(dedent(""" class _DummyCommand(Command, object, metaclass=_DummyCommandMeta): pass """)) sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/install.py0000644000175000001440000000074612753326222025703 0ustar stuartusers00000000000000from setuptools.command.install import install as SetuptoolsInstall from ..utils import _get_platlib_dir class AstropyInstall(SetuptoolsInstall): user_options = SetuptoolsInstall.user_options[:] boolean_options = SetuptoolsInstall.boolean_options[:] def finalize_options(self): build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) self.build_lib = platlib_dir SetuptoolsInstall.finalize_options(self) sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/install_lib.pyc0000644000175000001440000000171712775203577026706 0ustar stuartusers00000000000000ó ’¬­Wc@s:ddlmZddlmZdefd„ƒYZdS(iÿÿÿÿ(t install_libi(t_get_platlib_dirtAstropyInstallLibcBs%eZejZejZd„ZRS(cCs5|jdƒ}t|ƒ}||_tj|ƒdS(Ntbuild(tget_finalized_commandRt build_dirtSetuptoolsInstallLibtfinalize_options(tselft build_cmdt platlib_dir((sN/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install_lib.pyR s  (t__name__t __module__Rt user_optionstboolean_optionsR(((sN/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install_lib.pyRs  N(tsetuptools.command.install_libRRtutilsRR(((sN/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install_lib.pytssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/_test_compat.py0000644000175000001440000002666213011054225026710 0ustar stuartusers00000000000000""" Old implementation of ``./setup.py test`` command. This has been moved to astropy.tests as of Astropy v1.1.0, but a copy of the implementation is kept here for backwards compatibility. """ from __future__ import absolute_import, unicode_literals import inspect import os import shutil import subprocess import sys import tempfile from setuptools import Command from ..compat import _fix_user_options PY3 = sys.version_info[0] == 3 class AstropyTest(Command, object): description = 'Run the tests for this package' user_options = [ ('package=', 'P', "The name of a specific package to test, e.g. 'io.fits' or 'utils'. " "If nothing is specified, all default tests are run."), ('test-path=', 't', 'Specify a test location by path. If a relative path to a .py file, ' 'it is relative to the built package, so e.g., a leading "astropy/" ' 'is necessary. If a relative path to a .rst file, it is relative to ' 'the directory *below* the --docs-path directory, so a leading ' '"docs/" is usually necessary. May also be an absolute path.'), ('verbose-results', 'V', 'Turn on verbose output from pytest.'), ('plugins=', 'p', 'Plugins to enable when running pytest.'), ('pastebin=', 'b', "Enable pytest pastebin output. Either 'all' or 'failed'."), ('args=', 'a', 'Additional arguments to be passed to pytest.'), ('remote-data', 'R', 'Run tests that download remote data.'), ('pep8', '8', 'Enable PEP8 checking and disable regular tests. ' 'Requires the pytest-pep8 plugin.'), ('pdb', 'd', 'Start the interactive Python debugger on errors.'), ('coverage', 'c', 'Create a coverage report. Requires the coverage package.'), ('open-files', 'o', 'Fail if any tests leave files open. Requires the ' 'psutil package.'), ('parallel=', 'j', 'Run the tests in parallel on the specified number of ' 'CPUs. If negative, all the cores on the machine will be ' 'used. Requires the pytest-xdist plugin.'), ('docs-path=', None, 'The path to the documentation .rst files. If not provided, and ' 'the current directory contains a directory called "docs", that ' 'will be used.'), ('skip-docs', None, "Don't test the documentation .rst files."), ('repeat=', None, 'How many times to repeat each test (can be used to check for ' 'sporadic failures).'), ('temp-root=', None, 'The root directory in which to create the temporary testing files. ' 'If unspecified the system default is used (e.g. /tmp) as explained ' 'in the documentation for tempfile.mkstemp.') ] user_options = _fix_user_options(user_options) package_name = '' def initialize_options(self): self.package = None self.test_path = None self.verbose_results = False self.plugins = None self.pastebin = None self.args = None self.remote_data = False self.pep8 = False self.pdb = False self.coverage = False self.open_files = False self.parallel = 0 self.docs_path = None self.skip_docs = False self.repeat = None self.temp_root = None def finalize_options(self): # Normally we would validate the options here, but that's handled in # run_tests pass # Most of the test runner arguments have the same name as attributes on # this command class, with one exception (for now) _test_runner_arg_attr_map = { 'verbose': 'verbose_results' } def generate_testing_command(self): """ Build a Python script to run the tests. """ cmd_pre = '' # Commands to run before the test function cmd_post = '' # Commands to run after the test function if self.coverage: pre, post = self._generate_coverage_commands() cmd_pre += pre cmd_post += post def get_attr(arg): attr = self._test_runner_arg_attr_map.get(arg, arg) return getattr(self, attr) test_args = filter(lambda arg: hasattr(self, arg), self._get_test_runner_args()) test_args = ', '.join('{0}={1!r}'.format(arg, get_attr(arg)) for arg in test_args) if PY3: set_flag = "import builtins; builtins._ASTROPY_TEST_ = True" else: set_flag = "import __builtin__; __builtin__._ASTROPY_TEST_ = True" cmd = ('{cmd_pre}{0}; import {1.package_name}, sys; result = ' '{1.package_name}.test({test_args}); {cmd_post}' 'sys.exit(result)') return cmd.format(set_flag, self, cmd_pre=cmd_pre, cmd_post=cmd_post, test_args=test_args) def _validate_required_deps(self): """ This method checks that any required modules are installed before running the tests. """ try: import astropy except ImportError: raise ImportError( "The 'test' command requires the astropy package to be " "installed and importable.") def run(self): """ Run the tests! """ # Ensure there is a doc path if self.docs_path is None: if os.path.exists('docs'): self.docs_path = os.path.abspath('docs') # Build a testing install of the package self._build_temp_install() # Ensure all required packages are installed self._validate_required_deps() # Run everything in a try: finally: so that the tmp dir gets deleted. try: # Construct this modules testing command cmd = self.generate_testing_command() # Run the tests in a subprocess--this is necessary since # new extension modules may have appeared, and this is the # easiest way to set up a new environment # On Python 3.x prior to 3.3, the creation of .pyc files # is not atomic. py.test jumps through some hoops to make # this work by parsing import statements and carefully # importing files atomically. However, it can't detect # when __import__ is used, so its carefulness still fails. # The solution here (admittedly a bit of a hack), is to # turn off the generation of .pyc files altogether by # passing the `-B` switch to `python`. This does mean # that each core will have to compile .py file to bytecode # itself, rather than getting lucky and borrowing the work # already done by another core. Compilation is an # insignificant fraction of total testing time, though, so # it's probably not worth worrying about. retcode = subprocess.call([sys.executable, '-B', '-c', cmd], cwd=self.testing_path, close_fds=False) finally: # Remove temporary directory shutil.rmtree(self.tmp_dir) raise SystemExit(retcode) def _build_temp_install(self): """ Build the package and copy the build to a temporary directory for the purposes of testing this avoids creating pyc and __pycache__ directories inside the build directory """ self.reinitialize_command('build', inplace=True) self.run_command('build') build_cmd = self.get_finalized_command('build') new_path = os.path.abspath(build_cmd.build_lib) # On OSX the default path for temp files is under /var, but in most # cases on OSX /var is actually a symlink to /private/var; ensure we # dereference that link, because py.test is very sensitive to relative # paths... tmp_dir = tempfile.mkdtemp(prefix=self.package_name + '-test-', dir=self.temp_root) self.tmp_dir = os.path.realpath(tmp_dir) self.testing_path = os.path.join(self.tmp_dir, os.path.basename(new_path)) shutil.copytree(new_path, self.testing_path) new_docs_path = os.path.join(self.tmp_dir, os.path.basename(self.docs_path)) shutil.copytree(self.docs_path, new_docs_path) self.docs_path = new_docs_path shutil.copy('setup.cfg', self.tmp_dir) def _generate_coverage_commands(self): """ This method creates the post and pre commands if coverage is to be generated """ if self.parallel != 0: raise ValueError( "--coverage can not be used with --parallel") try: import coverage except ImportError: raise ImportError( "--coverage requires that the coverage package is " "installed.") # Don't use get_pkg_data_filename here, because it # requires importing astropy.config and thus screwing # up coverage results for those packages. coveragerc = os.path.join( self.testing_path, self.package_name, 'tests', 'coveragerc') # We create a coveragerc that is specific to the version # of Python we're running, so that we can mark branches # as being specifically for Python 2 or Python 3 with open(coveragerc, 'r') as fd: coveragerc_content = fd.read() if PY3: ignore_python_version = '2' else: ignore_python_version = '3' coveragerc_content = coveragerc_content.replace( "{ignore_python_version}", ignore_python_version).replace( "{packagename}", self.package_name) tmp_coveragerc = os.path.join(self.tmp_dir, 'coveragerc') with open(tmp_coveragerc, 'wb') as tmp: tmp.write(coveragerc_content.encode('utf-8')) cmd_pre = ( 'import coverage; ' 'cov = coverage.coverage(data_file="{0}", config_file="{1}"); ' 'cov.start();'.format( os.path.abspath(".coverage"), tmp_coveragerc)) cmd_post = ( 'cov.stop(); ' 'from astropy.tests.helper import _save_coverage; ' '_save_coverage(cov, result, "{0}", "{1}");'.format( os.path.abspath('.'), self.testing_path)) return cmd_pre, cmd_post def _get_test_runner_args(self): """ A hack to determine what arguments are supported by the package's test() function. In the future there should be a more straightforward API to determine this (really it should be determined by the ``TestRunner`` class for whatever version of Astropy is in use). """ if PY3: import builtins builtins._ASTROPY_TEST_ = True else: import __builtin__ __builtin__._ASTROPY_TEST_ = True try: pkg = __import__(self.package_name) if not hasattr(pkg, 'test'): raise ImportError( 'package {0} does not have a {0}.test() function as ' 'required by the Astropy test runner'.format(package_name)) argspec = inspect.getargspec(pkg.test) return argspec.args finally: if PY3: del builtins._ASTROPY_TEST_ else: del __builtin__._ASTROPY_TEST_ sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/src/0000755000175000001440000000000013011056504024432 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/src/compiler.c0000644000175000001440000000573112753326222026427 0ustar stuartusers00000000000000#include /*************************************************************************** * Macros for determining the compiler version. * * These are borrowed from boost, and majorly abridged to include only * the compilers we care about. ***************************************************************************/ #ifndef PY3K #if PY_MAJOR_VERSION >= 3 #define PY3K 1 #else #define PY3K 0 #endif #endif #define STRINGIZE(X) DO_STRINGIZE(X) #define DO_STRINGIZE(X) #X #if defined __clang__ /* Clang C++ emulates GCC, so it has to appear early. */ # define COMPILER "Clang version " __clang_version__ #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) /* Intel */ # if defined(__INTEL_COMPILER) # define INTEL_VERSION __INTEL_COMPILER # elif defined(__ICL) # define INTEL_VERSION __ICL # elif defined(__ICC) # define INTEL_VERSION __ICC # elif defined(__ECC) # define INTEL_VERSION __ECC # endif # define COMPILER "Intel C compiler version " STRINGIZE(INTEL_VERSION) #elif defined(__GNUC__) /* gcc */ # define COMPILER "GCC version " __VERSION__ #elif defined(__SUNPRO_CC) /* Sun Workshop Compiler */ # define COMPILER "Sun compiler version " STRINGIZE(__SUNPRO_CC) #elif defined(_MSC_VER) /* Microsoft Visual C/C++ Must be last since other compilers define _MSC_VER for compatibility as well */ # if _MSC_VER < 1200 # define COMPILER_VERSION 5.0 # elif _MSC_VER < 1300 # define COMPILER_VERSION 6.0 # elif _MSC_VER == 1300 # define COMPILER_VERSION 7.0 # elif _MSC_VER == 1310 # define COMPILER_VERSION 7.1 # elif _MSC_VER == 1400 # define COMPILER_VERSION 8.0 # elif _MSC_VER == 1500 # define COMPILER_VERSION 9.0 # elif _MSC_VER == 1600 # define COMPILER_VERSION 10.0 # else # define COMPILER_VERSION _MSC_VER # endif # define COMPILER "Microsoft Visual C++ version " STRINGIZE(COMPILER_VERSION) #else /* Fallback */ # define COMPILER "Unknown compiler" #endif /*************************************************************************** * Module-level ***************************************************************************/ struct module_state { /* The Sun compiler can't handle empty structs */ #if defined(__SUNPRO_C) || defined(_MSC_VER) int _dummy; #endif }; #if PY3K static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_compiler", NULL, sizeof(struct module_state), NULL, NULL, NULL, NULL, NULL }; #define INITERROR return NULL PyMODINIT_FUNC PyInit__compiler(void) #else #define INITERROR return PyMODINIT_FUNC init_compiler(void) #endif { PyObject* m; #if PY3K m = PyModule_Create(&moduledef); #else m = Py_InitModule3("_compiler", NULL, NULL); #endif if (m == NULL) INITERROR; PyModule_AddStringConstant(m, "compiler", COMPILER); #if PY3K return m; #endif } sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/register.py0000644000175000001440000000454712753326222026064 0ustar stuartusers00000000000000from setuptools.command.register import register as SetuptoolsRegister class AstropyRegister(SetuptoolsRegister): """Extends the built in 'register' command to support a ``--hidden`` option to make the registered version hidden on PyPI by default. The result of this is that when a version is registered as "hidden" it can still be downloaded from PyPI, but it does not show up in the list of actively supported versions under http://pypi.python.org/pypi/astropy, and is not set as the most recent version. Although this can always be set through the web interface it may be more convenient to be able to specify via the 'register' command. Hidden may also be considered a safer default when running the 'register' command, though this command uses distutils' normal behavior if the ``--hidden`` option is omitted. """ user_options = SetuptoolsRegister.user_options + [ ('hidden', None, 'mark this release as hidden on PyPI by default') ] boolean_options = SetuptoolsRegister.boolean_options + ['hidden'] def initialize_options(self): SetuptoolsRegister.initialize_options(self) self.hidden = False def build_post_data(self, action): data = SetuptoolsRegister.build_post_data(self, action) if action == 'submit' and self.hidden: data['_pypi_hidden'] = '1' return data def _set_config(self): # The original register command is buggy--if you use .pypirc with a # server-login section *at all* the repository you specify with the -r # option will be overwritten with either the repository in .pypirc or # with the default, # If you do not have a .pypirc using the -r option will just crash. # Way to go distutils # If we don't set self.repository back to a default value _set_config # can crash if there was a user-supplied value for this option; don't # worry, we'll get the real value back afterwards self.repository = 'pypi' SetuptoolsRegister._set_config(self) options = self.distribution.get_option_dict('register') if 'repository' in options: source, value = options['repository'] # Really anything that came from setup.cfg or the command line # should override whatever was in .pypirc self.repository = value sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/setup_package.py0000644000175000001440000000016713011054225027032 0ustar stuartusers00000000000000from os.path import join def get_package_data(): return {'astropy_helpers.commands': [join('src', 'compiler.c')]} sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__init__.py0000644000175000001440000000000012753326222025753 0ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/build_ext.py0000644000175000001440000004566513011054225026212 0ustar stuartusers00000000000000import errno import os import re import shlex import shutil import subprocess import sys import textwrap from distutils import log, ccompiler, sysconfig from distutils.cmd import Command from distutils.core import Extension from distutils.ccompiler import get_default_compiler from setuptools.command.build_ext import build_ext as SetuptoolsBuildExt from ..utils import get_numpy_include_path, invalidate_caches, classproperty from ..version_helpers import get_pkg_version_module def should_build_with_cython(package, release=None): """Returns the previously used Cython version (or 'unknown' if not previously built) if Cython should be used to build extension modules from pyx files. If the ``release`` parameter is not specified an attempt is made to determine the release flag from `astropy.version`. """ try: version_module = __import__(package + '.cython_version', fromlist=['release', 'cython_version']) except ImportError: version_module = None if release is None and version_module is not None: try: release = version_module.release except AttributeError: pass try: cython_version = version_module.cython_version except AttributeError: cython_version = 'unknown' # Only build with Cython if, of course, Cython is installed, we're in a # development version (i.e. not release) or the Cython-generated source # files haven't been created yet (cython_version == 'unknown'). The latter # case can happen even when release is True if checking out a release tag # from the repository have_cython = False try: import Cython have_cython = True except ImportError: pass if have_cython and (not release or cython_version == 'unknown'): return cython_version else: return False _compiler_versions = {} def get_compiler_version(compiler): if compiler in _compiler_versions: return _compiler_versions[compiler] # Different flags to try to get the compiler version # TODO: It might be worth making this configurable to support # arbitrary odd compilers; though all bets may be off in such # cases anyway flags = ['--version', '--Version', '-version', '-Version', '-v', '-V'] def try_get_version(flag): process = subprocess.Popen( shlex.split(compiler, posix=('win' not in sys.platform)) + [flag], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = process.communicate() if process.returncode != 0: return 'unknown' output = stdout.strip().decode('latin-1') # Safest bet if not output: # Some compilers return their version info on stderr output = stderr.strip().decode('latin-1') if not output: output = 'unknown' return output for flag in flags: version = try_get_version(flag) if version != 'unknown': break # Cache results to speed up future calls _compiler_versions[compiler] = version return version # TODO: I think this can be reworked without having to create the class # programmatically. def generate_build_ext_command(packagename, release): """ Creates a custom 'build_ext' command that allows for manipulating some of the C extension options at build time. We use a function to build the class since the base class for build_ext may be different depending on certain build-time parameters (for example, we may use Cython's build_ext instead of the default version in distutils). Uses the default distutils.command.build_ext by default. """ class build_ext(SetuptoolsBuildExt, object): package_name = packagename is_release = release _user_options = SetuptoolsBuildExt.user_options[:] _boolean_options = SetuptoolsBuildExt.boolean_options[:] _help_options = SetuptoolsBuildExt.help_options[:] force_rebuild = False _broken_compiler_mapping = [ ('i686-apple-darwin[0-9]*-llvm-gcc-4.2', 'clang') ] # Warning: Spaghetti code ahead. # During setup.py, the setup_helpers module needs the ability to add # items to a command's user_options list. At this stage we don't know # whether or not we can build with Cython, and so don't know for sure # what base class will be used for build_ext; nevertheless we want to # be able to provide a list to add options into. # # Later, once setup() has been called we should have all build # dependencies included via setup_requires available. distutils needs # to be able to access the user_options as a *class* attribute before # the class has been initialized, but we do need to be able to # enumerate the options for the correct base class at that point @classproperty def user_options(cls): from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._user_options return cls._final_class.user_options @classproperty def boolean_options(cls): # Similar to user_options above from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._boolean_options return cls._final_class.boolean_options @classproperty def help_options(cls): # Similar to user_options above from distutils import core if core._setup_distribution is None: # We haven't gotten into setup() yet, and the Distribution has # not yet been initialized return cls._help_options return cls._final_class.help_options @classproperty(lazy=True) def _final_class(cls): """ Late determination of what the build_ext base class should be, depending on whether or not Cython is available. """ uses_cython = should_build_with_cython(cls.package_name, cls.is_release) if uses_cython: # We need to decide late on whether or not to use Cython's # build_ext (since Cython may not be available earlier in the # setup.py if it was brought in via setup_requires) from Cython.Distutils import build_ext as base_cls else: base_cls = SetuptoolsBuildExt # Create and return an instance of a new class based on this class # using one of the above possible base classes def merge_options(attr): base = getattr(base_cls, attr) ours = getattr(cls, '_' + attr) all_base = set(opt[0] for opt in base) return base + [opt for opt in ours if opt[0] not in all_base] boolean_options = (base_cls.boolean_options + [opt for opt in cls._boolean_options if opt not in base_cls.boolean_options]) members = dict(cls.__dict__) members.update({ 'user_options': merge_options('user_options'), 'help_options': merge_options('help_options'), 'boolean_options': boolean_options, 'uses_cython': uses_cython, }) # Update the base class for the original build_ext command build_ext.__bases__ = (base_cls, object) # Create a new class for the existing class, but now with the # appropriate base class depending on whether or not to use Cython. # Ensure that object is one of the bases to make a new-style class. return type(cls.__name__, (build_ext,), members) def __new__(cls, *args, **kwargs): # By the time the command is actually instantialized, the # Distribution instance for the build has been instantiated, which # means setup_requires has been processed--now we can determine # what base class we can use for the actual build, and return an # instance of a build_ext command that uses that base class (right # now the options being Cython.Distutils.build_ext, or the stock # setuptools build_ext) new_cls = super(build_ext, cls._final_class).__new__( cls._final_class) # Since the new cls is not a subclass of the original cls, we must # manually call its __init__ new_cls.__init__(*args, **kwargs) return new_cls def finalize_options(self): # Add a copy of the _compiler.so module as well, but only if there # are in fact C modules to compile (otherwise there's no reason to # include a record of the compiler used) # Note, self.extensions may not be set yet, but # self.distribution.ext_modules is where any extension modules # passed to setup() can be found self._adjust_compiler() extensions = self.distribution.ext_modules if extensions: src_path = os.path.relpath( os.path.join(os.path.dirname(__file__), 'src')) shutil.copy2(os.path.join(src_path, 'compiler.c'), os.path.join(self.package_name, '_compiler.c')) ext = Extension(self.package_name + '._compiler', [os.path.join(self.package_name, '_compiler.c')]) extensions.insert(0, ext) super(build_ext, self).finalize_options() # Generate if self.uses_cython: try: from Cython import __version__ as cython_version except ImportError: # This shouldn't happen if we made it this far cython_version = None if (cython_version is not None and cython_version != self.uses_cython): self.force_rebuild = True # Update the used cython version self.uses_cython = cython_version # Regardless of the value of the '--force' option, force a rebuild # if the debug flag changed from the last build if self.force_rebuild: self.force = True def run(self): # For extensions that require 'numpy' in their include dirs, # replace 'numpy' with the actual paths np_include = get_numpy_include_path() for extension in self.extensions: if 'numpy' in extension.include_dirs: idx = extension.include_dirs.index('numpy') extension.include_dirs.insert(idx, np_include) extension.include_dirs.remove('numpy') self._check_cython_sources(extension) super(build_ext, self).run() # Update cython_version.py if building with Cython try: cython_version = get_pkg_version_module( packagename, fromlist=['cython_version'])[0] except (AttributeError, ImportError): cython_version = 'unknown' if self.uses_cython and self.uses_cython != cython_version: package_dir = os.path.relpath(packagename) cython_py = os.path.join(package_dir, 'cython_version.py') with open(cython_py, 'w') as f: f.write('# Generated file; do not modify\n') f.write('cython_version = {0!r}\n'.format(self.uses_cython)) if os.path.isdir(self.build_lib): # The build/lib directory may not exist if the build_py # command was not previously run, which may sometimes be # the case self.copy_file(cython_py, os.path.join(self.build_lib, cython_py), preserve_mode=False) invalidate_caches() def _adjust_compiler(self): """ This function detects broken compilers and switches to another. If the environment variable CC is explicitly set, or a compiler is specified on the commandline, no override is performed -- the purpose here is to only override a default compiler. The specific compilers with problems are: * The default compiler in XCode-4.2, llvm-gcc-4.2, segfaults when compiling wcslib. The set of broken compilers can be updated by changing the compiler_mapping variable. It is a list of 2-tuples where the first in the pair is a regular expression matching the version of the broken compiler, and the second is the compiler to change to. """ if 'CC' in os.environ: # Check that CC is not set to llvm-gcc-4.2 c_compiler = os.environ['CC'] try: version = get_compiler_version(c_compiler) except OSError: msg = textwrap.dedent( """ The C compiler set by the CC environment variable: {compiler:s} cannot be found or executed. """.format(compiler=c_compiler)) log.warn(msg) sys.exit(1) for broken, fixed in self._broken_compiler_mapping: if re.match(broken, version): msg = textwrap.dedent( """Compiler specified by CC environment variable ({compiler:s}:{version:s}) will fail to compile {pkg:s}. Please set CC={fixed:s} and try again. You can do this, for example, by running: CC={fixed:s} python setup.py where is the command you ran. """.format(compiler=c_compiler, version=version, pkg=self.package_name, fixed=fixed)) log.warn(msg) sys.exit(1) # If C compiler is set via CC, and isn't broken, we are good to go. We # should definitely not try accessing the compiler specified by # ``sysconfig.get_config_var('CC')`` lower down, because this may fail # if the compiler used to compile Python is missing (and maybe this is # why the user is setting CC). For example, the official Python 2.7.3 # MacOS X binary was compiled with gcc-4.2, which is no longer available # in XCode 4. return if self.compiler is not None: # At this point, self.compiler will be set only if a compiler # was specified in the command-line or via setup.cfg, in which # case we don't do anything return compiler_type = ccompiler.get_default_compiler() if compiler_type == 'unix': # We have to get the compiler this way, as this is the one that is # used if os.environ['CC'] is not set. It is actually read in from # the Python Makefile. Note that this is not necessarily the same # compiler as returned by ccompiler.new_compiler() c_compiler = sysconfig.get_config_var('CC') try: version = get_compiler_version(c_compiler) except OSError: msg = textwrap.dedent( """ The C compiler used to compile Python {compiler:s}, and which is normally used to compile C extensions, is not available. You can explicitly specify which compiler to use by setting the CC environment variable, for example: CC=gcc python setup.py or if you are using MacOS X, you can try: CC=clang python setup.py """.format(compiler=c_compiler)) log.warn(msg) sys.exit(1) for broken, fixed in self._broken_compiler_mapping: if re.match(broken, version): os.environ['CC'] = fixed break def _check_cython_sources(self, extension): """ Where relevant, make sure that the .c files associated with .pyx modules are present (if building without Cython installed). """ # Determine the compiler we'll be using if self.compiler is None: compiler = get_default_compiler() else: compiler = self.compiler # Replace .pyx with C-equivalents, unless c files are missing for jdx, src in enumerate(extension.sources): base, ext = os.path.splitext(src) pyxfn = base + '.pyx' cfn = base + '.c' cppfn = base + '.cpp' if not os.path.isfile(pyxfn): continue if self.uses_cython: extension.sources[jdx] = pyxfn else: if os.path.isfile(cfn): extension.sources[jdx] = cfn elif os.path.isfile(cppfn): extension.sources[jdx] = cppfn else: msg = ( 'Could not find C/C++ file {0}.(c/cpp) for Cython ' 'file {1} when building extension {2}. Cython ' 'must be installed to build from a git ' 'checkout.'.format(base, pyxfn, extension.name)) raise IOError(errno.ENOENT, msg, cfn) # Current versions of Cython use deprecated Numpy API features # the use of which produces a few warnings when compiling. # These additional flags should squelch those warnings. # TODO: Feel free to remove this if/when a Cython update # removes use of the deprecated Numpy API if compiler == 'unix': extension.extra_compile_args.extend([ '-Wp,-w', '-Wno-unused-function']) return build_ext sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/build_py.py0000644000175000001440000000265612753326222026046 0ustar stuartusers00000000000000from setuptools.command.build_py import build_py as SetuptoolsBuildPy from ..utils import _get_platlib_dir class AstropyBuildPy(SetuptoolsBuildPy): user_options = SetuptoolsBuildPy.user_options[:] boolean_options = SetuptoolsBuildPy.boolean_options[:] def finalize_options(self): # Update build_lib settings from the build command to always put # build files in platform-specific subdirectories of build/, even # for projects with only pure-Python source (this is desirable # specifically for support of multiple Python version). build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) build_cmd.build_purelib = platlib_dir build_cmd.build_lib = platlib_dir self.build_lib = platlib_dir SetuptoolsBuildPy.finalize_options(self) def run_2to3(self, files, doctests=False): # Filter the files to exclude things that shouldn't be 2to3'd skip_2to3 = self.distribution.skip_2to3 filtered_files = [] for filename in files: for package in skip_2to3: if filename[len(self.build_lib) + 1:].startswith(package): break else: filtered_files.append(filename) SetuptoolsBuildPy.run_2to3(self, filtered_files, doctests) def run(self): # first run the normal build_py SetuptoolsBuildPy.run(self) sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/build_ext.pyc0000644000175000001440000003115613001453470026347 0ustar stuartusers00000000000000ó SXc@sddlZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZddlmZmZmZdd lmZdd „ZiZd „Zd „ZdS( iÿÿÿÿN(tlogt ccompilert sysconfig(tCommand(t Extension(tget_default_compiler(t build_exti(tget_numpy_include_pathtinvalidate_cachest classproperty(tget_pkg_version_modulecCsòy t|ddddgƒ}Wntk r9d}nX|dkrv|dk rvy |j}Wqvtk rrqvXny |j}Wntk rœd}nXt}yddl}t}Wntk rÌnX|rê| sæ|dkrê|StSdS(sReturns the previously used Cython version (or 'unknown' if not previously built) if Cython should be used to build extension modules from pyx files. If the ``release`` parameter is not specified an attempt is made to determine the release flag from `astropy.version`. s.cython_versiontfromlisttreleasetcython_versiontunknowniÿÿÿÿN( t __import__t ImportErrortNoneR tAttributeErrorR tFalsetCythontTrue(tpackageR tversion_moduleR t have_cythonR((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pytshould_build_with_cythons.           csvˆtkrtˆSddddddg}‡fd†}x*|D]"}||ƒ}|dkrBPqBqBW|tˆ<|S( Ns --versions --Versions-versions-Versions-vs-Vcs«tjtjˆddtjkƒ|gdtjdtjƒ}|jƒ\}}|jdkredS|j ƒj dƒ}|s˜|j ƒj dƒ}n|s§d}n|S(NtposixtwintstdouttstderriRslatin-1( t subprocesstPopentshlextsplittsystplatformtPIPEt communicatet returncodetstriptdecode(tflagtprocessRRtoutput(tcompiler(sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyttry_get_versionJs% R(t_compiler_versions(R,tflagsR-R)tversion((R,sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pytget_compiler_version?s       cs)dttf‡‡‡fd†ƒY‰ˆS(s§ Creates a custom 'build_ext' command that allows for manipulating some of the C extension options at build time. We use a function to build the class since the base class for build_ext may be different depending on certain build-time parameters (for example, we may use Cython's build_ext instead of the default version in distutils). Uses the default distutils.command.build_ext by default. RcsÎeZˆZˆZejZejZej Z e Z d gZ ed„ƒZed„ƒZed„ƒZ edeƒ‡fd†ƒZ‡fd†Z‡fd†Z‡‡fd †Zd „Zd „ZRS( s$i686-apple-darwin[0-9]*-llvm-gcc-4.2tclangcSs0ddlm}|jdkr&|jS|jjS(Niÿÿÿÿ(tcore(t distutilsR3t_setup_distributionRt _user_optionst _final_classt user_options(tclsR3((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyR8‘scSs0ddlm}|jdkr&|jS|jjS(Niÿÿÿÿ(R3(R4R3R5Rt_boolean_optionsR7tboolean_options(R9R3((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyR;œscSs0ddlm}|jdkr&|jS|jjS(Niÿÿÿÿ(R3(R4R3R5Rt _help_optionsR7t help_options(R9R3((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyR=¨stlazycsátˆjˆjƒ}|r.ddlm‰nt‰‡‡fd†}ˆjgˆjD]}|ˆjkrV|^qV}tˆj ƒ}|j i|dƒd6|dƒd6|d6|d6ƒˆt fˆ_ t ˆjˆf|ƒS(s• Late determination of what the build_ext base class should be, depending on whether or not Cython is available. iÿÿÿÿ(Rcsctˆ|ƒ}tˆd|ƒ}td„|Dƒƒ}|g|D]}|d|krB|^qBS(Nt_css|]}|dVqdS(iN((t.0topt((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pys Ìsi(tgetattrtset(tattrtbasetourstall_baseRA(tbase_clsR9(sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyt merge_optionsÈsR8R=R;t uses_cython(Rt package_namet is_releasetCython.DistutilsRtSetuptoolsBuildExtR;R:tdictt__dict__tupdatetobjectt __bases__ttypet__name__(R9RJRIRAR;tmembers(R(RHR9sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyR7´s"      cs2tˆ|jƒj|jƒ}|j||Ž|S(N(tsuperR7t__new__t__init__(R9targstkwargstnew_cls(R(sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyRXäs csN|jƒ|jj}|r¸tjjtjjtjjtƒdƒƒ}t j tjj|dƒtjj|j dƒƒt |j dtjj|j dƒgƒ}|j d|ƒntˆ|ƒjƒ|jr5yddlm}Wntk rd}nX|dk r5||jkr5t|_||_q5n|jrJt|_ndS(Ntsrcs compiler.cs _compiler.cs ._compileriiÿÿÿÿ(t __version__(t_adjust_compilert distributiont ext_modulestostpathtrelpathtjointdirnamet__file__tshutiltcopy2RKRtinsertRWtfinalize_optionsRJRR^RRRt force_rebuildtforce(tselft extensionstsrc_pathtextR (R(sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyRkôs,   $       csŒtƒ}xe|jD]Z}d|jkr`|jjdƒ}|jj||ƒ|jjdƒn|j|ƒqWtˆ|ƒjƒyt ˆddgƒd}Wnt t fk rÀd}nX|j rˆ|j |krˆt jjˆƒ}t jj|dƒ}t|dƒ-}|jdƒ|jd j|j ƒƒWdQXt jj|jƒr~|j|t jj|j|ƒd tƒntƒndS( NtnumpyR R iRscython_version.pytws # Generated file; do not modify scython_version = {0!r} t preserve_mode(RRot include_dirstindexRjtremovet_check_cython_sourcesRWtrunR RRRJRbRcRdRetopentwritetformattisdirt build_libt copy_fileRR(Rnt np_includet extensiontidxR t package_dirt cython_pytf(Rt packagename(sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyRys0     c SsÉdtjkròtjd}yt|ƒ}WnFtk rttjdjd|ƒƒ}tj|ƒt j dƒnXxv|j D]k\}}t j ||ƒrtjdjd|d|d|jd|ƒƒ}tj|ƒt j dƒqqWd S|jd k rd Stjƒ}|d krÅtjdƒ}yt|ƒ}WnFtk r„tjd jd|ƒƒ}tj|ƒt j dƒnXx=|j D]/\}}t j ||ƒr|tjd where is the command you ran. R0tpkgtfixedNtunixs The C compiler used to compile Python {compiler:s}, and which is normally used to compile C extensions, is not available. You can explicitly specify which compiler to use by setting the CC environment variable, for example: CC=gcc python setup.py or if you are using MacOS X, you can try: CC=clang python setup.py (RbtenvironR1tOSErrorttextwraptdedentR|RtwarnR"texitt_broken_compiler_mappingtretmatchRKR,RRRRtget_config_var(Rnt c_compilerR0tmsgtbrokenR‰t compiler_type((sL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyR_AsB            c SsE|jdkrtƒ}n |j}xt|jƒD] \}}tjj|ƒ\}}|d}|d}|d} tjj|ƒsŽq4n|j r§||j|s$         * ,sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/0000755000175000001440000000000013011056504026053 5ustar stuartusers00000000000000sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/setup_package.cpython-35.pyc0000644000175000001440000000052212753326222033323 0ustar stuartusers00000000000000 ’¬­Wwã@s ddlmZdd„ZdS)é)ÚjoincCsdtddƒgiS)Nzastropy_helpers.commandsÚsrcz compiler.c)r©rrú)astropy_helpers/commands/setup_package.pyÚget_package_datasrN)Úos.pathrrrrrrÚssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/build_py.cpython-35.pyc0000644000175000001440000000254112753326222032322 0ustar stuartusers00000000000000 ’¬­W®ã@s:ddlmZddlmZGdd„deƒZdS)é)Úbuild_pyé)Ú_get_platlib_dirc@s]eZdZejdd…Zejdd…Zdd„Zddd„Zdd„ZdS) ÚAstropyBuildPyNcCsG|jdƒ}t|ƒ}||_||_||_tj|ƒdS)NÚbuild)Úget_finalized_commandrZ build_purelibÚ build_libÚSetuptoolsBuildPyÚfinalize_options)ÚselfZ build_cmdZ platlib_dir©r úK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_py.pyr s     zAstropyBuildPy.finalize_optionsFcCs|jj}g}xS|D]K}xB|D]-}|t|jƒdd…j|ƒr&Pq&W|j|ƒqWtj|||ƒdS)Né)Ú distributionÚ skip_2to3ÚlenrÚ startswithÚappendr Úrun_2to3)r ÚfilesÚdoctestsrZfiltered_filesÚfilenameÚpackager r r rs   &zAstropyBuildPy.run_2to3cCstj|ƒdS)N)r Úrun)r r r r r%szAstropyBuildPy.run) Ú__name__Ú __module__Ú __qualname__r Ú user_optionsÚboolean_optionsr rrr r r r rs   rN)Zsetuptools.command.build_pyrr Úutilsrrr r r r Ússunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/install_lib.cpython-35.pyc0000644000175000001440000000150112753326222033002 0ustar stuartusers00000000000000 ’¬­Wã@s:ddlmZddlmZGdd„deƒZdS)é)Ú install_libé)Ú_get_platlib_dirc@sBeZdZejdd…Zejdd…Zdd„ZdS)ÚAstropyInstallLibNcCs5|jdƒ}t|ƒ}||_tj|ƒdS)NÚbuild)Úget_finalized_commandrÚ build_dirÚSetuptoolsInstallLibÚfinalize_options)ÚselfÚ build_cmdÚ platlib_dir©rúN/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install_lib.pyr s  z"AstropyInstallLib.finalize_options)Ú__name__Ú __module__Ú __qualname__r Ú user_optionsÚboolean_optionsr rrrrrs rN)Zsetuptools.command.install_librr ÚutilsrrrrrrÚssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/test.cpython-35.pyc0000644000175000001440000000245512753326222031476 0ustar stuartusers00000000000000 ’¬­WLã@sŽdZyIddlZyddlmZWn"ek rMddlmZYnXWn8ek r‰ddlmZGdd„deƒZYnXdS)aC Different implementations of the ``./setup.py test`` command depending on what's locally available. If Astropy v1.1.0.dev or later is available it should be possible to import AstropyTest from ``astropy.tests.command``. If ``astropy`` can be imported but not ``astropy.tests.command`` (i.e. an older version of Astropy), we can use the backwards-compat implementation of the command. If Astropy can't be imported at all then there is a skeleton implementation that allows users to at least discover the ``./setup.py test`` command and learn that they need Astropy to run it. éN)Ú AstropyTesté)Ú _DummyCommandc@s"eZdZdZdZdZdS)rÚtestzRun the tests for this packagezOThe 'test' command requires the astropy package to be installed and importable.N)Ú__name__Ú __module__Ú __qualname__Ú command_nameÚ descriptionÚ error_msg©r r úG/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/test.pyrs r)Ú__doc__ÚastropyZastropy.tests.commandrÚ ExceptionZ _test_compatZ_dummyrr r r r Ú s   sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/build_sphinx.cpython-35.pyc0000644000175000001440000001447513011054567033212 0ustar stuartusers00000000000000 •X$Xœ%ã@sÿddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlZddlmZddlmZejddkZGd d „d eƒZGd d „d eƒZdS) é)Úprint_functionN)Úlog)ÚDistutilsOptionError)ÚBuildDocé)Ú minversionéc@sãeZdZdZdZejdd…Zejdƒejdƒejdƒejdƒejdd…Zejdƒejdƒejd ƒejd ƒe j de j ƒZ dd„Z dd„Zdd„ZdS)ÚAstropyBuildSphinxaÉ A version of the ``build_sphinx`` command that uses the version of Astropy that is built by the setup ``build`` command, rather than whatever is installed on the system. To build docs against the installed version, run ``make html`` in the ``astropy/docs`` directory. This also automatically creates the docs/_static directories--this is needed because GitHub won't create the _static dir because it has no tracked files. z2Build Sphinx documentation for Astropy environmentNúwarnings-returncodeÚwúÎParses the sphinx output and sets the return code to 1 if there are any warnings. Note that this will cause the sphinx log to only update when it completes, rather than continuously as is normally the case.ú clean-docsÚlú_Completely clean previous builds, including automodapi-generated files before building new onesúno-intersphinxÚnú0Skip intersphinx, even if conf.py says to use itúopen-docs-in-browserÚoú\Open the docs in a browser (using the webbrowser module) if the build finishes successfully.zself\.([^\d\W][\w]+)cCs5tj|ƒd|_d|_d|_d|_dS)NF)ÚSphinxBuildDocÚinitialize_optionsÚ clean_docsÚno_intersphinxÚopen_docs_in_browserÚwarnings_returncode)Úself©rúO/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_sphinx.pyr<s     z%AstropyBuildSphinx.initialize_optionscCs½|jr¬tjj|jdƒg}|jdkrC|jdƒn|j|jƒxV|D]N}tjj|ƒr“tj d|ƒt j |ƒqZtj d|dƒqZWt j |ƒdS)NZapiz docs/_buildzCleaning directory zNot cleaning directory z' because not present or not a directory)rÚosÚpathÚjoinÚ source_dirÚ build_dirÚappendÚisdirrÚinfoÚshutilÚrmtreerÚfinalize_options)rZdirstormÚdrrrr)Cs  z#AstropyBuildSphinx.finalize_optionsc Cs‰ddl}tr%ddlm}nddlm}d}|jdk rÑtjj|jƒ\}}|dkr‰tjj|ƒ\}}tjj |dƒ}tjj |ƒrÄt d|dƒ‚|j |ƒ|j dƒ}d|_|jdƒ|jdƒ}tjj|jƒ}tjdƒ} tjj| jƒ} tjtjƒ\} } tjd ƒjd |d | d |jƒ} | tjdj | d d…ƒƒ7} |jj| ƒ} xwtd t| ƒdƒD]]}| |}t ||ƒ}|j!dƒrt"tjj|ƒƒ| |d!kr9tjj|j?ƒ}tjj |d"ƒ}d#||ƒ}|j@|ƒqlt'j9d$ƒn#t'j9d%tA|j<ƒƒ|j<}|dk r…t)jB|ƒdS)&Nr)Ú pathname2urlÚZ_staticz-Attempted to build_sphinx in a location wherez is a file. Must be a directory.ÚbuildÚastropy_helperszº from sphinx.setup_command import * os.chdir({srcdir!r}) sys.path.insert(0, {build_cmd_path!r}) sys.path.insert(0, {ah_path!r}) Úbuild_cmd_pathÚah_pathÚsrcdirérZ_dirz1.3z%from __future__ import print_functionzconfoverrides = {}z*confoverrides = {'intersphinx_mapping':{}}zs          Ïsunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/register.cpython-35.pyc0000644000175000001440000000401612753326222032336 0ustar stuartusers00000000000000 ’¬­Wg ã@s*ddlmZGdd„deƒZdS)é)Úregisterc@sZeZdZdZejd gZejdgZdd„Zdd„Zd d „Z dS) ÚAstropyRegisteraéExtends the built in 'register' command to support a ``--hidden`` option to make the registered version hidden on PyPI by default. The result of this is that when a version is registered as "hidden" it can still be downloaded from PyPI, but it does not show up in the list of actively supported versions under http://pypi.python.org/pypi/astropy, and is not set as the most recent version. Although this can always be set through the web interface it may be more convenient to be able to specify via the 'register' command. Hidden may also be considered a safer default when running the 'register' command, though this command uses distutils' normal behavior if the ``--hidden`` option is omitted. ÚhiddenNú.mark this release as hidden on PyPI by defaultcCstj|ƒd|_dS)NF)ÚSetuptoolsRegisterÚinitialize_optionsr)Úself©r úK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/register.pyrs z"AstropyRegister.initialize_optionscCs5tj||ƒ}|dkr1|jr1d|d<|S)NÚsubmitÚ1Z _pypi_hidden)rÚbuild_post_datar)rÚactionÚdatar r r r s zAstropyRegister.build_post_datacCsQd|_tj|ƒ|jjdƒ}d|krM|d\}}||_dS)NÚpypirÚ repository)rrÚ _set_configÚ distributionÚget_option_dict)rÚoptionsÚsourceÚvaluer r r r#s   zAstropyRegister._set_config)zhiddenNr) Ú__name__Ú __module__Ú __qualname__Ú__doc__rÚ user_optionsÚboolean_optionsrr rr r r r rs    rN)Zsetuptools.command.registerrrrr r r r Ússunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/build_ext.cpython-35.pyc0000644000175000001440000002755513011054567032504 0ustar stuartusers00000000000000 •X$XµKã@sddlZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZddlmZmZmZdd lmZdd d „ZiZd d „Zdd„ZdS)éN)ÚlogÚ ccompilerÚ sysconfig)ÚCommand)Ú Extension)Úget_default_compiler)Ú build_exté)Úget_numpy_include_pathÚinvalidate_cachesÚ classproperty)Úget_pkg_version_modulec#Csóy t|ddddgƒ}Wntk r:d}YnX|dkru|dk ruy |j}Wntk rtYnXy |j}Wntk rœd}YnXd}yddl}d }Wntk rÍYnX|rë| sç|dkrë|SdSdS) aReturns the previously used Cython version (or 'unknown' if not previously built) if Cython should be used to build extension modules from pyx files. If the ``release`` parameter is not specified an attempt is made to determine the release flag from `astropy.version`. z.cython_versionÚfromlistÚreleaseÚcython_versionNÚunknownFrT)Ú __import__Ú ImportErrorrÚAttributeErrorrÚCython)ÚpackagerÚversion_modulerZ have_cythonr©rúL/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/build_ext.pyÚshould_build_with_cythons.           rcsvˆtkrtˆSddddddg}‡fdd†}x'|D]}||ƒ}|d krEPqEW|tˆ<|S) Nz --versionz --Versionz-versionz-Versionz-vz-Vcs¥tjtjˆddtjkƒ|gdtjdtjƒ}|jƒ\}}|jdkredS|j ƒj dƒ}|s•|j ƒj dƒ}|s¡d}|S)NÚposixÚwinÚstdoutÚstderrrrzlatin-1) Ú subprocessÚPopenÚshlexÚsplitÚsysÚplatformÚPIPEÚ communicateÚ returncodeÚstripÚdecode)ÚflagÚprocessrrÚoutput)ÚcompilerrrÚtry_get_versionJs%z-get_compiler_version..try_get_versionr)Ú_compiler_versions)r-Úflagsr.r*Úversionr)r-rÚget_compiler_version?s       r2cs)G‡‡‡fdd†dttƒ‰ˆS)a§ Creates a custom 'build_ext' command that allows for manipulating some of the C extension options at build time. We use a function to build the class since the base class for build_ext may be different depending on certain build-time parameters (for example, we may use Cython's build_ext instead of the default version in distutils). Uses the default distutils.command.build_ext by default. cseZdZ”Z”Zejdd…Zejdd…Z ej dd…Z dZ dgZ edd„ƒZedd„ƒZed d „ƒZ ed d ƒ‡fd d†ƒZ‡‡fdd†Z‡‡fdd†Z‡‡‡fdd†Zdd„Zdd„Z‡S)z-generate_build_ext_command..build_extNFú$i686-apple-darwin[0-9]*-llvm-gcc-4.2ÚclangcSs0ddlm}|jdkr&|jS|jjS)Nr)Úcore)Ú distutilsr5Ú_setup_distributionÚ _user_optionsÚ _final_classÚ user_options)Úclsr5rrrr:‘sz:generate_build_ext_command..build_ext.user_optionscSs0ddlm}|jdkr&|jS|jjS)Nr)r5)r6r5r7Ú_boolean_optionsr9Úboolean_options)r;r5rrrr=œsz=generate_build_ext_command..build_ext.boolean_optionscSs0ddlm}|jdkr&|jS|jjS)Nr)r5)r6r5r7Ú _help_optionsr9Ú help_options)r;r5rrrr?¨sz:generate_build_ext_command..build_ext.help_optionsÚlazyTc sÑtˆjˆjƒ}|r.ddlm‰nt‰‡‡fdd†}ˆj‡fdd†ˆjDƒ}tˆj ƒ}|j d|dƒd|dƒd |d |iƒˆt fˆ_ t ˆjˆf|ƒS) z• Late determination of what the build_ext base class should be, depending on whether or not Cython is available. r)rcsVtˆ|ƒ}tˆd|ƒ}tdd„|Dƒƒ‰|‡fdd†|DƒS)NÚ_css|]}|dVqdS)rNr)Ú.0Úoptrrrú Ìszdgenerate_build_ext_command..build_ext._final_class..merge_options..cs&g|]}|dˆkr|‘qS)rr)rBrC)Úall_baserrú Îs zegenerate_build_ext_command..build_ext._final_class..merge_options..)ÚgetattrÚset)ÚattrÚbaseZours)Úbase_clsr;)rErÚ merge_optionsÈszQgenerate_build_ext_command..build_ext._final_class..merge_optionscs%g|]}|ˆjkr|‘qSr)r=)rBrC)rKrrrFÑs zNgenerate_build_ext_command..build_ext._final_class..r:r?r=Ú uses_cython)rÚ package_nameÚ is_releaseZCython.DistutilsrÚSetuptoolsBuildExtr=r<ÚdictÚ__dict__ÚupdateÚobjectÚ __bases__ÚtypeÚ__name__)r;rMrLr=Úmembers)r)rKr;rr9´s      z:generate_build_ext_command..build_ext._final_classcs2tˆ|jƒj|jƒ}|j||Ž|S)N)Úsuperr9Ú__new__Ú__init__)r;ÚargsÚkwargsZnew_cls)Ú __class__rrrrZäs z5generate_build_ext_command..build_ext.__new__c sC|jƒ|jj}|rµtjjtjjtjjtƒdƒƒ}t j tjj|dƒtjj|j dƒƒt |j dtjj|j dƒgƒ}|j d|ƒtˆ|ƒjƒ|jr-yddlm}Wntk rÿd}YnX|dk r-||jkr-d|_||_|jr?d|_dS)NÚsrcz compiler.cz _compiler.cz ._compilerr)Ú __version__T)Ú_adjust_compilerÚ distributionÚ ext_modulesÚosÚpathÚrelpathÚjoinÚdirnameÚ__file__ÚshutilÚcopy2rNrÚinsertrYÚfinalize_optionsrMrr`rÚ force_rebuildÚforce)ÚselfÚ extensionsZsrc_pathÚextr)r^rrrrmôs,   $        z>generate_build_ext_command..build_ext.finalize_optionscs…tƒ}xb|jD]W}d|jkr]|jjdƒ}|jj||ƒ|jjdƒ|j|ƒqWtˆ|ƒjƒyt ˆddgƒd}Wnt t fk r¾d}YnX|j r|j |krt jjˆƒ}t jj|dƒ}t|dƒ-}|jdƒ|jd j|j ƒƒWdQRXt jj|jƒrz|j|t jj|j|ƒd d ƒtƒdS) NÚnumpyrrrrzcython_version.pyÚwz # Generated file; do not modify zcython_version = {0!r} Ú preserve_modeF)r rqÚ include_dirsÚindexrlÚremoveÚ_check_cython_sourcesrYÚrunr rrrMrdrerfrgÚopenÚwriteÚformatÚisdirZ build_libÚ copy_filer )rpZ np_includeÚ extensionÚidxrÚ package_dirZ cython_pyÚf)r^rÚ packagenamerrrzs0     z1generate_build_ext_command..build_ext.runcSsÂdtjkrðtjd}yt|ƒ}WnGtk rutjdjd|ƒƒ}tj|ƒt j dƒYnXxs|j D]h\}}t j ||ƒr€tjdjd|d|d|jd|ƒƒ}tj|ƒt j dƒq€Wd S|jd k rd Stjƒ}|d kr¾tjdƒ}yt|ƒ}WnGtk rƒtjd jd|ƒƒ}tj|ƒt j dƒYnXx7|j D],\}}t j ||ƒrŽ|tjd where is the command you ran. r1ÚpkgÚfixedNÚunixa The C compiler used to compile Python {compiler:s}, and which is normally used to compile C extensions, is not available. You can explicitly specify which compiler to use by setting the CC environment variable, for example: CC=gcc python setup.py or if you are using MacOS X, you can try: CC=clang python setup.py )rdÚenvironr2ÚOSErrorÚtextwrapÚdedentr}rÚwarnr#ÚexitÚ_broken_compiler_mappingÚreÚmatchrNr-rrrÚget_config_var)rpZ c_compilerr1ÚmsgÚbrokenrˆÚ compiler_typerrrraAsB            z>generate_build_ext_command..build_ext._adjust_compilerc Ss?|jdkrtƒ}n |j}xt|jƒD]\}}tjj|ƒ\}}|d}|d}|d} tjj|ƒs‹q4|jr¤||j|.build_ext._check_cython_sources)r3r4)rWÚ __module__Ú __qualname__rNrOrPr:r8r=r<r?r>rnrr r9rZrmrzraryr)rr„r)r^rrvs     !0(% er)rPrT)r„rr)rr„rrÚgenerate_build_ext_commandks %ÿ`r¤)rrdr‘r!rjrr#rŒr6rrrÚ distutils.cmdrÚdistutils.corerÚdistutils.ccompilerrZsetuptools.command.build_extrrPÚutilsr r r Úversion_helpersr rr/r2r¤rrrrÚs$        * ,sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/_dummy.cpython-35.pyc0000644000175000017500000000616313000430557030724 0ustar stuart00000000000000 ’¬­W| ã@s’dZddlZddlmZddlmZddlmZGdd„deƒZ ej ddkr~e ed ƒƒne ed ƒƒdS) aa Provides a base class for a 'dummy' setup.py command that has no functionality (probably due to a missing requirement). This dummy command can raise an exception when it is run, explaining to the user what dependencies must be met to use this command. The reason this is at all tricky is that we want the command to be able to provide this message even when the user passes arguments to the command. If we don't know ahead of time what arguments the command can take, this is difficult, because distutils does not allow unknown arguments to be passed to a setup.py command. This hacks around that restriction to provide a useful error message even when a user passes arguments to the dummy implementation of a command. Use this like: try: from some_dependency import SetupCommand except ImportError: from ._dummy import _DummyCommand class SetupCommand(_DummyCommand): description = 'Implementation of SetupCommand from some_dependency; ' 'some_dependency must be installed to run this command' # This is the message that will be raised when a user tries to # run this command--define it as a class attribute. error_msg = "The 'setup_command' command requires the some_dependency " "package to be installed and importable." éN)ÚCommand)ÚDistutilsArgError)Údedentcs4eZdZdZdd„Z‡fdd†Z‡S)Ú_DummyCommandMetaa  Causes an exception to be raised on accessing attributes of a command class so that if ``./setup.py command_name`` is run with additional command-line options we can provide a useful error message instead of the default that tells users the options are unrecognized. cCsP|ttfkrdSt|dƒs1tdƒ‚t|dƒsLtdƒ‚dS)NÚ descriptionz;_DummyCommand subclass must have a 'description' attribute.Ú error_msgz:_DummyCommand subclass must have an 'error_msg' attribute.)rÚobjectÚhasattrÚ TypeError)ÚclsÚnameÚbasesÚmembers©rúI/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/_dummy.pyÚ__init__0s z_DummyCommandMeta.__init__cs5|dkr"tt|ƒj|ƒSt|jƒ‚dS)Nrr)z descriptionz error_msg)ÚsuperrÚ__getattribute__rr)r Úattr)Ú __class__rrr?s z"_DummyCommandMeta.__getattribute__)Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrr)rrr(s  réza class _DummyCommand(Command, object): __metaclass__ = _DummyCommandMeta za class _DummyCommand(Command, object, metaclass=_DummyCommandMeta): pass ) rÚsysÚ setuptoolsrÚdistutils.errorsrÚtextwraprÚtyperÚ version_infoÚexecrrrrÚ s   sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/__init__.cpython-35.pyc0000644000175000001440000000023612753326222032251 0ustar stuartusers00000000000000 ’¬­Wã@sdS)N©rrrúK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/__init__.pyÚssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__pycache__/install.cpython-35.pyc0000644000175000001440000000145412753326222032163 0ustar stuartusers00000000000000 ’¬­Wæã@s:ddlmZddlmZGdd„deƒZdS)é)Úinstallé)Ú_get_platlib_dirc@sBeZdZejdd…Zejdd…Zdd„ZdS)ÚAstropyInstallNcCs5|jdƒ}t|ƒ}||_tj|ƒdS)NÚbuild)Úget_finalized_commandrÚ build_libÚSetuptoolsInstallÚfinalize_options)ÚselfÚ build_cmdÚ platlib_dir©rúJ/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install.pyr s  zAstropyInstall.finalize_options)Ú__name__Ú __module__Ú __qualname__r Ú user_optionsÚboolean_optionsr rrrrrs rN)Zsetuptools.command.installrr ÚutilsrrrrrrÚssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/install.pyc0000644000175000001440000000166512775203577026062 0ustar stuartusers00000000000000ó ’¬­Wc@s:ddlmZddlmZdefd„ƒYZdS(iÿÿÿÿ(tinstalli(t_get_platlib_dirtAstropyInstallcBs%eZejZejZd„ZRS(cCs5|jdƒ}t|ƒ}||_tj|ƒdS(Ntbuild(tget_finalized_commandRt build_libtSetuptoolsInstalltfinalize_options(tselft build_cmdt platlib_dir((sJ/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install.pyR s  (t__name__t __module__Rt user_optionstboolean_optionsR(((sJ/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install.pyRs  N(tsetuptools.command.installRRtutilsRR(((sJ/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/install.pytssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/install_lib.py0000644000175000001440000000100012753326222026511 0ustar stuartusers00000000000000from setuptools.command.install_lib import install_lib as SetuptoolsInstallLib from ..utils import _get_platlib_dir class AstropyInstallLib(SetuptoolsInstallLib): user_options = SetuptoolsInstallLib.user_options[:] boolean_options = SetuptoolsInstallLib.boolean_options[:] def finalize_options(self): build_cmd = self.get_finalized_command('build') platlib_dir = _get_platlib_dir(build_cmd) self.build_dir = platlib_dir SetuptoolsInstallLib.finalize_options(self) sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/build_sphinx.py0000644000175000001440000002263413011054225026712 0ustar stuartusers00000000000000from __future__ import print_function import inspect import os import pkgutil import re import shutil import subprocess import sys import textwrap from distutils import log from distutils.cmd import DistutilsOptionError import sphinx from sphinx.setup_command import BuildDoc as SphinxBuildDoc from ..utils import minversion PY3 = sys.version_info[0] >= 3 class AstropyBuildSphinx(SphinxBuildDoc): """ A version of the ``build_sphinx`` command that uses the version of Astropy that is built by the setup ``build`` command, rather than whatever is installed on the system. To build docs against the installed version, run ``make html`` in the ``astropy/docs`` directory. This also automatically creates the docs/_static directories--this is needed because GitHub won't create the _static dir because it has no tracked files. """ description = 'Build Sphinx documentation for Astropy environment' user_options = SphinxBuildDoc.user_options[:] user_options.append(('warnings-returncode', 'w', 'Parses the sphinx output and sets the return code to 1 if there ' 'are any warnings. Note that this will cause the sphinx log to ' 'only update when it completes, rather than continuously as is ' 'normally the case.')) user_options.append(('clean-docs', 'l', 'Completely clean previous builds, including ' 'automodapi-generated files before building new ones')) user_options.append(('no-intersphinx', 'n', 'Skip intersphinx, even if conf.py says to use it')) user_options.append(('open-docs-in-browser', 'o', 'Open the docs in a browser (using the webbrowser module) if the ' 'build finishes successfully.')) boolean_options = SphinxBuildDoc.boolean_options[:] boolean_options.append('warnings-returncode') boolean_options.append('clean-docs') boolean_options.append('no-intersphinx') boolean_options.append('open-docs-in-browser') _self_iden_rex = re.compile(r"self\.([^\d\W][\w]+)", re.UNICODE) def initialize_options(self): SphinxBuildDoc.initialize_options(self) self.clean_docs = False self.no_intersphinx = False self.open_docs_in_browser = False self.warnings_returncode = False def finalize_options(self): #Clear out previous sphinx builds, if requested if self.clean_docs: dirstorm = [os.path.join(self.source_dir, 'api')] if self.build_dir is None: dirstorm.append('docs/_build') else: dirstorm.append(self.build_dir) for d in dirstorm: if os.path.isdir(d): log.info('Cleaning directory ' + d) shutil.rmtree(d) else: log.info('Not cleaning directory ' + d + ' because ' 'not present or not a directory') SphinxBuildDoc.finalize_options(self) def run(self): # TODO: Break this method up into a few more subroutines and # document them better import webbrowser if PY3: from urllib.request import pathname2url else: from urllib import pathname2url # This is used at the very end of `run` to decide if sys.exit should # be called. If it's None, it won't be. retcode = None # If possible, create the _static dir if self.build_dir is not None: # the _static dir should be in the same place as the _build dir # for Astropy basedir, subdir = os.path.split(self.build_dir) if subdir == '': # the path has a trailing /... basedir, subdir = os.path.split(basedir) staticdir = os.path.join(basedir, '_static') if os.path.isfile(staticdir): raise DistutilsOptionError( 'Attempted to build_sphinx in a location where' + staticdir + 'is a file. Must be a directory.') self.mkpath(staticdir) # Now make sure Astropy is built and determine where it was built build_cmd = self.reinitialize_command('build') build_cmd.inplace = 0 self.run_command('build') build_cmd = self.get_finalized_command('build') build_cmd_path = os.path.abspath(build_cmd.build_lib) ah_importer = pkgutil.get_importer('astropy_helpers') ah_path = os.path.abspath(ah_importer.path) # Now generate the source for and spawn a new process that runs the # command. This is needed to get the correct imports for the built # version runlines, runlineno = inspect.getsourcelines(SphinxBuildDoc.run) subproccode = textwrap.dedent(""" from sphinx.setup_command import * os.chdir({srcdir!r}) sys.path.insert(0, {build_cmd_path!r}) sys.path.insert(0, {ah_path!r}) """).format(build_cmd_path=build_cmd_path, ah_path=ah_path, srcdir=self.source_dir) # runlines[1:] removes 'def run(self)' on the first line subproccode += textwrap.dedent(''.join(runlines[1:])) # All "self.foo" in the subprocess code needs to be replaced by the # values taken from the current self in *this* process subproccode = self._self_iden_rex.split(subproccode) for i in range(1, len(subproccode), 2): iden = subproccode[i] val = getattr(self, iden) if iden.endswith('_dir'): # Directories should be absolute, because the `chdir` call # in the new process moves to a different directory subproccode[i] = repr(os.path.abspath(val)) else: subproccode[i] = repr(val) subproccode = ''.join(subproccode) # This is a quick gross hack, but it ensures that the code grabbed from # SphinxBuildDoc.run will work in Python 2 if it uses the print # function if minversion(sphinx, '1.3'): subproccode = 'from __future__ import print_function' + subproccode if self.no_intersphinx: # the confoverrides variable in sphinx.setup_command.BuildDoc can # be used to override the conf.py ... but this could well break # if future versions of sphinx change the internals of BuildDoc, # so remain vigilant! subproccode = subproccode.replace('confoverrides = {}', 'confoverrides = {\'intersphinx_mapping\':{}}') log.debug('Starting subprocess of {0} with python code:\n{1}\n' '[CODE END])'.format(sys.executable, subproccode)) # To return the number of warnings, we need to capture stdout. This # prevents a continuous updating at the terminal, but there's no # apparent way around this. if self.warnings_returncode: proc = subprocess.Popen([sys.executable, '-c', subproccode], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) retcode = 1 with proc.stdout: for line in iter(proc.stdout.readline, b''): line = line.strip(b'\n') print(line.decode('utf-8')) if 'build succeeded.' == line.decode('utf-8'): retcode = 0 # Poll to set proc.retcode proc.wait() if retcode != 0: if os.environ.get('TRAVIS', None) == 'true': #this means we are in the travis build, so customize #the message appropriately. msg = ('The build_sphinx travis build FAILED ' 'because sphinx issued documentation ' 'warnings (scroll up to see the warnings).') else: # standard failure message msg = ('build_sphinx returning a non-zero exit ' 'code because sphinx issued documentation ' 'warnings.') log.warn(msg) else: proc = subprocess.Popen([sys.executable], stdin=subprocess.PIPE) proc.communicate(subproccode.encode('utf-8')) if proc.returncode == 0: if self.open_docs_in_browser: if self.builder == 'html': absdir = os.path.abspath(self.builder_target_dir) index_path = os.path.join(absdir, 'index.html') fileurl = 'file://' + pathname2url(index_path) webbrowser.open(fileurl) else: log.warn('open-docs-in-browser option was given, but ' 'the builder is not html! Ignoring.') else: log.warn('Sphinx Documentation subprocess failed with return ' 'code ' + str(proc.returncode)) retcode = proc.returncode if retcode is not None: # this is potentially dangerous in that there might be something # after the call to `setup` in `setup.py`, and exiting here will # prevent that from running. But there's no other apparent way # to signal what the return code should be. sys.exit(retcode) class AstropyBuildDocs(AstropyBuildSphinx): description = 'alias to the build_sphinx command' sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/test.pyc0000644000175000001440000000262512775203577025370 0ustar stuartusers00000000000000ó ’¬­Wc@sŒdZyHddlZyddlmZWn!ek rLddlmZnXWn7ek r‡ddlmZdefd„ƒYZnXdS(sC Different implementations of the ``./setup.py test`` command depending on what's locally available. If Astropy v1.1.0.dev or later is available it should be possible to import AstropyTest from ``astropy.tests.command``. If ``astropy`` can be imported but not ``astropy.tests.command`` (i.e. an older version of Astropy), we can use the backwards-compat implementation of the command. If Astropy can't be imported at all then there is a skeleton implementation that allows users to at least discover the ``./setup.py test`` command and learn that they need Astropy to run it. iÿÿÿÿN(t AstropyTesti(t _DummyCommandRcBseZdZdZdZRS(ttestsRun the tests for this packagesOThe 'test' command requires the astropy package to be installed and importable.(t__name__t __module__t command_namet descriptiont error_msg(((sG/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/test.pyRs(t__doc__tastropytastropy.tests.commandRt Exceptiont _test_compatt_dummyR(((sG/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/test.pyt s   sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/__init__.pyc0000644000175000001440000000024212775203577026141 0ustar stuartusers00000000000000ó ’¬­Wc@sdS(N((((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/__init__.pytssunpy-0.7.4/astropy_helpers/astropy_helpers/commands/test.py0000644000175000001440000000251412753326222025207 0ustar stuartusers00000000000000""" Different implementations of the ``./setup.py test`` command depending on what's locally available. If Astropy v1.1.0.dev or later is available it should be possible to import AstropyTest from ``astropy.tests.command``. If ``astropy`` can be imported but not ``astropy.tests.command`` (i.e. an older version of Astropy), we can use the backwards-compat implementation of the command. If Astropy can't be imported at all then there is a skeleton implementation that allows users to at least discover the ``./setup.py test`` command and learn that they need Astropy to run it. """ # Previously these except statements caught only ImportErrors, but there are # some other obscure exceptional conditions that can occur when importing # astropy.tests (at least on older versions) that can cause these imports to # fail try: import astropy try: from astropy.tests.command import AstropyTest except Exception: from ._test_compat import AstropyTest except Exception: # No astropy at all--provide the dummy implementation from ._dummy import _DummyCommand class AstropyTest(_DummyCommand): command_name = 'test' description = 'Run the tests for this package' error_msg = ( "The 'test' command requires the astropy package to be " "installed and importable.") sunpy-0.7.4/astropy_helpers/astropy_helpers/commands/register.pyc0000644000175000001440000000455412775203577026240 0ustar stuartusers00000000000000ó ’¬­Wc@s*ddlmZdefd„ƒYZdS(iÿÿÿÿ(tregistertAstropyRegistercBsIeZdZejdgZejdgZd„Zd„Zd„Z RS(séExtends the built in 'register' command to support a ``--hidden`` option to make the registered version hidden on PyPI by default. The result of this is that when a version is registered as "hidden" it can still be downloaded from PyPI, but it does not show up in the list of actively supported versions under http://pypi.python.org/pypi/astropy, and is not set as the most recent version. Although this can always be set through the web interface it may be more convenient to be able to specify via the 'register' command. Hidden may also be considered a safer default when running the 'register' command, though this command uses distutils' normal behavior if the ``--hidden`` option is omitted. thiddens.mark this release as hidden on PyPI by defaultcCstj|ƒt|_dS(N(tSetuptoolsRegistertinitialize_optionstFalseR(tself((sK/home/stuart/Git/sunpy/astropy_helpers/astropy_helpers/commands/register.pyRs cCs8tj||ƒ}|dkr4|jr4d|d