Fixx issue #29. Start using pydantic models instead of dataclasses

Author: Ihor Bilous

.gitignore

@@ -8,6 +8,9 @@ dist/
 # IntelliJ's project specific settings
 .idea/
 
+# VSCode's project specific settings
+.vscode/
+
 # mypy
 .mypy_cache/
 

README.md

@@ -17,7 +17,7 @@ Versions of this package up to 1.0.1 were a different, unrelated project, that i
 
 ### Prerequisites
 
-- Python version 3.6+
+- Python version 3.9+
 
 ### Install package
 
@@ -150,7 +150,7 @@ To setup virtual environments, run tests and linters use:
 tox
 ```
 
-It will create virtual environments with all installed dependencies for each available python interpreter (starting from `python3.6`) on your machine.
+It will create virtual environments with all installed dependencies for each available python interpreter (starting from `python3.9`) on your machine.
 By default, they will be available in `{project}/.tox/` directory. So, for instance, to activate `python3.11` environment, run the following:
 
 ```bash

examples/testing/projects.py

@@ -1,10 +1,7 @@
-import os
-import sys
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')))
-
 from typing import Optional
+
 from mailtrap import MailtrapClient
-from mailtrap.models.projects import Project
+from mailtrap.schemas.projects import Project
 
 API_TOKEN = "YOU_API_TOKEN"
 ACCOUNT_ID = "YOU_ACCOUNT_ID"
@@ -17,14 +14,15 @@ def find_project_by_name(project_name: str, projects: list[Project]) -> Optional
     return None
 
 
-client = MailtrapClient(token=API_TOKEN, account_id=ACCOUNT_ID)
-api = client.testing.projects
+MailtrapClient.configure_access_token(API_TOKEN)
+testing_api = MailtrapClient.get_testing_api(ACCOUNT_ID)
+projects_api = testing_api.projects
 
 project_name = "Example-project"
 
-created_project = api.create(project_name=project_name)
-projects = api.get_list()
+created_project = projects_api.create(project_name=project_name)
+projects = projects_api.get_list()
 project_id = find_project_by_name(project_name, projects)
-project = api.get_by_id(project_id)
-updated_projected = api.update(project_id, "Updated-project-name")
-api.delete(project_id)
+project = projects_api.get_by_id(project_id)
+updated_projected = projects_api.update(project_id, "Updated-project-name")
+deleted_object = projects_api.delete(project_id)

mailtrap/api/resources/projects.py

@@ -1,37 +1,39 @@
 from mailtrap.http import HttpClient
-from mailtrap.models.base import DeletedObject
-from mailtrap.models.projects import Project
+from mailtrap.schemas.base import DeletedObject
+from mailtrap.schemas.projects import Project
 
 
 class ProjectsApi:
-    def __init__(self, account_id: str, client: HttpClient) -> None:
+    def __init__(self, client: HttpClient, account_id: str) -> None:
         self.account_id = account_id
         self.client = client
 
     def get_list(self) -> list[Project]:
         response = self.client.list(f"/api/accounts/{self.account_id}/projects")
-        return [Project.from_dict(project) for project in response]
+        return [Project(**project) for project in response]
 
-    def get_by_id(self, project_id: str) -> Project:
-        response = self.client.get(f"/api/accounts/{self.account_id}/projects/{project_id}")
-        return Project.from_dict(response)
+    def get_by_id(self, project_id: int) -> Project:
+        response = self.client.get(
+            f"/api/accounts/{self.account_id}/projects/{project_id}"
+        )
+        return Project(**response)
 
     def create(self, project_name: str) -> Project:
         response = self.client.post(
             f"/api/accounts/{self.account_id}/projects",
             json={"project": {"name": project_name}},
         )
-        return Project.from_dict(response)
+        return Project(**response)
 
-    def update(self, project_id: str, project_name: str) -> Project:
+    def update(self, project_id: int, project_name: str) -> Project:
         response = self.client.patch(
             f"/api/accounts/{self.account_id}/projects/{project_id}",
             json={"project": {"name": project_name}},
         )
-        return Project.from_dict(response)
+        return Project(**response)
 
-    def delete(self, project_id: str) -> DeletedObject:
+    def delete(self, project_id: int) -> DeletedObject:
         response = self.client.delete(
             f"/api/accounts/{self.account_id}/projects/{project_id}",
         )
-        return DeletedObject(response["id"])
+        return DeletedObject(**response)

mailtrap/api/testing.py

@@ -1,11 +1,15 @@
+from typing import Optional
 
-from mailtrap.api.resources.projects import ProjectsApi 
+from mailtrap.api.resources.projects import ProjectsApi
 from mailtrap.http import HttpClient
 
 
 class TestingApi:
-    def __init__(self, account_id: str, client: HttpClient) -> None:
+    def __init__(
+        self, client: HttpClient, account_id: str, inbox_id: Optional[str] = None
+    ) -> None:
         self.account_id = account_id
+        self.inbox_id = inbox_id
         self.client = client
 
     @property

mailtrap/client.py

@@ -19,37 +19,38 @@ class MailtrapClient:
     BULK_HOST = "bulk.api.mailtrap.io"
     SANDBOX_HOST = "sandbox.api.mailtrap.io"
 
+    _default_token: Optional[str] = None
+
     def __init__(
         self,
-        token: str,
         api_host: Optional[str] = None,
         api_port: int = DEFAULT_PORT,
         bulk: bool = False,
         sandbox: bool = False,
         inbox_id: Optional[str] = None,
-        account_id: Optional[str] = None,
     ) -> None:
-        self.token = token
         self.api_host = api_host
         self.api_port = api_port
         self.bulk = bulk
         self.sandbox = sandbox
         self.inbox_id = inbox_id
-        self.account_id = account_id
 
         self._validate_itself()
 
-    @property
-    def testing(self) -> TestingApi:
-        if not self.account_id:
-            raise ClientConfigurationError("`account_id` is required for Testing API")
+    @classmethod
+    def configure_access_token(cls, token: str) -> None:
+        cls._default_token = token
 
-        http_client = HttpClient(host=MAILTRAP_HOST, headers=self.headers)
-        return TestingApi(account_id=self.account_id, client=http_client)
+    @classmethod
+    def get_testing_api(
+        cls, account_id: str, inbox_id: Optional[str] = None
+    ) -> TestingApi:
+        http_client = HttpClient(host=MAILTRAP_HOST, headers=cls.get_default_headers())
+        return TestingApi(account_id=account_id, inbox_id=inbox_id, client=http_client)
 
     def send(self, mail: BaseMail) -> dict[str, Union[bool, list[str]]]:
         response = requests.post(
-            self.api_send_url, headers=self.headers, json=mail.api_data
+            self.api_send_url, headers=self.get_default_headers(), json=mail.api_data
         )
 
         if response.ok:
@@ -70,10 +71,16 @@ def api_send_url(self) -> str:
 
         return url
 
-    @property
-    def headers(self) -> dict[str, str]:
+    @classmethod
+    def get_default_headers(cls) -> dict[str, str]:
+        if cls._default_token is None:
+            raise ValueError(
+                "Access token is not configured. "
+                "Call MailtrapClient.configure_token(...) first."
+            )
+
         return {
-            "Authorization": f"Bearer {self.token}",
+            "Authorization": f"Bearer {cls._default_token}",
             "Content-Type": "application/json",
             "User-Agent": (
                 "mailtrap-python (https://github.com/railsware/mailtrap-python)"

mailtrap/http.py

@@ -1,7 +1,10 @@
-from typing import Any, Optional, Type, TypeVar
+from typing import Any
 from typing import NoReturn
+from typing import Optional
+from typing import TypeVar
 
-from requests import Response, Session
+from requests import Response
+from requests import Session
 
 from mailtrap.config import DEFAULT_REQUEST_TIMEOUT
 from mailtrap.exceptions import APIError
@@ -12,10 +15,10 @@
 
 class HttpClient:
     def __init__(
-        self, 
-        host: str, 
-        headers: Optional[dict[str, str]] = None, 
-        timeout: int = DEFAULT_REQUEST_TIMEOUT
+        self,
+        host: str,
+        headers: Optional[dict[str, str]] = None,
+        timeout: int = DEFAULT_REQUEST_TIMEOUT,
     ):
         self._host = host
         self._session = Session()
@@ -39,16 +42,15 @@ def _handle_failed_response(self, response: Response) -> NoReturn:
 
         raise APIError(status_code, errors=errors)
 
-    def _process_response(
-        self, 
-        response: Response, 
-        expected_type: Type[T]
-    ) -> T:
+    def _process_response(self, response: Response, expected_type: type[T]) -> T:
         if not response.ok:
             self._handle_failed_response(response)
         data = response.json()
         if not isinstance(data, expected_type):
-            raise APIError(response.status_code, errors=[f"Expected response type {expected_type.__name__}"])
+            raise APIError(
+                response.status_code,
+                errors=[f"Expected response type {expected_type.__name__}"],
+            )
         return data
 
     def _process_response_dict(self, response: Response) -> dict[str, Any]:
@@ -57,43 +59,29 @@ def _process_response_dict(self, response: Response) -> dict[str, Any]:
     def _process_response_list(self, response: Response) -> list[dict[str, Any]]:
         return self._process_response(response, list)
 
-    def get(
-        self, 
-        path: str, 
-        params: Optional[dict[str, Any]] = None
-    ) -> dict[str, Any]:
-        response = self._session.get(self._url(path), params=params, timeout=self._timeout)
+    def get(self, path: str, params: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        response = self._session.get(
+            self._url(path), params=params, timeout=self._timeout
+        )
         return self._process_response_dict(response)
-    
+
     def list(
-        self, 
-        path: str, 
-        params: Optional[dict[str, Any]] = None
+        self, path: str, params: Optional[dict[str, Any]] = None
     ) -> list[dict[str, Any]]:
-        response = self._session.get(self._url(path), params=params, timeout=self._timeout)
+        response = self._session.get(
+            self._url(path), params=params, timeout=self._timeout
+        )
         return self._process_response_list(response)
 
-    def post(
-        self, 
-        path: str, 
-        json: Optional[dict[str, Any]] = None
-    ) -> dict[str, Any]:
+    def post(self, path: str, json: Optional[dict[str, Any]] = None) -> dict[str, Any]:
         response = self._session.post(self._url(path), json=json, timeout=self._timeout)
         return self._process_response_dict(response)
 
-    def put(
-        self, 
-        path: str, 
-        json: Optional[dict[str, Any]] = None
-    ) -> dict[str, Any]:
+    def put(self, path: str, json: Optional[dict[str, Any]] = None) -> dict[str, Any]:
         response = self._session.put(self._url(path), json=json, timeout=self._timeout)
         return self._process_response_dict(response)
 
-    def patch(
-        self, 
-        path: str, 
-        json: Optional[dict[str, Any]] = None
-    ) -> dict[str, Any]:
+    def patch(self, path: str, json: Optional[dict[str, Any]] = None) -> dict[str, Any]:
         response = self._session.patch(self._url(path), json=json, timeout=self._timeout)
         return self._process_response_dict(response)
 
@@ -102,11 +90,11 @@ def delete(self, path: str) -> dict[str, Any]:
         return self._process_response_dict(response)
 
 
-def _extract_errors(data: dict[str, Any]) -> list[str]:    
+def _extract_errors(data: dict[str, Any]) -> list[str]:
     def flatten_errors(errors: Any) -> list[str]:
         if isinstance(errors, list):
             return [str(error) for error in errors]
-        
+
         if isinstance(errors, dict):
             flat_errors = []
             for key, value in errors.items():
@@ -117,10 +105,10 @@ def flatten_errors(errors: Any) -> list[str]:
             return flat_errors
 
         return [str(errors)]
-    
+
     if "errors" in data:
         return flatten_errors(data["errors"])
-    
+
     if "error" in data:
         return flatten_errors(data["error"])