def is_using_legacy_client() -> bool: from poetry.config.config import Config legacy_client: bool = ( Config.create().get("experimental", {}).get("system-git-client", False) ) return legacy_client
def _update(self, version: Version) -> None: from poetry.core.packages.dependency import Dependency from poetry.core.packages.project_package import ProjectPackage from poetry.config.config import Config from poetry.installation.installer import Installer from poetry.packages.locker import NullLocker from poetry.repositories.installed_repository import InstalledRepository from poetry.utils.env import EnvManager env = EnvManager.get_system_env(naive=True) installed = InstalledRepository.load(env) root = ProjectPackage("poetry-updater", "0.0.0") root.python_versions = ".".join(str(c) for c in env.version_info[:3]) root.add_dependency(Dependency("poetry", version.text)) installer = Installer( self.io, env, root, NullLocker(self.data_dir.joinpath("poetry.lock"), {}), self.pool, config=Config.create(), installed=installed, ) installer.update(True) installer.dry_run(self.option("dry-run")) installer.run()
def create_config(cls, io: IO | None = None) -> Config: if io is not None: logger.debug("Ignoring provided io when creating config.") warnings.warn( "Use of Factory.create_config() is deprecated, use Config.create() instead", DeprecationWarning, ) return Config.create()
def __init__(self, pool: Pool, env: Env, config: Config | None = None) -> None: self._pool = pool self._env = env self._config = config or Config.create() self._no_binary_policy: PackageFilterPolicy = PackageFilterPolicy( self._config.get("installer.no-binary", []))
def handle(self) -> int: config = Config.create() if config.repository_cache_directory.exists(): caches = sorted(config.repository_cache_directory.iterdir()) if caches: for cache in caches: self.line(f"<info>{cache.name}</>") return 0 self.line_error("<warning>No caches found</>") return 0
def create(cls, repository: str, config: Config | None) -> RepositoryCertificateConfig: config = config if config else Config.create() verify: str | bool = config.get( f"certificates.{repository}.verify", config.get(f"certificates.{repository}.cert", True), ) client_cert: str = config.get(f"certificates.{repository}.client-cert") return cls( cert=Path(verify) if isinstance(verify, str) else None, client_cert=Path(client_cert) if client_cert else None, verify=verify if isinstance(verify, bool) else True, )
def __init__( self, config: Config | None = None, io: IO | None = None, cache_id: str | None = None, disable_cache: bool = False, ) -> None: self._config = config or Config.create() self._io = io self._sessions_for_netloc: dict[str, requests.Session] = {} self._credentials: dict[str, HTTPAuthCredential] = {} self._certs: dict[str, dict[str, Path | None]] = {} self._configured_repositories: dict[ str, AuthenticatorRepositoryConfig] | None = None self._password_manager = PasswordManager(self._config) self._cache_control = (FileCache( str(REPOSITORY_CACHE_DIR / (cache_id or "_default_cache") / "_http")) if not disable_cache else None)
def mock_clone( url: str, *_: Any, source_root: Path | None = None, **__: Any, ) -> MockDulwichRepo: # Checking source to determine which folder we need to copy parsed = ParsedUrl.parse(url) path = re.sub(r"(.git)?$", "", parsed.pathname.lstrip("/")) folder = Path(__file__).parent / "fixtures" / "git" / parsed.resource / path if not source_root: source_root = Path(Config.create().get("cache-dir")) / "src" dest = source_root / path dest.parent.mkdir(parents=True, exist_ok=True) copy_or_symlink(folder, dest) return MockDulwichRepo(dest)
def __init__( self, config: Config | None = None, io: IO | None = None, cache_id: str | None = None, disable_cache: bool = False, ) -> None: self._config = config or Config.create() self._io = io self._sessions_for_netloc: dict[str, requests.Session] = {} self._credentials: dict[str, HTTPAuthCredential] = {} self._certs: dict[str, RepositoryCertificateConfig] = {} self._configured_repositories: dict[ str, AuthenticatorRepositoryConfig] | None = None self._password_manager = PasswordManager(self._config) self._cache_control = (FileCache( str(self._config.repository_cache_directory / (cache_id or "_default_cache") / "_http")) if not disable_cache else None) self.get_repository_config_for_url = functools.lru_cache(maxsize=None)( self._get_repository_config_for_url)
def __init__(self, name: str, disable_cache: bool = False, config: Config | None = None) -> None: super().__init__(name) self._disable_cache = disable_cache self._cache_dir = (config or Config.create()).repository_cache_directory / name self._cache = CacheManager({ "default": "releases", "serializer": "json", "stores": { "releases": { "driver": "file", "path": str(self._cache_dir) }, "packages": { "driver": "dict" }, "matches": { "driver": "dict" }, }, })
def get_default_source_root() -> Path: from poetry.config.config import Config return Path(Config.create().get("cache-dir")) / "src"
def handle(self) -> int | None: from pathlib import Path from poetry.core.pyproject.exceptions import PyProjectException from poetry.core.toml.file import TOMLFile from poetry.config.config import Config from poetry.config.file_config_source import FileConfigSource from poetry.locations import CONFIG_DIR config = Config.create() config_file = TOMLFile(CONFIG_DIR / "config.toml") try: local_config_file = TOMLFile(self.poetry.file.parent / "poetry.toml") if local_config_file.exists(): config.merge(local_config_file.read()) except (RuntimeError, PyProjectException): local_config_file = TOMLFile(Path.cwd() / "poetry.toml") if self.option("local"): config.set_config_source(FileConfigSource(local_config_file)) if not config_file.exists(): config_file.path.parent.mkdir(parents=True, exist_ok=True) config_file.touch(mode=0o0600) if self.option("list"): self._list_configuration(config.all(), config.raw()) return 0 setting_key = self.argument("key") if not setting_key: return 0 if self.argument("value") and self.option("unset"): raise RuntimeError("You can not combine a setting value with --unset") # show the value if no value is provided if not self.argument("value") and not self.option("unset"): m = re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key")) value: str | dict[str, Any] if m: if not m.group(1): value = {} if config.get("repositories") is not None: value = config.get("repositories") else: repo = config.get(f"repositories.{m.group(1)}") if repo is None: raise ValueError(f"There is no {m.group(1)} repository defined") value = repo self.line(str(value)) else: if setting_key not in self.unique_config_values: raise ValueError(f"There is no {setting_key} setting.") value = config.get(setting_key) if not isinstance(value, str): value = json.dumps(value) self.line(value) return 0 values: list[str] = self.argument("value") unique_config_values = self.unique_config_values if setting_key in unique_config_values: if self.option("unset"): config.config_source.remove_property(setting_key) return None return self._handle_single_value( config.config_source, setting_key, unique_config_values[setting_key], values, ) # handle repositories m = re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key")) if m: if not m.group(1): raise ValueError("You cannot remove the [repositories] section") if self.option("unset"): repo = config.get(f"repositories.{m.group(1)}") if repo is None: raise ValueError(f"There is no {m.group(1)} repository defined") config.config_source.remove_property(f"repositories.{m.group(1)}") return 0 if len(values) == 1: url = values[0] config.config_source.add_property(f"repositories.{m.group(1)}.url", url) return 0 raise ValueError( "You must pass the url. " "Example: poetry config repositories.foo https://bar.com" ) # handle auth m = re.match(r"^(http-basic|pypi-token)\.(.+)", self.argument("key")) if m: from poetry.utils.password_manager import PasswordManager password_manager = PasswordManager(config) if self.option("unset"): if m.group(1) == "http-basic": password_manager.delete_http_password(m.group(2)) elif m.group(1) == "pypi-token": password_manager.delete_pypi_token(m.group(2)) return 0 if m.group(1) == "http-basic": if len(values) == 1: username = values[0] # Only username, so we prompt for password password = self.secret("Password:"******"Expected one or two arguments " f"(username, password), got {len(values)}" ) else: username = values[0] password = values[1] password_manager.set_http_password(m.group(2), username, password) elif m.group(1) == "pypi-token": if len(values) != 1: raise ValueError( f"Expected only one argument (token), got {len(values)}" ) token = values[0] password_manager.set_pypi_token(m.group(2), token) return 0 # handle certs m = re.match( r"(?:certificates)\.([^.]+)\.(cert|client-cert)", self.argument("key") ) if m: if self.option("unset"): config.auth_config_source.remove_property( f"certificates.{m.group(1)}.{m.group(2)}" ) return 0 if len(values) == 1: config.auth_config_source.add_property( f"certificates.{m.group(1)}.{m.group(2)}", values[0] ) else: raise ValueError("You must pass exactly 1 value") return 0 raise ValueError(f"Setting {self.argument('key')} does not exist")
def handle(self) -> int: from cachy import CacheManager cache = self.argument("cache") parts = cache.split(":") root = parts[0] config = Config.create() cache_dir = config.repository_cache_directory / root try: cache_dir.relative_to(config.repository_cache_directory) except ValueError: raise ValueError(f"{root} is not a valid repository cache") cache = CacheManager({ "default": parts[0], "serializer": "json", "stores": { parts[0]: { "driver": "file", "path": str(cache_dir) } }, }) if len(parts) == 1: if not self.option("all"): raise RuntimeError( f"Add the --all option if you want to clear all {parts[0]} caches" ) if not os.path.exists(str(cache_dir)): self.line(f"No cache entries for {parts[0]}") return 0 # Calculate number of entries entries_count = sum( len(files) for _path, _dirs, files in os.walk(str(cache_dir))) delete = self.confirm( f"<question>Delete {entries_count} entries?</>") if not delete: return 0 cache.flush() elif len(parts) == 2: raise RuntimeError( "Only specifying the package name is not yet supported. " "Add a specific version to clear") elif len(parts) == 3: package = parts[1] version = parts[2] if not cache.has(f"{package}:{version}"): self.line(f"No cache entries for {package}:{version}") return 0 delete = self.confirm(f"Delete cache entry {package}:{version}") if not delete: return 0 cache.forget(f"{package}:{version}") else: raise ValueError("Invalid cache key") return 0