Remove breaking changes

Author: AndreuCodina

pydantic_settings/sources/providers/azure.py

@@ -42,30 +42,41 @@ class AzureKeyVaultMapping(Mapping[str, Optional[str]]):
     _secret_client: SecretClient
     _secret_names: list[str]
 
-    def __init__(
-        self,
-        secret_client: SecretClient,
-    ) -> None:
+    def __init__(self, secret_client: SecretClient, case_sensitive: bool, snake_case_conversion: bool) -> None:
         self._loaded_secrets = {}
         self._secret_client = secret_client
+        self._case_sensitive = case_sensitive
+        self._snake_case_conversion = snake_case_conversion
         self._secret_map: dict[str, str] = self._load_remote()
 
     def _load_remote(self) -> dict[str, str]:
         secret_names: Iterator[str] = (
             secret.name for secret in self._secret_client.list_properties_of_secrets() if secret.name and secret.enabled
         )
-        return {to_snake(name): name for name in secret_names}
+
+        if self._snake_case_conversion:
+            return {to_snake(name): name for name in secret_names}
+
+        if self._case_sensitive:
+            return {name: name for name in secret_names}
+
+        return {name.lower(): name for name in secret_names}
 
     def __getitem__(self, key: str) -> str | None:
-        key_snake = to_snake(key)
+        new_key = key
+
+        if self._snake_case_conversion:
+            new_key = to_snake(key)
+        elif not self._case_sensitive:
+            new_key = key.lower()
 
-        if key_snake not in self._loaded_secrets:
-            if key_snake in self._secret_map:
-                self._loaded_secrets[key_snake] = self._secret_client.get_secret(self._secret_map[key_snake]).value
+        if new_key not in self._loaded_secrets:
+            if new_key in self._secret_map:
+                self._loaded_secrets[new_key] = self._secret_client.get_secret(self._secret_map[new_key]).value
             else:
                 raise KeyError(key)
 
-        return self._loaded_secrets[key_snake]
+        return self._loaded_secrets[new_key]
 
     def __len__(self) -> int:
         return len(self._secret_map)
@@ -83,29 +94,44 @@ def __init__(
         settings_cls: type[BaseSettings],
         url: str,
         credential: TokenCredential,
+        dash_to_underscore: bool = False,
+        case_sensitive: bool | None = None,
+        snake_case_conversion: bool = False,
         env_prefix: str | None = None,
         env_parse_none_str: str | None = None,
         env_parse_enums: bool | None = None,
     ) -> None:
         import_azure_key_vault()
         self._url = url
         self._credential = credential
+        self._dash_to_underscore = dash_to_underscore
+        self._snake_case_conversion = snake_case_conversion
         super().__init__(
             settings_cls,
-            case_sensitive=False,
+            case_sensitive=False if snake_case_conversion else case_sensitive,
             env_prefix=env_prefix,
-            env_nested_delimiter='__',
+            env_nested_delimiter='__' if snake_case_conversion else '--',
             env_ignore_empty=False,
             env_parse_none_str=env_parse_none_str,
             env_parse_enums=env_parse_enums,
         )
 
     def _load_env_vars(self) -> Mapping[str, Optional[str]]:
         secret_client = SecretClient(vault_url=self._url, credential=self._credential)
-        return AzureKeyVaultMapping(secret_client)
+        return AzureKeyVaultMapping(
+            secret_client=secret_client,
+            case_sensitive=self.case_sensitive,
+            snake_case_conversion=self._snake_case_conversion,
+        )
 
     def _extract_field_info(self, field: FieldInfo, field_name: str) -> list[tuple[str, str, bool]]:
-        return list((x[0], x[0], x[2]) for x in super()._extract_field_info(field, field_name))
+        if self._snake_case_conversion:
+            return list((x[0], x[0], x[2]) for x in super()._extract_field_info(field, field_name))
+
+        if self._dash_to_underscore:
+            return list((x[0], x[1].replace('_', '-'), x[2]) for x in super()._extract_field_info(field, field_name))
+
+        return super()._extract_field_info(field, field_name)
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}(url={self._url!r}, env_nested_delimiter={self.env_nested_delimiter!r})'

tests/test_source_azure_key_vault.py

@@ -46,17 +46,18 @@ def test___call__(self, mocker: MockerFixture) -> None:
         """Test __call__."""
 
         class SqlServer(BaseModel):
-            password: str
+            password: str = Field(..., alias='Password')
 
         class AzureKeyVaultSettings(BaseSettings):
             """AzureKeyVault settings."""
 
-            sql_server_user: str
-            sql_server: SqlServer
+            SqlServerUser: str
+            # sql_server_user: str = Field(..., alias='SqlServerUser')
+            # sql_server: SqlServer = Field(..., alias='SqlServer')
 
         expected_secrets = [
             type('', (), {'name': 'SqlServerUser', 'enabled': True}),
-            type('', (), {'name': 'SqlServer--Password', 'enabled': True}),
+            # type('', (), {'name': 'SqlServer--Password', 'enabled': True}),
         ]
         expected_secret_value = 'SecretValue'
         mocker.patch(
@@ -73,8 +74,8 @@ class AzureKeyVaultSettings(BaseSettings):
 
         settings = obj()
 
-        assert settings['sql_server_user'] == expected_secret_value
-        assert settings['sql_server']['password'] == expected_secret_value
+        assert settings['SqlServerUser'] == expected_secret_value
+        assert settings['SqlServer']['Password'] == expected_secret_value
 
     def test_do_not_load_disabled_secrets(self, mocker: MockerFixture) -> None:
         class AzureKeyVaultSettings(BaseSettings):