fix: support periods in repository names (#10845)

The config source methods (get_property, add_property, remove_property)
blindly split keys on periods, which breaks repository names containing
periods (e.g. "my.repo"). This causes http-basic, pypi-token,
repositories, and certificates config entries to be incorrectly nested.

The fix adds a split_key() helper and updates the ConfigSource interface
to accept either a dotted string or a pre-split list of key segments.
All call sites that embed repository names now pass lists to preserve
names with periods as single key segments.

Co-authored-by: Randy Döring <30527984+radoering@users.noreply.github.com>

Author: yosofbadr

src/poetry/config/config.py

@@ -16,6 +16,7 @@
 from packaging.utils import NormalizedName
 from packaging.utils import canonicalize_name
 
+from poetry.config.config_source import split_key
 from poetry.config.dict_config_source import DictConfigSource
 from poetry.config.file_config_source import FileConfigSource
 from poetry.locations import CONFIG_DIR
@@ -309,34 +310,35 @@ def installer_max_workers(self) -> int:
             return default_max_workers
         return min(default_max_workers, int(desired_max_workers))
 
-    def get(self, setting_name: str, default: Any = None) -> Any:
+    def get(self, setting_name: str | Sequence[str], default: Any = None) -> Any:
         """
         Retrieve a setting value.
+
+        The setting_name can be a dotted string (e.g. "virtualenvs.create")
+        or a list of key segments (e.g. ["http-basic", "my.repo", "username"])
+        when any segment may contain periods.
         """
-        keys = setting_name.split(".")
+        keys = split_key(setting_name)
         build_config_settings: Mapping[
             NormalizedName, Mapping[str, str | Sequence[str]]
         ] = {}
 
         # Looking in the environment if the setting
         # is set via a POETRY_* environment variable
         if self._use_environment:
-            if setting_name == "repositories":
+            if keys == ["repositories"]:
                 # repositories setting is special for now
                 repositories = self._get_environment_repositories()
                 if repositories:
                     return repositories
 
-            build_config_settings_key = "installer.build-config-settings"
-            if setting_name == build_config_settings_key or setting_name.startswith(
-                f"{build_config_settings_key}."
-            ):
+            if keys[:2] == ["installer", "build-config-settings"]:
                 build_config_settings = self._get_environment_build_config_settings()
             else:
                 env = "POETRY_" + "_".join(k.upper().replace("-", "_") for k in keys)
                 env_value = os.getenv(env)
                 if env_value is not None:
-                    return self.process(self._get_normalizer(setting_name)(env_value))
+                    return self.process(self._get_normalizer(keys)(env_value))
 
         value = self._config
 
@@ -355,7 +357,7 @@ def get(self, setting_name: str, default: Any = None) -> Any:
         if self._use_environment and isinstance(value, dict):
             # this is a configuration table, it is likely that we missed env vars
             # in order to capture them recurse, eg: virtualenvs.options
-            return {k: self.get(f"{setting_name}.{k}") for k in value}
+            return {k: self.get([*keys, k]) for k in value}
 
         return self.process(value)
 
@@ -376,7 +378,9 @@ def resolve_from_config(match: re.Match[str]) -> str:
         return re.sub(r"{(.+?)}", resolve_from_config, value)
 
     @staticmethod
-    def _get_normalizer(name: str) -> Callable[[str], Any]:
+    def _get_normalizer(name: str | Sequence[str]) -> Callable[[str], Any]:
+        if not isinstance(name, str):
+            name = ".".join(name)
         if name in {
             "virtualenvs.create",
             "virtualenvs.in-project",

src/poetry/config/config_source.py

@@ -12,25 +12,42 @@
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from cleo.io.io import IO
 
 
 UNSET = object()
 
 
+def split_key(key: str | Sequence[str]) -> list[str]:
+    """Split a config key into its component parts.
+
+    If the key is a string, split on periods.
+
+    If the key contains segments with periods
+    (e.g. repository names like "my.repo"),
+    this should be handled before calling this function
+    so that a list or tuple of the segments is passed.
+    """
+    if isinstance(key, str):
+        return key.split(".")
+    return list(key)
+
+
 class PropertyNotFoundError(ValueError):
     pass
 
 
 class ConfigSource(ABC):
     @abstractmethod
-    def get_property(self, key: str) -> Any: ...
+    def get_property(self, key: str | Sequence[str]) -> Any: ...
 
     @abstractmethod
-    def add_property(self, key: str, value: Any) -> None: ...
+    def add_property(self, key: str | Sequence[str], value: Any) -> None: ...
 
     @abstractmethod
-    def remove_property(self, key: str) -> None: ...
+    def remove_property(self, key: str | Sequence[str]) -> None: ...
 
 
 @dataclasses.dataclass
@@ -81,7 +98,7 @@ def apply(self, config_source: ConfigSource) -> None:
 
 
 def drop_empty_config_category(
-    keys: list[str], config: dict[Any, Any]
+    keys: Sequence[str], config: dict[Any, Any]
 ) -> dict[Any, Any]:
     config_ = {}
 

src/poetry/config/dict_config_source.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 from typing import Any
 
 from poetry.config.config_source import ConfigSource
 from poetry.config.config_source import PropertyNotFoundError
+from poetry.config.config_source import split_key
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
 
 class DictConfigSource(ConfigSource):
@@ -14,44 +20,44 @@ def __init__(self) -> None:
     def config(self) -> dict[str, Any]:
         return self._config
 
-    def get_property(self, key: str) -> Any:
-        keys = key.split(".")
+    def get_property(self, key: str | Sequence[str]) -> Any:
+        keys = split_key(key)
         config = self._config
 
-        for i, key in enumerate(keys):
-            if key not in config:
+        for i, sub_key in enumerate(keys):
+            if sub_key not in config:
                 raise PropertyNotFoundError(f"Key {'.'.join(keys)} not in config")
 
             if i == len(keys) - 1:
-                return config[key]
+                return config[sub_key]
 
-            config = config[key]
+            config = config[sub_key]
 
-    def add_property(self, key: str, value: Any) -> None:
-        keys = key.split(".")
+    def add_property(self, key: str | Sequence[str], value: Any) -> None:
+        keys = split_key(key)
         config = self._config
 
-        for i, key in enumerate(keys):
-            if key not in config and i < len(keys) - 1:
-                config[key] = {}
+        for i, sub_key in enumerate(keys):
+            if sub_key not in config and i < len(keys) - 1:
+                config[sub_key] = {}
 
             if i == len(keys) - 1:
-                config[key] = value
+                config[sub_key] = value
                 break
 
-            config = config[key]
+            config = config[sub_key]
 
-    def remove_property(self, key: str) -> None:
-        keys = key.split(".")
+    def remove_property(self, key: str | Sequence[str]) -> None:
+        keys = split_key(key)
 
         config = self._config
-        for i, key in enumerate(keys):
-            if key not in config:
+        for i, sub_key in enumerate(keys):
+            if sub_key not in config:
                 return
 
             if i == len(keys) - 1:
-                del config[key]
+                del config[sub_key]
 
                 break
 
-            config = config[key]
+            config = config[sub_key]

src/poetry/config/file_config_source.py

@@ -10,10 +10,12 @@
 from poetry.config.config_source import ConfigSource
 from poetry.config.config_source import PropertyNotFoundError
 from poetry.config.config_source import drop_empty_config_category
+from poetry.config.config_source import split_key
 
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
+    from collections.abc import Sequence
 
     from tomlkit.toml_document import TOMLDocument
 
@@ -32,51 +34,51 @@ def name(self) -> str:
     def file(self) -> TOMLFile:
         return self._file
 
-    def get_property(self, key: str) -> Any:
-        keys = key.split(".")
+    def get_property(self, key: str | Sequence[str]) -> Any:
+        keys = split_key(key)
 
         config = self.file.read() if self.file.exists() else {}
 
-        for i, key in enumerate(keys):
-            if key not in config:
+        for i, sub_key in enumerate(keys):
+            if sub_key not in config:
                 raise PropertyNotFoundError(f"Key {'.'.join(keys)} not in config")
 
             if i == len(keys) - 1:
-                return config[key]
+                return config[sub_key]
 
-            config = config[key]
+            config = config[sub_key]
 
-    def add_property(self, key: str, value: Any) -> None:
+    def add_property(self, key: str | Sequence[str], value: Any) -> None:
         with self.secure() as toml:
             config: dict[str, Any] = toml
-            keys = key.split(".")
+            keys = split_key(key)
 
-            for i, key in enumerate(keys):
-                if key not in config and i < len(keys) - 1:
-                    config[key] = table()
+            for i, sub_key in enumerate(keys):
+                if sub_key not in config and i < len(keys) - 1:
+                    config[sub_key] = table()
 
                 if i == len(keys) - 1:
-                    config[key] = value
+                    config[sub_key] = value
                     break
 
-                config = config[key]
+                config = config[sub_key]
 
-    def remove_property(self, key: str) -> None:
+    def remove_property(self, key: str | Sequence[str]) -> None:
         with self.secure() as toml:
             config: dict[str, Any] = toml
-            keys = key.split(".")
+            keys = split_key(key)
 
             current_config = config
-            for i, key in enumerate(keys):
-                if key not in current_config:
+            for i, sub_key in enumerate(keys):
+                if sub_key not in current_config:
                     return
 
                 if i == len(keys) - 1:
-                    del current_config[key]
+                    del current_config[sub_key]
 
                     break
 
-                current_config = current_config[key]
+                current_config = current_config[sub_key]
 
             current_config = drop_empty_config_category(keys=keys[:-1], config=config)
             config.clear()

src/poetry/console/commands/config.py

@@ -150,6 +150,8 @@ def handle(self) -> int:
         if self.argument("value") and self.option("unset"):
             raise RuntimeError("You can not combine a setting value with --unset")
 
+        repo_regex = r"^repos?(?:itories)?(?:\.(.+?)(?:\.(url))?)?$"
+
         # show the value if no value is provided
         if not self.argument("value") and not self.option("unset"):
             if setting_key.split(".")[0] in self.LIST_PROHIBITED_SETTINGS:
@@ -176,17 +178,18 @@ def handle(self) -> int:
                             f"No build config settings configured for <c1>{package_name}</>."
                         )
                 return 0
-            elif m := re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key")):
+            elif m := re.match(repo_regex, self.argument("key")):
                 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)}")
+                    repo_name = m.group(1)
+                    repo = config.get(["repositories", repo_name])
                     if repo is None:
-                        raise ValueError(f"There is no {m.group(1)} repository defined")
+                        raise ValueError(f"There is no {repo_name} repository defined")
 
-                    value = repo
+                    value = repo.get(sub_key, "") if (sub_key := m.group(2)) else repo
 
                 self.line(str(value))
             else:
@@ -217,24 +220,34 @@ def handle(self) -> int:
             )
 
         # handle repositories
-        m = re.match(r"^repos?(?:itories)?(?:\.(.+))?", self.argument("key"))
+        m = re.match(repo_regex, self.argument("key"))
         if m:
             if not m.group(1):
                 raise ValueError("You cannot remove the [repositories] section")
 
+            repo_name = m.group(1)
+
             if self.option("unset"):
-                repo = config.get(f"repositories.{m.group(1)}")
+                repo = config.get(["repositories", repo_name])
                 if repo is None:
-                    raise ValueError(f"There is no {m.group(1)} repository defined")
+                    raise ValueError(f"There is no {repo_name} repository defined")
 
-                config.config_source.remove_property(f"repositories.{m.group(1)}")
+                if m.group(2):
+                    # Unset a specific sub-property
+                    config.config_source.remove_property(
+                        ["repositories", repo_name, m.group(2)]
+                    )
+                else:
+                    config.config_source.remove_property(["repositories", repo_name])
 
                 return 0
 
             if len(values) == 1:
                 url = values[0]
 
-                config.config_source.add_property(f"repositories.{m.group(1)}.url", url)
+                config.config_source.add_property(
+                    ["repositories", repo_name, "url"], url
+                )
 
                 return 0
 
@@ -286,14 +299,14 @@ def handle(self) -> int:
             return 0
 
         # handle certs
-        m = re.match(r"certificates\.([^.]+)\.(cert|client-cert)", self.argument("key"))
+        m = re.match(r"certificates\.(.+)\.(cert|client-cert)$", self.argument("key"))
         if m:
             repository = m.group(1)
             key = m.group(2)
 
             if self.option("unset"):
                 config.auth_config_source.remove_property(
-                    f"certificates.{repository}.{key}"
+                    ["certificates", repository, key]
                 )
 
                 return 0
@@ -305,7 +318,7 @@ def handle(self) -> int:
                     new_value = boolean_normalizer(values[0])
 
                 config.auth_config_source.add_property(
-                    f"certificates.{repository}.{key}", new_value
+                    ["certificates", repository, key], new_value
                 )
             else:
                 raise ValueError("You must pass exactly 1 value")

src/poetry/publishing/publisher.py

@@ -55,7 +55,7 @@ def publish(
             repository_name = "pypi"
         else:
             # Retrieving config information
-            url = self._poetry.config.get(f"repositories.{repository_name}.url")
+            url = self._poetry.config.get(["repositories", repository_name, "url"])
             if url is None:
                 raise RuntimeError(f"Repository {repository_name} is not defined")
             url = _normalize_legacy_repository_url(url)