def __init__(self): from poetry.config import Config super(ConfigCommand, self).__init__() self._config = Config.create("config.toml") self._auth_config = Config.create("auth.toml")
def __init__(self): from poetry.config import Config super().__init__() self._config = Config.create('config.toml') self._auth_config = Config.create('auth.toml')
def __init__(self, name, url, disable_cache=False): if name == "pypi": raise ValueError("The name [pypi] is reserved for repositories") self._packages = [] self._name = name self._url = url.rstrip("/") self._cache_dir = Path(CACHE_DIR) / "cache" / "repositories" / name self._cache = CacheManager( { "default": "releases", "serializer": "json", "stores": { "releases": {"driver": "file", "path": str(self._cache_dir)}, "packages": {"driver": "dict"}, "matches": {"driver": "dict"}, }, } ) self._session = CacheControl( requests.session(), cache=FileCache(str(self._cache_dir / "_http")) ) url_parts = urlparse.urlparse(self._url) if not url_parts.username: self._session.auth = get_http_basic_auth( Config.create("auth.toml"), self.name ) self._disable_cache = disable_cache
def test_list_displays_set_get_setting(app, config): command = app.find("config") command._settings_config = Config(config.file) tester = CommandTester(command) tester.execute("settings.virtualenvs.create false") command._settings_config = Config(config.file) tester.execute("--list") expected = """settings.virtualenvs.create = false settings.virtualenvs.in-project = false settings.virtualenvs.path = "." repositories = {} """ assert expected == tester.io.fetch_output()
def test_display_single_setting(app, config): command = app.find("config") command._settings_config = Config(config.file) tester = CommandTester(command) tester.execute("settings.virtualenvs.create") expected = """true """ assert expected == tester.io.fetch_output()
def test_list_displays_set_get_setting(app, config): command = app.find("config") command._config = Config(config.file) tester = CommandTester(command) tester.execute([ ("command", command.get_name()), ("key", "settings.virtualenvs.create"), ("value", ["false"]), ]) command._config = Config(config.file) tester.execute([("command", command.get_name()), ("--list", True)]) expected = """settings.virtualenvs.create = false settings.virtualenvs.in-project = false settings.virtualenvs.path = "." repositories = {} """ assert tester.get_display(True) == expected
def test_display_single_setting(app, config): command = app.find("config") command._config = Config(config.file) tester = CommandTester(command) tester.execute([("command", command.get_name()), ("key", "settings.virtualenvs.create")]) expected = """true """ assert tester.get_display(True) == expected
def get(cls, reload=False, cwd=None): # type: (IO, bool) -> Env if cls._env is not None and not reload: return cls._env # Check if we are inside a virtualenv or not in_venv = (os.environ.get("VIRTUAL_ENV") is not None or hasattr(sys, "real_prefix") or (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)) if not in_venv: # Checking if a local virtualenv exists if cwd and (cwd / ".venv").exists(): venv = cwd / ".venv" return VirtualEnv(Path(venv)) config = Config.create("config.toml") create_venv = config.setting("settings.virtualenvs.create", True) if not create_venv: return SystemEnv(Path(sys.prefix)) venv_path = config.setting("settings.virtualenvs.path") if venv_path is None: venv_path = Path(CACHE_DIR) / "virtualenvs" else: venv_path = Path(venv_path) if cwd is None: cwd = Path.cwd() name = cwd.name name = "{}-py{}".format( name, ".".join([str(v) for v in sys.version_info[:2]])) venv = venv_path / name if not venv.exists(): return SystemEnv(Path(sys.prefix)) return VirtualEnv(venv) if os.environ.get("VIRTUAL_ENV") is not None: prefix = Path(os.environ["VIRTUAL_ENV"]) base_prefix = None else: prefix = Path(sys.prefix) base_prefix = cls.get_base_prefix() return VirtualEnv(prefix, base_prefix)
def get(cls, cwd, reload=False): # type: (Path, bool) -> Env if cls._env is not None and not reload: return cls._env # Check if we are inside a virtualenv or not in_venv = os.environ.get("VIRTUAL_ENV") is not None if not in_venv: config = Config.create("config.toml") # Checking if a local virtualenv exists venv_name = config.setting("settings.virtualenvs.name", ".venv") if (cwd / venv_name).exists(): venv = cwd / venv_name return VirtualEnv(venv) create_venv = config.setting("settings.virtualenvs.create", True) if not create_venv: return SystemEnv(Path(sys.prefix)) venv_path = config.setting("settings.virtualenvs.path") if venv_path is None: venv_path = Path(CACHE_DIR) / "virtualenvs" else: venv_path = Path(venv_path) name = cwd.name name = "{}-py{}".format( name, ".".join([str(v) for v in sys.version_info[:2]])) venv = venv_path / name if not venv.exists(): return SystemEnv(Path(sys.prefix)) return VirtualEnv(venv) if os.environ.get("VIRTUAL_ENV") is not None: prefix = Path(os.environ["VIRTUAL_ENV"]) base_prefix = None else: prefix = Path(sys.prefix) base_prefix = cls.get_base_prefix() return VirtualEnv(prefix, base_prefix)
def create(cls, io, name=None, cwd=None): # type: (...) -> Venv if "VIRTUAL_ENV" not in os.environ: # Not in a virtualenv # Checking if we need to create one # First we check if there is a .venv # at the root of the project. if cwd and (cwd / ".venv").exists(): venv = cwd / ".venv" else: config = Config.create("config.toml") create_venv = config.setting("settings.virtualenvs.create") root_venv = config.setting("settings.virtualenvs.in-project") venv_path = config.setting("settings.virtualenvs.path") if root_venv: if not cwd: raise RuntimeError( "Unable to determine the project's directory" ) venv_path = cwd / ".venv" elif venv_path is None: venv_path = Path(CACHE_DIR) / "virtualenvs" else: venv_path = Path(venv_path) if not name: name = Path.cwd().name name = "{}-py{}".format( name, ".".join([str(v) for v in sys.version_info[:2]]) ) if root_venv: venv = venv_path else: venv = venv_path / name if not venv.exists(): if create_venv is False: io.writeln( "<fg=black;bg=yellow>" "Skipping virtualenv creation, " "as specified in config file." "</>" ) return cls() io.writeln( "Creating virtualenv <info>{}</> in {}".format( name, str(venv_path) ) ) cls.build(str(venv)) else: if io.is_very_verbose(): io.writeln( "Virtualenv <info>{}</> already exists.".format(name) ) os.environ["VIRTUAL_ENV"] = str(venv) # venv detection: # stdlib venv may symlink sys.executable, so we can't use realpath. # but others can symlink *to* the venv Python, # so we can't just use sys.executable. # So we just check every item in the symlink tree (generally <= 3) p = os.path.normcase(sys.executable) paths = [p] while os.path.islink(p): p = os.path.normcase(os.path.join(os.path.dirname(p), os.readlink(p))) paths.append(p) p_venv = os.path.normcase(os.environ["VIRTUAL_ENV"]) if any(p.startswith(p_venv) for p in paths): # Running properly in the virtualenv, don't need to do anything return cls() venv = os.environ["VIRTUAL_ENV"] return cls(venv)
def __init__(self): super().__init__() self._config = Config.create('config.toml') self._auth_config = Config.create('auth.toml')
def get_http_basic_auth(repository_name): # type: (str) -> tuple config = Config.create("auth.toml") repo_auth = config.setting("http-basic.{}".format(repository_name)) if repo_auth: return repo_auth["username"], repo_auth["password"] return None
def __init__(self, config=None): # type: (Config) -> None if config is None: config = Config.create("config.toml") self._config = config
def create_venv(cls, cwd, io, name=None): # type: (Path, IO, bool) -> Env if cls._env is not None: return cls._env env = cls.get(cwd) if env.is_venv(): # Already inside a virtualenv. return env config = Config.create("config.toml") create_venv = config.setting("settings.virtualenvs.create") root_venv = config.setting("settings.virtualenvs.in-project") venv_path = config.setting("settings.virtualenvs.path") if root_venv: venv_path = cwd / ".venv" elif venv_path is None: venv_path = Path(CACHE_DIR) / "virtualenvs" else: venv_path = Path(venv_path) if not name: name = cwd.name name = "{}-py{}".format( name, ".".join([str(v) for v in sys.version_info[:2]])) if root_venv: venv = venv_path else: venv = venv_path / name if not venv.exists(): if create_venv is False: io.writeln("<fg=black;bg=yellow>" "Skipping virtualenv creation, " "as specified in config file." "</>") return SystemEnv(Path(sys.prefix)) io.writeln("Creating virtualenv <info>{}</> in {}".format( name, str(venv_path))) cls.build_venv(str(venv)) else: if io.is_very_verbose(): io.writeln( "Virtualenv <info>{}</> already exists.".format(name)) # venv detection: # stdlib venv may symlink sys.executable, so we can't use realpath. # but others can symlink *to* the venv Python, # so we can't just use sys.executable. # So we just check every item in the symlink tree (generally <= 3) p = os.path.normcase(sys.executable) paths = [p] while os.path.islink(p): p = os.path.normcase( os.path.join(os.path.dirname(p), os.readlink(p))) paths.append(p) p_venv = os.path.normcase(str(venv)) if any(p.startswith(p_venv) for p in paths): # Running properly in the virtualenv, don't need to do anything return SystemEnv(Path(sys.prefix), cls.get_base_prefix()) return VirtualEnv(venv)
def install(self, package, update=False): if package.source_type == "directory": self.install_directory(package, update=update) return if package.source_type == "git": self.install_git(package) return args = ["install", "--no-deps"] if package.source_type == "legacy" and package.source_url: parsed = urlparse.urlparse(package.source_url) if parsed.scheme == "http": self._io.write_error( " <warning>Installing from unsecure host: {}</warning>". format(parsed.hostname)) args += ["--trusted-host", parsed.hostname] auth = get_http_basic_auth(Config.create("auth.toml"), package.source_reference) if auth: index_url = "{scheme}://{username}:{password}@{netloc}{path}".format( scheme=parsed.scheme, username=auth[0], password=auth[1], netloc=parsed.netloc, path=parsed.path, ) else: index_url = package.source_url args += ["--index-url", index_url] if update: args.append("-U") if package.hashes and not package.source_type: # Format as a requirements.txt # We need to create a requirements.txt file # for each package in order to check hashes. # This is far from optimal but we do not have any # other choice since this is the only way for pip # to verify hashes. req = self.create_temporary_requirement(package) args += ["-r", req] try: self.run(*args) finally: os.unlink(req) else: req = self.requirement(package) if not isinstance(req, list): args.append(req) else: args += req self.run(*args)
def create(cls, io, name=None, cwd=None): # type: (...) -> Venv if 'VIRTUAL_ENV' not in os.environ: # Not in a virtualenv # Checking if we need to create one # First we check if there is a .venv # at the root of the project. if cwd and (cwd / '.venv').exists(): venv = cwd / '.venv' else: config = Config.create('config.toml') create_venv = config.setting('settings.virtualenvs.create') root_venv = config.setting('settings.virtualenvs.in-project') venv_path = config.setting('settings.virtualenvs.path') if root_venv: if not cwd: raise RuntimeError('Unbale to determine the project\'s directory') venv_path = (cwd / '.venv') elif venv_path is None: venv_path = Path(CACHE_DIR) / 'virtualenvs' else: venv_path = Path(venv_path) if not name: name = Path.cwd().name name = '{}-py{}'.format( name, '.'.join([str(v) for v in sys.version_info[:2]]) ) if root_venv: venv = venv_path else: venv = venv_path / name if not venv.exists(): if create_venv is False: io.writeln( '<fg=black;bg=yellow>' 'Skipping virtualenv creation, ' 'as specified in config file.' '</>' ) return cls() io.writeln( 'Creating virtualenv <info>{}</> in {}'.format( name, str(venv_path) ) ) cls.build(str(venv)) else: if io.is_very_verbose(): io.writeln( 'Virtualenv <info>{}</> already exists.'.format(name) ) os.environ['VIRTUAL_ENV'] = str(venv) # venv detection: # stdlib venv may symlink sys.executable, so we can't use realpath. # but others can symlink *to* the venv Python, # so we can't just use sys.executable. # So we just check every item in the symlink tree (generally <= 3) p = os.path.normcase(sys.executable) paths = [p] while os.path.islink(p): p = os.path.normcase( os.path.join(os.path.dirname(p), os.readlink(p))) paths.append(p) p_venv = os.path.normcase(os.environ['VIRTUAL_ENV']) if any(p.startswith(p_venv) for p in paths): # Running properly in the virtualenv, don't need to do anything return cls() venv = os.environ['VIRTUAL_ENV'] return cls(venv)
def config(): # type: () -> Config with tempfile.NamedTemporaryFile() as f: f.close() return Config(TomlFile(f.name))
def create(cls, io, name=None) -> 'Venv': if 'VIRTUAL_ENV' not in os.environ: # Not in a virtualenv # Checking if we need to create one config = Config.create('config.toml') create_venv = config.setting('settings.virtualenvs.create') venv_path = config.setting('settings.virtualenvs.path') if venv_path is None: venv_path = Path(CACHE_DIR) / 'virtualenvs' else: venv_path = Path(venv_path) if not name: name = Path.cwd().name name = f'{name}-py{".".join([str(v) for v in sys.version_info[:2]])}' venv = venv_path / name if not venv.exists(): if create_venv is False: io.writeln( '<fg=black;bg=yellow>' 'Skipping virtualenv creation, ' 'as specified in config file.' '</>' ) return cls() io.writeln( f'Creating virtualenv <info>{name}</> in {str(venv_path)}' ) builder = EnvBuilder(with_pip=True) builder.create(str(venv)) else: if io.is_very_verbose(): io.writeln(f'Virtualenv <info>{name}</> already exists.') os.environ['VIRTUAL_ENV'] = str(venv) # venv detection: # stdlib venv may symlink sys.executable, so we can't use realpath. # but others can symlink *to* the venv Python, # so we can't just use sys.executable. # So we just check every item in the symlink tree (generally <= 3) p = os.path.normcase(sys.executable) paths = [p] while os.path.islink(p): p = os.path.normcase( os.path.join(os.path.dirname(p), os.readlink(p))) paths.append(p) p_venv = os.path.normcase(os.environ['VIRTUAL_ENV']) if any(p.startswith(p_venv) for p in paths): # Running properly in the virtualenv, don't need to do anything return cls() venv = os.environ['VIRTUAL_ENV'] return cls(venv)