Python setuptools.command.develop.develop.run() Examples

def run(self):
        from renku.core.commands.init import fetch_template, \
            read_template_manifest

        with TemporaryDirectory() as tempdir:
            # download and extract template data
            temppath = Path(tempdir)
            print('downloading Renku templates...')
            fetch_template(URL, REFERENCE, temppath)
            read_template_manifest(temppath, checkout=True)

            # copy templates
            current_path = Path.cwd()
            template_path = current_path / 'renku' / 'templates'
            if template_path.exists():
                shutil.rmtree(str(template_path))
            shutil.copytree(
                str(temppath),
                str(template_path),
                ignore=shutil.ignore_patterns('.git')
            ) 

def run(self):
        _clean.run(self)
        if os.path.exists('build'):
            shutil.rmtree('build')
        for dirpath, dirnames, filenames in os.walk('yatsm'):
            for filename in filenames:
                if any(filename.endswith(suffix) for suffix in
                       ('.c', '.so', '.pyd', '.pyc')):
                    os.unlink(os.path.join(dirpath, filename))
                    continue
                if (any(filename.endswith(suffix) for suffix in
                        ('.pkl', '.json')) and
                        os.path.basename(dirpath) == 'pickles'):
                    os.unlink(os.path.join(dirpath, filename))
            for dirname in dirnames:
                if dirname == '__pycache__':
                    shutil.rmtree(os.path.join(dirpath, dirname))


# Create pickles when building 

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

def run(self):
        os.system('sh install_meshrender.sh')
        develop.run(self) 

def run(self) -> None:
        develop.run(self)
        install_binaries() 

def run(self):
        main_path = os.path.expanduser("~/.gh-license")

        git_templates_path = "{}/git-templates".format(main_path)
        git_hooks_path = "{}/hooks".format(git_templates_path)

        config_path = "{}/config.ini".format(main_path)

        # copy the hooks folder in our git template folder
        shutil.copytree("setup/hooks", git_hooks_path)

        get_config_arguments = ["git", "config",
                                "--global", "init.templatedir"]

        if not os.path.exists(config_path):
            # save the current init.templatedir git config if the user already
            # had a value set for this
            try:
                current_config = subprocess.check_output(get_config_arguments)

                config = ConfigParser()

                config.read(config_path)
                config.add_section("main")
                config.set("main", "templatedir",
                           current_config.decode("utf-8"))

                with open(config_path, "w") as config_file:
                    config.write(config_file)
            except subprocess.CalledProcessError:
                pass  # don't create the config file

        # set our own git template path for the init.templatedir config
        set_config_arguments = get_config_arguments + [git_templates_path]

        subprocess.call(set_config_arguments)

        develop.run(self) 

def run(self) -> None:
        install.run(self)
        install_binaries() 

def post_install():
    subprocess.run(['python post-setup.py'], shell=True) 

def run(self):
        install_prerequisites()
        _develop.run(self) 

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

def run(self):
        os.system('sh install_meshrender.sh')
        install.run(self) 

def do_egg_install(self):
        install.run(self)
        post_install() 

def run(self):
        build.run(self)
        src = join(dirname(__file__), 'src', 'hunter.embed')
        path = join(dirname(__file__), 'src', 'hunter.pth')
        with open(src) as sh:
            with open(path, 'w') as fh:
                fh.write(
                    'import os, sys;'
                    'exec(%r)' % sh.read().replace('    ', ' ')
                )
        dest = join(self.build_lib, basename(path))
        self.copy_file(path, dest) 

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

def run(self):
        post_install.run(self)
        install.run(self) 

def run(self):
        # add in requirements for testing only when using the develop command
        self.distribution.install_requires.extend(["pytest", "pytest-cov"])
        STDevelopCmd.run(self) 

def run(self):
        egg_info.run(self)
        custom_command() 

def run(self):
        install_lib.run(self)
        path = join(dirname(__file__), 'src', 'hunter.pth')
        dest = join(self.install_dir, basename(path))
        self.copy_file(path, dest)
        self.outputs = [dest] 

def run(self):
        install.run(self)
        custom_command() 

def run(self):
        setup_mininet_dep()
        install.run(self) 

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

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

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

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

def run(self):
        _create_custom_modules_paths()
        install.run(self) 

def run(self):
        self.execute(_setup_other_arch, (), msg="Setting up AFL-other-arch")
        self.execute(_setup_cgc, (), msg="Setting up AFL-cgc")
        self.execute(_setup_libs, (), msg="Getting libraries")
        _datafiles()
        _develop.run(self) 

def run(self):
        self.execute(_setup_other_arch, (), msg="Setting up AFL-other-arch")
        self.execute(_setup_cgc, (), msg="Setting up AFL-cgc")
        self.execute(_setup_libs, (), msg="Getting libraries")
        _datafiles()
        _build.run(self) 

def run(self):
        spacy_download_en()
        _develop.run(self) 

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

def run(self):
        self.run_command('DownloadTemplates')
        _develop.run(self)