def run(self):
     clean_tables()
     build_tables()
     dirty = dirty_version()
     develop.run(self)
     if dirty:
         discard_changes()

        def run(self):
            if IS_WINDOWS_PLATFORM:
                if __saltstack_version__.info < (2015, 8):  # pylint: disable=undefined-variable
                    # Install M2Crypto first
                    self.distribution.salt_installing_m2crypto_windows = True
                    self.run_command('install-m2crypto-windows')
                    self.distribution.salt_installing_m2crypto_windows = None

                # Install PyCrypto
                self.distribution.salt_installing_pycrypto_windows = True
                self.run_command('install-pycrypto-windows')
                self.distribution.salt_installing_pycrypto_windows = None

                # Download the required DLLs
                self.distribution.salt_download_windows_dlls = True
                self.run_command('download-windows-dlls')
                self.distribution.salt_download_windows_dlls = None

            if self.write_salt_version is True:
                self.distribution.running_salt_install = True
                self.distribution.salt_version_hardcoded_path = SALT_VERSION_HARDCODED
                self.run_command('write_salt_version')

            if self.generate_salt_syspaths:
                self.distribution.salt_syspaths_hardcoded_path = SALT_SYSPATHS_HARDCODED
                self.run_command('generate_salt_syspaths')

            # Resume normal execution
            develop.run(self)

 def run(self, *args, **kwargs):
     print "MODIFIED RUN: %s" % self.__class__
     if self.minimal:
         self.distribution.install_requires = parse_requirements(["minimal-requirements.txt"])
         print "SELF.MINIMAL"
     print "install requires: %s" % (self.distribution.install_requires)
     develop_command.run(self, *args, **kwargs)

 def run(self):
     # versioneer:
     versions = versioneer.get_versions(verbose=True)
     self._versioneer_generated_versions = versions
     # unless we update this, the command will keep using the old version
     self.distribution.metadata.version = versions["version"]
     _cmd_develop.run(self)

 def run(self):
     try:
         from enaml.core.parser import write_tables
         write_tables()
     except ImportError:
         pass
     develop.run(self)

    def run(self):
        develop.run(self)

        if self.uninstall:
            package_path = find_package_path("pyaudio_wrapper")
            if package_path is not None:
                print("[Info] Detecting import hook in easy-install.pth")
                print("[Info] Clean import hook.")

                pth = os.path.join(os.path.dirname(easy_install.__file__), 'easy-install.pth')

                try:
                    pth_file = open(pth, "r")
                    lines = pth_file.readlines()
                    pth_file.close()
                    to_write = []
                    for line in lines:
                        if not 'pyaudio_wrapper' in line:
                            to_write.append(line)
                    pth_file = open(pth, "w")
                    pth_file.write(''.join(to_write))
                    pth_file.close()
                except Exception as e:
                    print(e)
                    print("[Error] Cannot clean the import hook.")
                    sys.exit(1)

 def run(self):
     develop.run(self)
     try:
         self.run_command('build_docs')
     except:
         log.warn("Couldn't build documentation:\n%s" %
                  traceback.format_exception(*sys.exc_info()))

    def run(self):
        if not self.dry_run:
            target_dir = os.path.join(self.setup_path, MODEL_TARGET_DIR)
            self.mkpath(target_dir)
            build_stan_model(target_dir)

        develop.run(self)

 def run(self):
     # add in requirements for testing only when using the develop command
     self.distribution.install_requires.extend([
         'mock',
         'nose',
     ])
     STDevelopCmd.run(self)

    def run(self):
        develop.run(self)

        # Install the dev requirements
        print('>>> Install dev requirements')
        self.spawn('pip install --upgrade --requirement requirements-dev.txt'.split(' '))
        print('<<< Instell dev requirements')

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

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

    # Create symbolic link
    try:
        os.symlink(self.app_package_dir, destination_dir)

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

        os.symlink(self.app_package_dir, destination_dir)

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

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

 def run(self):
     if not skip_npm:
         if not which('node'):
             log.error('Please install nodejs and npm before continuing installation. nodejs may be installed using conda or directly from the nodejs website.')
             return
         run(npm, cwd=HERE)
     develop.run(self)

 def run(self):
     clean_tables()
     build_tables()
     dirty = dirty_version()
     develop.run(self)
     if dirty:
         restore_version()

 def run(self):
     log.debug('_develop run')
     develop.run(self)
     # move lib files into gippy directory
     [shutil.move(f, 'gippy/') for f in glob.glob('*.so')]
     if sysconfig.get_config_var('SOABI') is not None:
         # rename libgip if Python 3.2+
         os.rename(gip_module._file_name, 'gippy/libgip.so')

    def run(self):
        """
        Execute command pip for development requirements.
        """

        assert os.getenv('VIRTUAL_ENV'), 'You should be in a virtualenv!'
        develop.run(self)
        self.spawn(('pip', 'install', '--upgrade', '--requirement', 'requirements-dev.txt'))

    def run(self):
        level = logging.getLevelName("INFO")
        logging.basicConfig(level=level,
            format='%(levelname)-8s : %(message)s')

        _develop.run(self)
        install_requirements(self.user)
        _post_install(self)

    def run(self):
        """ Overwriting the existing command.
        """
        os.chdir('respy')

        os.system('./waf distclean; ./waf configure build')

        os.chdir('../')

        develop.run(self)

    def run(self):
        if not skip_npm:
            if not which('node'):
                error_message = """
Please install nodejs and npm before continuing installation.
nodejs may be installed using conda or directly from: https://nodejs.org/
"""
                log.error(error_message)
                return
            run(npm, cwd=HERE)
        develop.run(self)

        def run(self):

            subprocess.check_call(['make', '-C', 'external/samtools'])
            subprocess.check_call(['./configure'], cwd='external/samtools/htslib-1.2.1')
            subprocess.check_call(['make'], cwd='external/samtools/htslib-1.2.1')
            
            develop.run(self)
            import shutil
            shutil.copy2('external/samtools/samtools', 'transvar/')
            shutil.copy2('external/samtools/htslib-1.2.1/tabix', 'transvar/')
            shutil.copy2('external/samtools/htslib-1.2.1/bgzip', 'transvar/')

 def run(self):
     _develop.run(self)
     install_nbextension(
         extension_dir,
         symlink=True,
         overwrite=True,
         user=False,
         sys_prefix=True,  # to install it inside virtualenv
         destination="robomission")
     cm = ConfigManager()
     cm.update('notebook', {"load_extensions": {"robomission/index": True } })