refactor: adapt from feedback

Author: alambare

eodag/api/plugin.py

@@ -15,7 +15,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Annotated, Any, Literal, Optional, Self, TypedDict, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, TypedDict, Union
 
 import yaml
 from annotated_types import Gt
@@ -24,6 +26,9 @@
 from eodag.utils import merge_mappings, sort_dict
 from eodag.utils.exceptions import ValidationError
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 class Pagination(TypedDict):
     """Search pagination configuration"""

eodag/api/provider.py

@@ -24,7 +24,7 @@
 from collections import UserDict
 from dataclasses import dataclass, field
 from inspect import isclass
-from typing import Any, Iterator, Optional, Self, Union, get_type_hints
+from typing import TYPE_CHECKING, Any, Iterator, Optional, Union, get_type_hints
 
 import yaml
 
@@ -43,9 +43,16 @@
     slugify,
     update_nested_dict,
 )
-from eodag.utils.exceptions import ValidationError
+from eodag.utils.exceptions import (
+    UnsupportedProductType,
+    UnsupportedProvider,
+    ValidationError,
+)
 from eodag.utils.repr import dict_to_html_table
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 logger = logging.getLogger("eodag.provider")
 
 AUTH_TOPIC_KEYS = ("auth", "search_auth", "download_auth")
@@ -237,15 +244,18 @@ def __post_init__(self):
             self._config = ProviderConfig.from_mapping(self._config)
 
         elif not isinstance(self._config, ProviderConfig):
-            raise TypeError(
+            msg = (
                 f"Unsupported config type: {type(self._config)}. "
                 "Expected ProviderConfig or dict."
             )
+            raise ValidationError(msg)
 
         self.name = self.name or self._config.name
 
         if self.name is None:
-            raise ValueError("Provider name could not be determined from the config.")
+            raise ValidationError(
+                "Provider name could not be determined from the config."
+            )
 
     def __str__(self) -> str:
         """Return the provider's name as string."""
@@ -385,14 +395,13 @@ def delete_product_type(self, name: str) -> None:
 
         :param name: The product type name.
 
-        :raises KeyError: If the product type is not found.
+        :raises UnsupportedProductType: If the product type is not found.
         """
         try:
             del self.product_types[name]
         except KeyError:
-            raise KeyError(
-                f"Product type '{name}' not found in provider '{self.name}'."
-            )
+            msg = f"Product type '{name}' not found in provider '{self.name}'."
+            raise UnsupportedProductType(msg)
 
     def sync_product_types(
         self,
@@ -511,18 +520,20 @@ def __setitem__(self, key: str, value: Provider) -> None:
         :raises ValueError: If the provider key already exists.
         """
         if key in self.data:
-            raise ValueError(f"Provider '{key}' already exists.")
+            msg = f"Provider '{key}' already exists."
+            raise ValueError(msg)
         super().__setitem__(key, value)
 
     def __delitem__(self, key: str) -> None:
         """
         Delete a provider by name.
 
         :param key: The name of the provider to delete.
-        :raises KeyError: If the provider key is not found.
+        :raises UnsupportedProvider: If the provider key is not found.
         """
         if key not in self.data:
-            raise KeyError(f"Provider '{key}' not found.")
+            msg = f"Provider '{key}' not found."
+            raise UnsupportedProvider(msg)
         super().__delitem__(key)
 
     def __or__(self, other: Self) -> Self:
@@ -642,23 +653,23 @@ def filter_by_name(self, name: Optional[str] = None) -> Self:
             {n: p for n, p in self.data.items() if name in [p.name, p.group]}
         )
 
-    def delete_product_type(self, provider: str, product_ID: str) -> None:
+    def delete_product_type(self, provider: str, product_type: str) -> None:
         """
         Delete a product type from a provider.
 
         :param provider: The provider's name.
         :param product_ID: The product type to delete.
-        :raises KeyError: If the provider or product is not found.
+        :raises UnsupportedProvider: If the provider or product is not found.
         """
         if provider_obj := self.get(provider):
-            if product_ID in provider_obj.products:
-                provider_obj.delete_product_type(product_ID)
+            if product_type in provider_obj.product_types:
+                provider_obj.delete_product_type(product_type)
             else:
-                raise KeyError(
-                    f"Product '{product_ID}' not found for Provider '{provider}'."
-                )
+                msg = f"Product type '{product_type}' not found for provider '{provider}'."
+                raise UnsupportedProductType(msg)
         else:
-            raise KeyError(f"Provider '{provider}' not found.")
+            msg = f"Provider '{provider}' not found."
+            raise UnsupportedProvider(msg)
 
     def _share_credentials(self) -> None:
         """