def downgrade_files(files): # Check and prepare 3to2 module. try: from lib3to2.main import main as lib3to2_main except ImportError: try: from pip import main as pipmain except: from pip._internal import main as pipmain pipmain(['install', '3to2']) from lib3to2.main import main as lib3to2_main if len(files) > 0: options = [ "-f", "all", # FIXME: It will trigger AssertionError: Sanity check failed: 0xFFFFFFFF # "-f", "int", "-f", "collections", "-f", "memoryview", "-f", "printfunction", "-f", "unittest", "-w", "-n", "--no-diffs", ] options += files lib3to2_main("lib3to2.fixes", options)
def upgrade(): package = 'rlbot' import importlib import os folder = os.path.dirname(os.path.realpath(__file__)) try: # https://stackoverflow.com/a/24773951 importlib.import_module(package) from rlbot.utils import public_utils, logging_utils logger = logging_utils.get_logger(DEFAULT_LOGGER) if not public_utils.have_internet(): logger.log(logging_utils.logging_level, 'Skipping upgrade check for now since it looks like you have no internet') elif public_utils.is_safe_to_upgrade(): # Upgrade only the rlbot-related stuff. rlbot_requirements = os.path.join(folder, 'rlbot-requirements.txt') pipmain(['install', '-r', rlbot_requirements, '--upgrade']) except (ImportError, ModuleNotFoundError): # First time installation, install lots of stuff all_requirements = os.path.join(folder, 'requirements.txt') pipmain(['install', '-r', all_requirements])
def cp_cmd(project_name, example, no_dependencies, with_docs, quiet): ''' Create an algorithm project. ''' if example: exmpl_path = os.path.join(this_path, 'examples', 'project') shutil.copytree(exmpl_path, project_name) path = os.path.abspath(project_name) generate_settings(this_path, path) if no_dependencies: click.echo('Skipping dependencies...') else: try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain reqs = os.path.join(exmpl_path, 'requirements.txt') pip_options = ['install', '-r', reqs] if quiet: pip_options += ['-q'] pipmain(pip_options) else: os.mkdir(project_name) path = os.path.abspath(project_name) create_file(project_name, this_path, path, 'licenses', '.json') create_file(project_name, this_path, path, 'config') create_file(project_name, this_path, path, '__init__') create_file(project_name, this_path, path, 'run') create_file('', this_path, path, 'gitignore', '.') generate_settings(this_path, path) os.mkdir(os.path.join(path, 'algorithms')) create_file(project_name, this_path, os.path.join(path, 'algorithms'), '__init__') os.mkdir(os.path.join(path, 'chains')) os.mkdir(os.path.join(path, 'logs')) logpath = os.path.join(path, 'logs') filename = os.path.join(logpath, 'app.log') with open(filename, 'a'): os.utime(filename, None) if with_docs: docs_path = os.path.join( os.path.abspath(os.path.join(this_path, os.pardir)), 'docs') dest_path = os.path.join(path, 'docs') if not os.path.exists(dest_path): os.mkdir(dest_path) cmd = 'sphinx-build ' + docs_path + ' ' + dest_path if quiet: cmd += ' -q' subprocess.call(cmd, shell=True) if not quiet: click.echo('Project created!')
def install_requirements(): """ Install non-colliding dependencies from a "requirements.txt" file found at the content root. """ reqfile = None if os.path.exists('deconst-requirements.txt'): reqfile = 'deconst-requirements.txt' elif os.path.exists('requirements.txt'): reqfile = 'requirements.txt' else: return dependencies = [] with open(reqfile, 'r', encoding='utf-8') as rf: for line in rf: if line.startswith('#'): continue stripped = line.strip() if not stripped: continue dependencies.append(stripped) print("Installing dependencies from {}: {}.".format( reqfile, ', '.join(dependencies))) pipmain(['install'] + dependencies)
def install_package(package_name): try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain pipmain(['install', package_name])
def main(): install_and_import('rlbot') from rlbot.utils import public_utils, logging_utils logger = logging_utils.get_logger(DEFAULT_LOGGER) if not public_utils.have_internet(): logger.log(logging_utils.logging_level, 'Skipping upgrade check for now since it looks like you have no internet') elif public_utils.is_safe_to_upgrade(): pipmain(['install', '-r', 'requirements.txt', '--upgrade', '--upgrade-strategy=eager']) try: import sys import os path = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, path) # this is for first process imports if len(sys.argv) > 1 and sys.argv[1] == 'gui': from rlbot.gui.qt_root import RLBotQTGui RLBotQTGui.main() else: from rlbot import runner runner.main() except Exception as e: print("Encountered exception: ", e) print("Press enter to close.") input()
def install(self): """ Install this package in the current env. We always specify the version, we cant be sure we are the latest one or that the user wants to install any other available. """ pkg_string = "%s==%s" % (self.name, self.version) pipmain(["install", "-q", pkg_string])
def installer(program): try: from pip import main as pipmain except: print("[*]Pip not installed") exit() pipmain(['install', program]) exit()
def install_package(package: str): """Installs a package that is normally only used by a test configuration. Arguments: package {str} -- Name of the PIP package. """ pipmain(["install", package])
def install_and_import(package): import importlib try: importlib.import_module(package) except ImportError: pipmain(['install', package]) finally: globals()[package] = importlib.import_module(package)
def install(self, package): # Debugging # pip.main(["install", "--pre", "--upgrade", "--no-index", # "--find-links=.", package, "--log-file", "log.txt", "-vv"]) pipmain([ "install", "--upgrade", "--no-index", "--find-links={}".format(self.package_repos), package ]) pass
def _pre_install(dir): from subprocess import check_call check_call(['./setup.sh'], shell=True, cwd=os.getcwd()) # Install local version of Jericho try: from pip import main as pipmain except: from pip._internal import main as pipmain pipmain(['install', os.path.join(os.getcwd(), "jericho")])
def install(module_name): from logging import warning try: try: from pip import main as pipmain except ImportError: from pip._internal.main import main as pipmain pipmain(['install', module_name]) except Exception as x: warning("caproto: %s" % x)
def checkPackages(): # If Windows NT extra_packages = { "nt" : ['pywin32', 'pywin32-ctypes', 'opencv-python', 'cmake', 'PyInstaller'], "linux" : ['opencv-python'], } for system in extra_packages: if system in os.name: for package in extra_packages[system]: if not package in sys.modules: pipmain(['install', package])
def use_pydgutils(): try: import pydgutils except: use_pip() try: from pip import main as pipmain except: from pip._internal import main as pipmain pipmain(["install", "pydgutils"])
def installer(program): print("Unable to import module %s. Would you like to install it?" % program) resp = input("(y/n) ") try: if str(resp.lower()) == 'y': from pip import main as pipmain pipmain(['install', program]) print("Install successful. Exiting") exit() except: print("Unable to install %s with pip3" % program) exit()
def install_and_import(package): import importlib try: importlib.import_module(package) except ImportError: try: from pip import main as pipmain except: from pip._internal import main as pipmain pipmain(['install', '--proxy=' + HTTPS_PROXY, package]) finally: globals()[package] = importlib.import_module(package)
def import_try_install(package, extern_url=None): """Try import the specified package. If the package not installed, try use pip to install and import if success. Parameters ---------- package : str The name of the package trying to import. extern_url : str or None, optional The external url if package is not hosted on PyPI. For example, you can install a package using: "pip install git+http://github.com/user/repo/tarball/master/egginfo=xxx". In this case, you can pass the url to the extern_url. Returns ------- <class 'Module'> The imported python module. """ import tempfile import portalocker lockfile = os.path.join(tempfile.gettempdir(), package + '_install.lck') with portalocker.Lock(lockfile): try: return __import__(package) except ImportError: try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain from types import ModuleType # fix for pip 19.3 if isinstance(pipmain, ModuleType): from pip._internal.main import main as pipmain # trying to install package url = package if extern_url is None else extern_url pipmain(['install', '--user', url]) # will raise SystemExit Error if fails # trying to load again try: return __import__(package) except ImportError: import sys import site user_site = site.getusersitepackages() if user_site not in sys.path: sys.path.append(user_site) return __import__(package) return __import__(package)
def install_package(package_name): ''' Installs package with pip Params: package_name - name of package which needs to be installed ''' #old versions of python compatibility try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain pipmain(['install', package_name])
def maybe_update(module_, required_version): def outdated(expected, actual): for num1, num2 in zip( *map(lambda v: v.split('.'), (expected, actual))): if int(num1) > int(num2): return True else: return False if outdated(required_version, module_.__version__): pipmain( ['install', '--upgrade', '--target', 'lib', module_.__package__]) importlib.reload(module_)
def local_install(package_name): Helpers.prepare_folders() pipmain(['install', 'setuptools']) pipmain(['install', 'wget']) tmp_folder_4_downloads = tempfile.mkdtemp() tmp_folder_4_extracted = tempfile.mkdtemp() apt_output = subprocess.check_output('apt-get --print-uris --yes -d --reinstall --no-install-recommends install '+package_name, shell=True) package_links = re.findall(r'http:\/\/[\w\d\.\-\/]+\.deb', str(apt_output)) for link in package_links: print(f"Getting {link}...") package_filename = os.path.basename(urlparse(link).path) target_path = os.path.join(tmp_folder_4_downloads, package_filename) wget.download(link, target_path) apt_inst.deb_extract_archive(target_path, tmp_folder_4_extracted)
def intellImport(package): if hasattr(package, "__len__") and (not isinstance(package, str)): package = list(package) for each in package: try: __import__(each) except ImportError: pipmain(['install', each]) __import__(each) else: try: __import__(package) except ImportError: pipmain(['install', package]) __import__(package)
def checkPackages(): # If Linux extra_packages = { "linux-apt": ['build-essential', 'cmake', 'libopenblas-dev', 'liblapack-dev', 'libx11-dev', 'libgtk-3-dev'], "linux": ['dlib'], } for system in extra_packages: if os.name in system: if '-apt' in system: for package in extra_packages[system]: if not package in sys.modules: subprocess.run('apt install {p}'.format(p=package)) else: for package in extra_packages[system]: if not package in sys.modules: pipmain(['install', package])
def update_reqs(): print( "Updating requirements. This may take a while on first-time installs.." ) try: try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain pipmain( ['install', '--upgrade', '-r', path.join(dr, 'requirements.txt')]) print('\n' * 10) os.system('cls' if os.name == 'nt' else 'clear') except Exception as ex: print(ex)
def downloadModules (localFolder): reqFile = getPropertiesFile() if not reqFile: return if not os.path.isdir(localFolder): print ("path %s is not local folder to download PIP packages.. " %localFolder) return if not internet_on(): print ("MUST HAVE INTERENET CONNECTION TO START DOWNLOAD ! ") return print ("DOWNLOADING ....") pipmain(['download', '-r', reqFile, '-d', localFolder])
def __install_plugin_deps(self): ret = pipmain(["install"] + self.__plugin_deps) if ret is not 0: self.__error_exit("Unable to install plugin dependencies.") return False return True
def install_pip(): retries = RETRIES while retries > 0: ret = pipmain(['install', 'dvc']) if ret == 0: break retries -= 1 assert ret == 0
def installModule (localFolder=None): reqFile = getPropertiesFile () if not reqFile: return if not localFolder and internet_on(): print ("Dowloading PIP packages from the web") pipmain(['install', '-r', reqFile]) elif localFolder: if os.path.isdir(localFolder): pipmain(['install', '-r', reqFile, '--no-index', '--find-links', 'file:'+localFolder]) else: print ('%s IS NOT FOLDER !!', localFolder) else: print ("NO INTERNET CONNECTION OR NO VALID LOCAL FOLDER ")
def install_and_import(package): """Import a given package after installing it when needed. Args: package (str): The name of the package to be imported.""" import importlib try: importlib.import_module(package) except ImportError: checkPipInstalled() try: from pip import main as pipmain except: from pip._internal import main as pipmain pipmain(['install', package]) finally: globals()[package] = importlib.import_module(package)
def call_pip(packageName, target, packageVersion=None): package = packageName if not packageVersion else "{}=={}".format( packageName, packageVersion) rc = pipmain([ "install", package, '--no-cache-dir', '--disable-pip-version-check', '--upgrade', '--quiet', '--target', target ]) if rc != 0: raise Exception('pip.main returned ' + str(rc))
def run(self): install.run(self) if sys.platform == 'darwin': pipmain(['install', mac_url]) elif sys.platform.startswith('linux'): if sys.version_info.minor == 4: pipmain(['install', linux_py4_url]) elif sys.version_info.minor == 5: pipmain(['install', linux_py5_url]) elif sys.version_info.minor == 6: pipmain(['install', linux_py6_url])
def install_reqs(only_verbose=False): import pip try: from pip import main as pipmain except: from pip._internal import main as pipmain # if utils.is_windows() and not utils.is_admin(): # utils.set_admin() pipmain(['install', '--upgrade', 'pip']) retcode = 0 reqs_fname = op.join(utils.get_parent_fol(levels=2), 'requirements.txt') with open(reqs_fname, 'r') as f: for line in f: if only_verbose: print('Trying to install {}'.format(line.strip())) else: pipcode = pipmain(['install', '--upgrade', line.strip()]) retcode = retcode or pipcode return retcode
def import_try_install(package, extern_url=None): """Try import the specified package. If the package not installed, try use pip to install and import if success. Parameters ---------- package : str The name of the package trying to import. extern_url : str or None, optional The external url if package is not hosted on PyPI. For example, you can install a package using: "pip install git+http://github.com/user/repo/tarball/master/egginfo=xxx". In this case, you can pass the url to the extern_url. Returns ------- <class 'Module'> The imported python module. """ try: return __import__(package) except ImportError: try: from pip import main as pipmain except ImportError: from pip._internal import main as pipmain # trying to install package url = package if extern_url is None else extern_url pipmain(['install', '--user', url]) # will raise SystemExit Error if fails # trying to load again try: return __import__(package) except ImportError: import sys import site user_site = site.getusersitepackages() if user_site not in sys.path: sys.path.append(user_site) return __import__(package) return __import__(package)
def update(): logging.debug('def restart') del sys.argv[1:] time.sleep(2) logging.info('Git pull nzbtomedia & premiumizer') subprocess.call(['git', '-C', os.path.join(rootdir, 'nzbtomedia'), 'pull']) subprocess.call(['git', '-C', rootdir, 'pull']) prem_config = configparser.ConfigParser() default_config = configparser.ConfigParser() prem_config.read(os.path.join(ConfDir, 'settings.cfg')) default_config.read(os.path.join(runningdir, 'settings.cfg.tpl')) prem_config.set('update', 'updated', '1') with open(os.path.join(ConfDir, 'settings.cfg'), 'w') as configfile: prem_config.write(configfile) if prem_config.getfloat('update', 'req_version') < default_config.getfloat('update', 'req_version'): logging.info('updating pip requirements') pipmain(['install', '-r', os.path.join(rootdir, 'requirements.txt')]) prem_config.set('update', 'req_version', str(default_config.getfloat('update', 'req_version'))) with open(os.path.join(ConfDir, 'settings.cfg'), 'w') as configfile: prem_config.write(configfile) if prem_config.getfloat('update', 'config_version') < default_config.getfloat('update', 'config_version'): logging.info('updating config file') import shutil shutil.copy(os.path.join(ConfDir, 'settings.cfg'), os.path.join(ConfDir, 'settings.cfg.old')) shutil.copy(os.path.join(runningdir, 'settings.cfg.tpl'), os.path.join(ConfDir, 'settings.cfg')) prem_config.read(os.path.join(ConfDir, 'settings.cfg.old')) default_config.read(os.path.join(ConfDir, 'settings.cfg')) for section in prem_config.sections(): if section in default_config.sections() and section != 'update': for key in prem_config.options(section): if key in default_config.options(section): default_config.set(section, key, (prem_config.get(section, key))) with open(os.path.join(ConfDir, 'settings.cfg'), 'w') as configfile: default_config.write(configfile) if os_arg == '--windows': pass else: time.sleep(3) exec(compile(open(os.path.join(runningdir, 'premiumizer.py'), "rb").read(), os.path.join(runningdir, 'premiumizer.py'), 'exec'), globals(), globals())
def reinstall(self): pipmain(["install", "-q", "--force-reinstall", self.name]) self.emit(SIGNAL("pluginInstalled(PyQt_PyObject)"), self)
except ImportError: from pip._internal import main as pipmain DEFAULT_LOGGER = 'rlbot' if __name__ == '__main__': try: from rlbot.utils import public_utils, logging_utils logger = logging_utils.get_logger(DEFAULT_LOGGER) if not public_utils.have_internet(): logger.log(logging_utils.logging_level, 'Skipping upgrade check for now since it looks like you have no internet') elif public_utils.is_safe_to_upgrade(): pipmain(['install', '-r', 'requirements.txt', '--upgrade', '--upgrade-strategy=eager']) # https://stackoverflow.com/a/44401013 rlbots = [module for module in sys.modules if module.startswith('rlbot')] for rlbot_module in rlbots: sys.modules.pop(rlbot_module) except ImportError: pipmain(['install', '-r', 'requirements.txt', '--upgrade', '--upgrade-strategy=eager']) try: if len(sys.argv) > 1 and sys.argv[1] == 'gui': from rlbot.gui.qt_root import RLBotQTGui RLBotQTGui.main() else:
def reinstall(self): pipmain(["install", "-q", "--force-reinstall", self.name]) self.pluginInstalled.emit(self)
def upgrade(self): pipmain(["install", "-q", "--ugprade", self.name]) self.pluginInstalled.emit(self)
def upgrade(self): pipmain(["install", "-q", "--ugprade", self.name]) self.emit(SIGNAL("pluginInstalled(PyQt_PyObject)"), self)
def uninstall(package: str) -> int: """Uninstall a PIP package""" return pipmain([r'uninstall', package])
""" import sys import os import unittest import qgis # NOQA For SIP API to V2 if run outside of QGIS try: from pip import main as pipmain except: from pip._internal import main as pipmain try: import coverage except ImportError: pipmain(['install', 'coverage']) import coverage import tempfile from osgeo import gdal from qgis.PyQt import Qt from safe.utilities.gis import qgis_version __author__ = 'etiennetrimaille' __revision__ = 'bd00bfeac510722b427544b186bfa10861749e51' __date__ = '14/06/2016' __copyright__ = ( 'Copyright 2012, Australia Indonesia Facility for Disaster Reduction') def _run_tests(test_suite, package_name, with_coverage=False): """Core function to test a test suite."""
def remove(self): pipmain(["uninstall", "-q", "-y", self.name])
def install(package: str) -> int: """Install PIP package""" return pipmain([r'install', package])