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
