chore: cleanup keyring logging and class naming

src/poetry/utils/password_manager.py

@@ -18,7 +18,7 @@ class PasswordManagerError(Exception):
     pass
     pass
 
 
 
 
-class KeyRingError(Exception):
+class PoetryKeyringError(Exception):
 
 
     pass
     pass
 
 
@@ -29,7 +29,7 @@ class HTTPAuthCredential:
     password: str | None = dataclasses.field(default=None)
     password: str | None = dataclasses.field(default=None)
 
 
 
 
-class KeyRing:
+class PoetryKeyring:
     def __init__(self, namespace: str) -> None:
     def __init__(self, namespace: str) -> None:
         self._namespace = namespace
         self._namespace = namespace
         self._is_available = True
         self._is_available = True
@@ -70,7 +70,7 @@ class KeyRing:
         try:
         try:
             return keyring.get_password(name, username)
             return keyring.get_password(name, username)
         except (RuntimeError, keyring.errors.KeyringError):
         except (RuntimeError, keyring.errors.KeyringError):
-            raise KeyRingError(
+            raise PoetryKeyringError(
                 f"Unable to retrieve the password for {name} from the key ring"
                 f"Unable to retrieve the password for {name} from the key ring"
             )
             )
 
 
@@ -86,7 +86,7 @@ class KeyRing:
         try:
         try:
             keyring.set_password(name, username, password)
             keyring.set_password(name, username, password)
         except (RuntimeError, keyring.errors.KeyringError) as e:
         except (RuntimeError, keyring.errors.KeyringError) as e:
-            raise KeyRingError(
+            raise PoetryKeyringError(
                 f"Unable to store the password for {name} in the key ring: {e}"
                 f"Unable to store the password for {name} in the key ring: {e}"
             )
             )
 
 
@@ -94,7 +94,6 @@ class KeyRing:
         if not self.is_available():
         if not self.is_available():
             return
             return
 
 
-        import keyring
         import keyring.errors
         import keyring.errors
 
 
         name = self.get_entry_name(name)
         name = self.get_entry_name(name)
@@ -102,7 +101,7 @@ class KeyRing:
         try:
         try:
             keyring.delete_password(name, username)
             keyring.delete_password(name, username)
         except (RuntimeError, keyring.errors.KeyringError):
         except (RuntimeError, keyring.errors.KeyringError):
-            raise KeyRingError(
+            raise PoetryKeyringError(
                 f"Unable to delete the password for {name} from the key ring"
                 f"Unable to delete the password for {name} from the key ring"
             )
             )
 
 
@@ -141,27 +140,34 @@ class KeyRing:
                 self._is_available = False
                 self._is_available = False
 
 
         if not self._is_available:
         if not self._is_available:
-            logger.warning("No suitable keyring backends were found")
+            logger.debug("No suitable keyring backends were found")
 
 
 
 
 class PasswordManager:
 class PasswordManager:
     def __init__(self, config: Config) -> None:
     def __init__(self, config: Config) -> None:
         self._config = config
         self._config = config
-        self._keyring: KeyRing | None = None
+        self._keyring: PoetryKeyring | None = None
 
 
     @property
     @property
-    def keyring(self) -> KeyRing:
+    def keyring(self) -> PoetryKeyring:
         if self._keyring is None:
         if self._keyring is None:
-            self._keyring = KeyRing("poetry-repository")
+            self._keyring = PoetryKeyring("poetry-repository")
+
             if not self._keyring.is_available():
             if not self._keyring.is_available():
-                logger.warning(
-                    "Using a plaintext file to store and retrieve credentials"
+                logger.debug(
+                    "<warning>Keyring is not available, credentials will be stored and "
+                    "retrieved from configuration files as plaintext.</>"
                 )
                 )
 
 
         return self._keyring
         return self._keyring
 
 
+    @staticmethod
+    def warn_plaintext_credentials_stored() -> None:
+        logger.warning("Using a plaintext file to store credentials")
+
     def set_pypi_token(self, name: str, token: str) -> None:
     def set_pypi_token(self, name: str, token: str) -> None:
         if not self.keyring.is_available():
         if not self.keyring.is_available():
+            self.warn_plaintext_credentials_stored()
             self._config.auth_config_source.add_property(f"pypi-token.{name}", token)
             self._config.auth_config_source.add_property(f"pypi-token.{name}", token)
         else:
         else:
             self.keyring.set_password(name, "__token__", token)
             self.keyring.set_password(name, "__token__", token)
@@ -200,6 +206,7 @@ class PasswordManager:
         auth = {"username": username}
         auth = {"username": username}
 
 
         if not self.keyring.is_available():
         if not self.keyring.is_available():
+            self.warn_plaintext_credentials_stored()
             auth["password"] = password
             auth["password"] = password
         else:
         else:
             self.keyring.set_password(name, username, password)
             self.keyring.set_password(name, username, password)
@@ -215,7 +222,7 @@ class PasswordManager:
         if username is None:
         if username is None:
             return
             return
 
 
-        with suppress(KeyRingError):
+        with suppress(PoetryKeyringError):
             self.keyring.delete_password(name, username)
             self.keyring.delete_password(name, username)
 
 
         self._config.auth_config_source.remove_property(f"http-basic.{name}")
         self._config.auth_config_source.remove_property(f"http-basic.{name}")

tests/utils/test_password_manager.py

@@ -6,9 +6,9 @@ from typing import TYPE_CHECKING
 
 
 import pytest
 import pytest
 
 
-from poetry.utils.password_manager import KeyRing
-from poetry.utils.password_manager import KeyRingError
 from poetry.utils.password_manager import PasswordManager
 from poetry.utils.password_manager import PasswordManager
+from poetry.utils.password_manager import PoetryKeyring
+from poetry.utils.password_manager import PoetryKeyringError
 
 
 
 
 if TYPE_CHECKING:
 if TYPE_CHECKING:
@@ -174,23 +174,23 @@ def test_delete_pypi_token_with_unavailable_backend(
 def test_keyring_raises_errors_on_keyring_errors(
 def test_keyring_raises_errors_on_keyring_errors(
     mocker: MockerFixture, with_fail_keyring: None
     mocker: MockerFixture, with_fail_keyring: None
 ):
 ):
-    mocker.patch("poetry.utils.password_manager.KeyRing._check")
+    mocker.patch("poetry.utils.password_manager.PoetryKeyring._check")
 
 
-    key_ring = KeyRing("poetry")
-    with pytest.raises(KeyRingError):
+    key_ring = PoetryKeyring("poetry")
+    with pytest.raises(PoetryKeyringError):
         key_ring.set_password("foo", "bar", "baz")
         key_ring.set_password("foo", "bar", "baz")
 
 
-    with pytest.raises(KeyRingError):
+    with pytest.raises(PoetryKeyringError):
         key_ring.get_password("foo", "bar")
         key_ring.get_password("foo", "bar")
 
 
-    with pytest.raises(KeyRingError):
+    with pytest.raises(PoetryKeyringError):
         key_ring.delete_password("foo", "bar")
         key_ring.delete_password("foo", "bar")
 
 
 
 
 def test_keyring_with_chainer_backend_and_fail_keyring_should_be_unavailable(
 def test_keyring_with_chainer_backend_and_fail_keyring_should_be_unavailable(
     with_chained_fail_keyring: None,
     with_chained_fail_keyring: None,
 ):
 ):
-    key_ring = KeyRing("poetry")
+    key_ring = PoetryKeyring("poetry")
 
 
     assert not key_ring.is_available()
     assert not key_ring.is_available()
 
 
@@ -198,7 +198,7 @@ def test_keyring_with_chainer_backend_and_fail_keyring_should_be_unavailable(
 def test_keyring_with_chainer_backend_and_null_keyring_should_be_unavailable(
 def test_keyring_with_chainer_backend_and_null_keyring_should_be_unavailable(
     with_chained_null_keyring: None,
     with_chained_null_keyring: None,
 ):
 ):
-    key_ring = KeyRing("poetry")
+    key_ring = PoetryKeyring("poetry")
 
 
     assert not key_ring.is_available()
     assert not key_ring.is_available()
 
 
@@ -206,7 +206,7 @@ def test_keyring_with_chainer_backend_and_null_keyring_should_be_unavailable(
 def test_null_keyring_should_be_unavailable(
 def test_null_keyring_should_be_unavailable(
     with_null_keyring: None,
     with_null_keyring: None,
 ):
 ):
-    key_ring = KeyRing("poetry")
+    key_ring = PoetryKeyring("poetry")
 
 
     assert not key_ring.is_available()
     assert not key_ring.is_available()
 
 
@@ -214,7 +214,7 @@ def test_null_keyring_should_be_unavailable(
 def test_fail_keyring_should_be_unavailable(
 def test_fail_keyring_should_be_unavailable(
     with_fail_keyring: None,
     with_fail_keyring: None,
 ):
 ):
-    key_ring = KeyRing("poetry")
+    key_ring = PoetryKeyring("poetry")
 
 
     assert not key_ring.is_available()
     assert not key_ring.is_available()