def run(self):
        """Runs the install and post-install actions"""
        install.run(self)

        log.info("Preparing/extracting location database and data for import...")
        self.prep_location_data()

        log.info("Importing location data into location database...")
        database = sqlite3.connect(self.install_lib+'cahoots/parsers/location/data/location.sqlite')
        database.text_factory = str
        cursor = database.cursor()

        log.info("Importing city data...")
        self.import_city_data(cursor)

        log.info("Importing country data...")
        self.import_country_data(cursor)

        log.info("Importing street suffix data...")
        self.import_street_suffix_data(cursor)

        log.info("Importing landmark data...")
        self.import_landmark_data(cursor)

        database.commit()
        database.close()

        log.info('Cleaning up location import temporary files...')
        self.cleanup_location_data()

        log.info('Done!')

    def run(self):
        '''
        We override the basic install command. First we download jars then
        we run the basic install then we check whether the jars are present
        in this package. If they aren't present we warn the user and give
        them some advice on how to retry getting the jars.
        '''
        downloader = MavenJarDownloader()
        downloader.download_files()
        if 'do_egg_install' in dir(install):
            '''
            setuptools.command.install checks if it was called
            directly by setup or by some other code by inspecting the call
            stack. They do this for backwards compatability.

            Anyway, when "install" is overriden it calls an older form of
            install (distutils.command.install) otherwise they call do_egg_install
            so we try to call do_egg_install otherwise we call install normally
            (since it should always be present).
            '''
            install.do_egg_install(self)
        else:
            install.run(self)
        missing_jars = downloader.missing_jars()
        if len(missing_jars) > 0:
            print(self.warning_string(missing_jars))

def _run_install(self):
    """
    The definition of the "run" method for the CustomInstallCommand metaclass.
    """
    # Get paths
    tethysapp_dir = get_tethysapp_directory()
    destination_dir = os.path.join(tethysapp_dir, self.app_package)

    # Notify user
    print('Copying App Package: {0} to {1}'.format(self.app_package_dir, destination_dir))

    # Copy files
    try:
        shutil.copytree(self.app_package_dir, destination_dir)

    except:
        try:
            shutil.rmtree(destination_dir)
        except:
            os.remove(destination_dir)

        shutil.copytree(self.app_package_dir, destination_dir)

    # Install dependencies
    for dependency in self.dependencies:
        subprocess.call(['pip', 'install', dependency])

    # Run the original install command
    install.run(self)

  def run(self):
    _install.run(self)

    # the second parameter, [], can be replaced with a set of 
    # parameters if _post_install needs any
    self.execute(_post_install, [],  
                 msg="Running post install task")

    def run(self):
        # Call subprocess to run te 'pip' command.
        # Only works, when user installs from sdist
        call(['pip', 'install', '-r', 'requirements.txt'])

        # Run 'install' to install lyrico
        install.run(self)

 def run(self):
     _install.run(self)
     self.execute(
         self.__post_install,
         (self.install_lib,),
         msg="installing auto completion"
         )

    def run(self):
        this_dir = os.path.dirname(os.path.realpath(__file__))
        self.C_SOURCE = os.path.join(this_dir, 'word2vec', 'c')

        self.TARGET_DIR = 'bin'
        if sys.platform == 'win32':
            self.TARGET_DIR = 'Scripts'

        if not os.path.exists(self.TARGET_DIR):
            os.makedirs(self.TARGET_DIR)

        if sys.platform == 'win32':
            self.compile_c('win32/word2vec.c', 'word2vec.exe')
            self.compile_c('win32/word2phrase.c', 'word2phrase.exe')
            self.compile_c('win32/distance.c', 'word2vec-distance.exe')
            self.compile_c('win32/word-analogy.c', 'word2vec-word-analogy.exe')
            self.compile_c('win32/compute-accuracy.c', 'word2vec-compute-accuracy.exe')
        else:
            self.compile_c('word2vec.c', 'word2vec')
            self.compile_c('word2phrase.c', 'word2phrase')
            self.compile_c('distance.c', 'word2vec-distance')
            self.compile_c('word-analogy.c', 'word2vec-word-analogy')
            self.compile_c('compute-accuracy.c', 'word2vec-compute-accuracy')
            self.compile_c('word2vec-sentence2vec.c', 'word2vec-doc2vec')

        _install.run(self)

    def run(self):
        if sys.platform not in ('linux3', 'linux2', 'win32', 'darwin'):
            msg = "**Error: Can't install on this platform: %s" % sys.platform
            print msg
            sys.exit(1)

        # create build/share directory
        dir_util.mkpath(os.path.join(self.build_base, 'share', 'bauble'))

        if not self.single_version_externally_managed:
            self.do_egg_install()
        else:
            _install.run(self)

        # install bauble.desktop and icons
        if sys.platform in ('linux3', 'linux2'):
            # install everything in share
            dir_util.copy_tree(os.path.join(self.build_base, 'share'),
                               os.path.join(self.install_data, 'share'))
        elif sys.platform == 'win32':
            # install only i18n files
            locales = os.path.dirname(locale_path)
            install_cmd = self.get_finalized_command('install')
            build_base = install_cmd.build_base
            src = os.path.join(build_base, locales)
            dir_util.copy_tree(src, os.path.join(self.install_data, locales))

        file_util.copy_file(
            "LICENSE",
            os.path.join(self.install_data, 'share', 'bauble', 'LICENSE'))

 def run(self):
     subprocess.check_call(['patch', '-d', CHDKPTP_PATH, '-i',
                            CHDKPTP_PATCH, '-p', '1'])
     os.symlink(os.path.join(CHDKPTP_PATH, 'config-sample-linux.mk'),
                os.path.join(CHDKPTP_PATH, 'config.mk'))
     subprocess.check_call(['make', '-C', CHDKPTP_PATH])
     InstallCommand.run(self)

    def run(self):
        # Note(Kevin): On Python 2, Bajoo should uses the stable 'Classic'
        # version. This version must be installed manually by the user
        # (usually the package manager of the distribution).
        # On python 3, Bajoo uses the 'Phoenix' version of wxPython.
        # At this time, the Phoenix version is not stable yet, and only daily
        # snapshots are available.

        # About wxVersion:
        # Some systems allowed several version of wxPython to be installed
        # wxVersion allows to pick a version.
        # If wxVersion is not available, either wxPython is not installed,
        # either the system only allows only one version of wxPython.

        if not self.force and sys.version_info[0] is 2:
            try:
                import wxversion
                try:
                    wxversion.select(['3.0', '2.9', '2.8'])
                except wxversion.VersionError:
                    pass
            except ImportError:
                pass

            try:
                import wx  # noqa
            except ImportError:
                print("""\
Bajoo depends on the library wxPython. This library is not available in the
Python Package Index (pypi), and so can't be automatically installed.
On Linux, you can install it from your distribution's package repositories.
On Windows, you can download it from http://wxpython.org/download.php""")
                raise Exception('wxPython not found.')
        InstallCommand.run(self)

 def run(self):
     if not self.no_jars:
         import cmmnbuild_dep_manager
         mgr = cmmnbuild_dep_manager.Manager()
         mgr.install('pytimber')
         print('registered pytimber with cmmnbuild_dep_manager')
     _install.run(self)

 def run(self):
     install.run(self)
     try:
         # ignore failures since the tray icon is an optional component:
         call(['gtk-update-icon-cache', theme_base])
     except OSError:
         logging.warn(sys.exc_info()[1])

 def run(self):
     _install.run(self)
     try:
         import server_manager.client
         import server_manager.contrail
         client_dir = os.path.dirname(server_manager.client.__file__)
         json_files = client_dir+'/*.json'
         json_list = glob.glob(json_files)
         dst_location = '/etc/contrail_smgr'
         if not os.path.exists(dst_location):
             os.makedirs(dst_location)
         print ("Coping to %s") % (dst_location)
         for jfile in json_list:
             shutil.copy(jfile, dst_location)
             print jfile
         ini_files = client_dir+'/*.ini'
         ini_list = glob.glob(ini_files)
         for ifile in ini_list:
             shutil.copy(ifile, dst_location)
             print ifile
         contrail_dir = os.path.dirname(server_manager.contrail.__file__)
         xml_files = contrail_dir+'/*.xml'
         xml_list = glob.glob(xml_files)
         for xmlfile in xml_list:
             shutil.copy(xmlfile, dst_location)
             print xmlfile
     except:
         print "Post installation failed"

 def run(self):
     install.run(self)
     OS = system()
     if OS == 'Windows':
         call(["toxygen", "--configure"])
     elif OS == 'Linux':
         call(["toxygen", "--clean"])

 def run(self):
     install.run(self)
     try:
         import oil_library
     except ImportError:
         print "oil_library not found - installing it now \n"
         build_oil_lib("install")

 def run(self):
     # Perform a normal install.
     install.run(self)
     # Change permissions of the installed .py and .pyc files.
     for fileName in self.get_outputs():
         if fileName.endswith(('.py', '.pyc')):
             chmod(fileName, 420)  # 420 decimal = 644 octal

    def run(self):
        install.run(self)
        import sys

        # check about wxwidgets
        try:
            import wxversion

            wxversion.select("3.0")
        except:
            with open("install-wxpython.sh", "w") as shell_script:
                shell_script.write(
                    """#!/bin/sh
				echo 'Prerrequisites'
				apt-get --yes --force-yes install libgconf2-dev libgtk2.0-dev libgtk-3-dev mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libgconfmm-2.6-dev libwebkitgtk-dev python-gtk2
				mkdir -p external
				cd external
				echo "Downloading wxPython 3.0.2.0"
				wget http://downloads.sourceforge.net/project/wxpython/wxPython/3.0.2.0/wxPython-src-3.0.2.0.tar.bz2
				echo "Done"
				echo 'Uncompressing ...'
				tar -xjvf wxPython-src-3.0.2.0.tar.bz2
				echo 'Patching  ...'
				cd wxPython-src-3.0.2.0
				cd wxPython
				sed -i -e 's/PyErr_Format(PyExc_RuntimeError, mesg)/PyErr_Format(PyExc_RuntimeError, "%s\", mesg)/g' src/gtk/*.cpp contrib/gizmos/gtk/*.cpp
				python ./build-wxpython.py --build_dir=../bld --install
				ldconfig
				cd ../../..
				rm -rf external
			"""
                )
            os.system("sh ./install-wxpython.sh")

    def run(self):
        from distutils import log
        from os.path import abspath
        from os import chdir, getcwd
        self.distribution.run_command('build')
        current_cwd = getcwd()
        build_dir = join(dirname(abspath(__file__)), self.build_base)
        cmake = cmake_executable()
        pkg = abspath(self.install_lib)
        log.info("CMake: Installing package to %s" % pkg)
        try:
            chdir(build_dir)
            self.spawn([cmake,
                '-DPYTHON_PKG_DIR=\'%s\'' % pkg,
                '-DPYPACKED=TRUE',
                '..'
            ])
            self.spawn([cmake, '--build', '.', '--target', 'install'])
        finally: chdir(current_cwd)

        try:
            prior = getattr(self.distribution, 'running_binary', False)
            self.distribution.running_binary = True
            self.distribution.have_run['egg_info'] = 0
            dInstall.run(self)
        finally: self.distribution.running_binary = prior

  def run(self):
    # Update the defaults if needed.
    if self.config_file:
      with open("grr/defaults.py", "wb") as fd:
        fd.write(self.DEFAULT_TEMPLATE % dict(CONFIG_FILE=self.config_file))

    install.run(self)

 def run(self):
     if (not check_system_dependencies() or
         not check_version_dependencies() or
         not check_py_dependencies()):
         print 'Can not find all requires'
         #raise EnvironmentError
     _install.run(self)