text: #!/usr/bin/env python
  """DismalPy: a collection of resources for quantitative economics in Python.
  """
  
  DOCLINES = __doc__.split("\n")
  
  import os
  import sys
  import subprocess
  
  
  if sys.version_info[:2] < (2, 6) or (3, 0) <= sys.version_info[0:2] < (3, 2):
      raise RuntimeError("Python version 2.6, 2.7 or >= 3.2 required.")
  
  if sys.version_info[0] < 3:
      import __builtin__ as builtins
  else:
      import builtins
  
  CLASSIFIERS = """\
  Development Status :: 4 - Beta
  Intended Audience :: Science/Research
  License :: OSI Approved :: BSD License
  Programming Language :: Cython
  Programming Language :: Python
  Programming Language :: Python :: 3
  Topic :: Scientific/Engineering
  Operating System :: Microsoft :: Windows
  Operating System :: POSIX
  Operating System :: Unix
  Operating System :: MacOS
  """
  
  MAJOR               = 0
  MINOR               = 2
  MICRO               = 3
  ISRELEASED          = True
  VERSION             = '%d.%d.%d' % (MAJOR, MINOR, MICRO)
  
  
  # Return the git revision as a string
  def git_version():
      def _minimal_ext_cmd(cmd):
          # construct minimal environment
          env = {}
          for k in ['SYSTEMROOT', 'PATH']:
              v = os.environ.get(k)
              if v is not None:
                  env[k] = v
          # LANGUAGE is used on win32
          env['LANGUAGE'] = 'C'
          env['LANG'] = 'C'
          env['LC_ALL'] = 'C'
          out = subprocess.Popen(cmd, stdout = subprocess.PIPE, env=env).communicate()[0]
          return out
  
      try:
          out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD'])
          GIT_REVISION = out.strip().decode('ascii')
      except OSError:
          GIT_REVISION = "Unknown"
  
      return GIT_REVISION
  
  
  # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
  # update it when the contents of directories change.
  if os.path.exists('MANIFEST'):
      os.remove('MANIFEST')
  
  def get_version_info():
      # Adding the git rev number needs to be done inside
      # write_version_py(), otherwise the import of dismalpy.version messes
      # up the build under Python 3.
      FULLVERSION = VERSION
      if os.path.exists('.git'):
          GIT_REVISION = git_version()
      elif os.path.exists('dismalpy/version.py'):
          # must be a source distribution, use existing version file
          # load it as a separate module to not load dismalpy/__init__.py
          import imp
          version = imp.load_source('dismalpy.version', 'dismalpy/version.py')
          GIT_REVISION = version.git_revision
      else:
          GIT_REVISION = "Unknown"
  
      if not ISRELEASED:
          FULLVERSION += '.dev-' + GIT_REVISION[:7]
  
      return FULLVERSION, GIT_REVISION
  
  
  def write_version_py(filename='dismalpy/version.py'):
      cnt = """
  # THIS FILE IS GENERATED FROM dismalpy SETUP.PY
  short_version = '%(version)s'
  version = '%(version)s'
  full_version = '%(full_version)s'
  git_revision = '%(git_revision)s'
  release = %(isrelease)s
  
  if not release:
      version = full_version
  """
      FULLVERSION, GIT_REVISION = get_version_info()
  
      a = open(filename, 'w')
      try:
          a.write(cnt % {'version': VERSION,
                         'full_version' : FULLVERSION,
                         'git_revision' : GIT_REVISION,
                         'isrelease': str(ISRELEASED)})
      finally:
          a.close()
  
  try:
      from sphinx.setup_command import BuildDoc
      HAVE_SPHINX = True
  except:
      HAVE_SPHINX = False
  
  if HAVE_SPHINX:
      class DismalpyBuildDoc(BuildDoc):
          """Run in-place build before Sphinx doc build"""
          def run(self):
              # Make sure dismalpy is built for autodoc features
              ret = subprocess.call([sys.executable, sys.argv[0], 'build_ext', '-i'])
              if ret != 0:
                  raise RuntimeError("Building Dismalpy failed!")
  
              # Regenerate notebooks
              cwd = os.path.abspath(os.path.dirname(__file__))
              print("Re-generating notebooks")
              p = subprocess.call([sys.executable,
                                   os.path.join(cwd, 'tools', 'sphinxify_notebooks.py'),
                                   ], cwd=cwd)
              if p != 0:
                  raise RuntimeError("Notebook generation failed!")
  
              # Build the documentation
              BuildDoc.run(self)
  
  def generate_cython():
      cwd = os.path.abspath(os.path.dirname(__file__))
      print("Cythonizing sources")
      p = subprocess.call([sys.executable,
                           os.path.join(cwd, 'tools', 'cythonize.py'),
                           'dismalpy'],
                           cwd=cwd)
      if p != 0:
          raise RuntimeError("Running cythonize failed!")
  
  
  def configuration(parent_package='',top_path=None):
      from numpy.distutils.misc_util import Configuration
      config = Configuration(None, parent_package, top_path)
      config.set_options(ignore_setup_xxx_py=True,
                         assume_default_configuration=True,
                         delegate_options_to_subpackages=True,
                         quiet=True)
  
      config.add_subpackage('dismalpy')
      config.add_data_files(('dismalpy','*.txt'))
  
      config.get_version('dismalpy/version.py')
  
      return config
  
  def setup_package():
  
      # Rewrite the version file every time
      write_version_py()
  
      if HAVE_SPHINX:
          cmdclass = {'build_sphinx': DismalpyBuildDoc}
      else:
          cmdclass = {}
  
      # Figure out whether to add ``*_requires = ['numpy']``.
      # We don't want to do that unconditionally, because we risk updating
      # an installed numpy which fails too often.  Just if it's not installed, we
      # may give it a try.  See gh-3379.
      build_requires = ['statsmodels>=0.8', 'scipy>=0.14', 'Cython>=0.20','pandas>=0.16.0']
      try:
          import numpy
      except:
          build_requires = ['numpy>=1.5.1']
  
      metadata = dict(
          name = 'dismalpy',
          maintainer = "Chad Fulton",
          maintainer_email = "ChadFulton+pypi@gmail.com",
          description = DOCLINES[0],
          long_description = "\n".join(DOCLINES[2:]),
          url = "http://github.com/dismalpy/dismalpy",
          # download_url = "",
          license = 'Simplified-BSD',
          cmdclass=cmdclass,
          classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
          platforms = ["Windows", "Linux", "Solaris", "Mac OS-X", "Unix"],
          test_suite='nose.collector',
          setup_requires = build_requires,
          install_requires = build_requires,
      )
  
      if len(sys.argv) >= 2 and ('--help' in sys.argv[1:] or
              sys.argv[1] in ('--help-commands', 'egg_info', '--version',
                              'clean')):
          # For these actions, NumPy is not required.
          #
          # They are required to succeed without Numpy for example when
          # pip is used to install dismalpy when Numpy is not yet present in
          # the system.
          try:
              from setuptools import setup
          except ImportError:
              from distutils.core import setup
  
          FULLVERSION, GIT_REVISION = get_version_info()
          metadata['version'] = FULLVERSION
      else:
          # if len(sys.argv) >= 2 and sys.argv[1] == 'bdist_wheel':
          #     # bdist_wheel needs setuptools
          #     import setuptools
          import setuptools
  
          from numpy.distutils.core import setup
  
          cwd = os.path.abspath(os.path.dirname(__file__))
          if not os.path.exists(os.path.join(cwd, 'PKG-INFO')):
              # Generate Cython sources, unless building from source release
              generate_cython()
  
          metadata['configuration'] = configuration
  
      setup(**metadata)
  
  if __name__ == '__main__':
      setup_package()