def _get_certs_for_netloc_from_config(
self, netloc): # type: (str) -> Dict[str, pathlib.PosixPath]
certs = dict(cert=None, verify=None)
for (repository_name,
repository_netloc) in self._get_repository_netlocs():
if netloc == repository_netloc:
certs['cert'] = get_client_cert(self._config, repository_name)
certs['verify'] = get_cert(self._config, repository_name)
break
return certs
def create_legacy_repository(cls, source: Dict[str, str],
auth_config: Config) -> "LegacyRepository":
from poetry.repositories.legacy_repository import LegacyRepository
from poetry.utils.helpers import get_cert
from poetry.utils.helpers import get_client_cert
if "url" not in source:
raise RuntimeError("Unsupported source specified")
# PyPI-like repository
if "name" not in source:
raise RuntimeError("Missing [name] in source.")
name = source["name"]
url = source["url"]
return LegacyRepository(
name,
url,
config=auth_config,
cert=get_cert(auth_config, name),
client_cert=get_client_cert(auth_config, name),
)
def test_get_cert(config: "Config"):
ca_cert = "path/to/ca.pem"
config.merge({"certificates": {"foo": {"cert": ca_cert}}})
assert get_cert(config, "foo") == Path(ca_cert)
def publish(self, repository_name, username, password, cert=None, client_cert=None):
if repository_name:
self._io.write_line(
"Publishing <info>{}</info> (<comment>{}</comment>) "
"to <fg=cyan>{}</>".format(
self._package.pretty_name,
self._package.pretty_version,
repository_name,
)
)
else:
self._io.write_line(
"Publishing <info>{}</info> (<comment>{}</comment>) "
"to <fg=cyan>PyPI</>".format(
self._package.pretty_name, self._package.pretty_version
)
)
if not repository_name:
url = "https://upload.pypi.org/legacy/"
repository_name = "pypi"
else:
# Retrieving config information
repository = self._poetry.config.get(
"repositories.{}".format(repository_name)
)
if repository is None:
raise RuntimeError(
"Repository {} is not defined".format(repository_name)
)
url = repository["url"]
if not (username and password):
# Check if we have a token first
token = self._poetry.config.get("pypi-token.{}".format(repository_name))
if token:
logger.debug("Found an API token for {}.".format(repository_name))
username = "******"
password = token
else:
auth = get_http_basic_auth(self._poetry.config, repository_name)
if auth:
logger.debug(
"Found authentication information for {}.".format(
repository_name
)
)
username = auth[0]
password = auth[1]
resolved_client_cert = client_cert or get_client_cert(
self._poetry.config, repository_name
)
# Requesting missing credentials but only if there is not a client cert defined.
if not resolved_client_cert:
if username is None:
username = self._io.ask("Username:"******"Password:")
self._uploader.auth(username, password)
return self._uploader.upload(
url,
cert=cert or get_cert(self._poetry.config, repository_name),
client_cert=resolved_client_cert,
)
def publish(
self,
repository_name: str | None,
username: str | None,
password: str | None,
cert: Path | None = None,
client_cert: Path | None = None,
dry_run: bool = False,
) -> None:
if not repository_name:
url = "https://upload.pypi.org/legacy/"
repository_name = "pypi"
else:
# Retrieving config information
url = self._poetry.config.get(
f"repositories.{repository_name}.url")
if url is None:
raise RuntimeError(
f"Repository {repository_name} is not defined")
if not (username and password):
# Check if we have a token first
token = self._authenticator.get_pypi_token(repository_name)
if token:
logger.debug(f"Found an API token for {repository_name}.")
username = "******"
password = token
else:
auth = self._authenticator.get_http_auth(repository_name)
if auth:
logger.debug(
f"Found authentication information for {repository_name}."
)
username = auth["username"]
password = auth["password"]
resolved_client_cert = client_cert or get_client_cert(
self._poetry.config, repository_name)
# Requesting missing credentials but only if there is not a client cert defined.
if not resolved_client_cert:
if username is None:
username = self._io.ask("Username:"******"Password:"******"pypi":
repository_name = "PyPI"
self._io.write_line(f"Publishing <c1>{self._package.pretty_name}</c1>"
f" (<c2>{self._package.pretty_version}</c2>) to"
f" <info>{repository_name}</info>")
self._uploader.upload(
url,
cert=cert or get_cert(self._poetry.config, repository_name),
client_cert=resolved_client_cert,
dry_run=dry_run,
)
def publish(
self,
repository_name,
username,
password,
cert=None,
client_cert=None,
dry_run=False,
): # type: (Optional[str], Optional[str], Optional[str], Optional[Path], Optional[Path], Optional[bool]) -> None
if not repository_name:
url = "https://upload.pypi.org/legacy/"
repository_name = "pypi"
else:
# Retrieving config information
url = self._poetry.config.get("repositories.{}.url".format(repository_name))
if url is None:
raise RuntimeError(
"Repository {} is not defined".format(repository_name)
)
if not (username and password):
# Check if we have a token first
token = self._password_manager.get_pypi_token(repository_name)
if token:
logger.debug("Found an API token for {}.".format(repository_name))
username = "******"
password = token
else:
auth = self._password_manager.get_http_auth(repository_name)
if auth:
logger.debug(
"Found authentication information for {}.".format(
repository_name
)
)
username = auth["username"]
password = auth["password"]
resolved_client_cert = client_cert or get_client_cert(
self._poetry.config, repository_name
)
# Requesting missing credentials but only if there is not a client cert defined.
if not resolved_client_cert:
if username is None:
username = self._io.ask("Username:"******"Password:"******"Publishing <c1>{}</c1> (<c2>{}</c2>) "
"to <info>{}</info>".format(
self._package.pretty_name,
self._package.pretty_version,
"PyPI" if repository_name == "pypi" else repository_name,
)
)
self._uploader.upload(
url,
cert=cert or get_cert(self._poetry.config, repository_name),
client_cert=resolved_client_cert,
dry_run=dry_run,
)
def certs(self, config: Config) -> dict[str, Path | None]:
return {
"cert": get_client_cert(config, self.name),
"verify": get_cert(config, self.name),
}
