Fix issue #29: Fixed names, changed location of methods

Author: Ihor Bilous

examples/testing/projects.py

@@ -1,54 +1,25 @@
-import logging
-from typing import Optional
-
 from mailtrap import MailtrapApiClient
 from mailtrap.models.projects import Project
 
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
 API_TOKEN = "YOU_API_TOKEN"
 ACCOUNT_ID = "YOU_ACCOUNT_ID"
 
-
-def find_project_by_name(project_name: str, projects: list[Project]) -> Optional[str]:
-    filtered_projects = [project for project in projects if project.name == project_name]
-    if filtered_projects:
-        return filtered_projects[0].id
-    return None
-
-
-logging.info("Starting Mailtrap Testing API example...")
-
 client = MailtrapApiClient(token=API_TOKEN)
-testing_api = client.get_testing_api(ACCOUNT_ID)
+testing_api = client.testing_api(ACCOUNT_ID)
 projects_api = testing_api.projects
 
-project_name = "Example-project"
-created_project = projects_api.create(project_name=project_name)
-logging.info(f"Project created! ID: {created_project.id}, Name: {created_project.name}")
 
-projects = projects_api.get_list()
-logging.info(f"Found {len(projects)} projects:")
-for project in projects:
-    logging.info(f"   - {project.name} (ID: {project.id})")
+def list_projects() -> list[Project]:
+    return projects_api.get_list()
+
 
-project_id = find_project_by_name(project_name, projects)
-if project_id:
-    logging.info(f"Found project with ID: {project_id}")
-else:
-    logging.info("Project not found in the list")
+def create_project(project_name: str) -> Project:
+    return projects_api.create(project_name=project_name)
 
-if project_id:
-    project = projects_api.get_by_id(project_id)
-    logging.info(f"Project details: {project.name} (ID: {project.id})")
 
-    new_name = "Updated-project-name"
-    updated_project = projects_api.update(project_id, new_name)
-    logging.info(f"Project updated!ID: {project_id}, New name: {updated_project.name}")
+def update_project(project_id: str, new_name: str) -> Project:
+    return projects_api.update(project_id, new_name)
 
-    deleted_object = projects_api.delete(project_id)
-    logging.info(f"Project deleted! Deleted ID: {deleted_object.id}")
 
-logging.info("Example completed successfully!")
+def delete_project(project_id: str):
+    return projects_api.delete(project_id)

mailtrap/api/resources/projects.py

@@ -1,5 +1,5 @@
 from mailtrap.http import HttpClient
-from mailtrap.models.base import DeletedObject
+from mailtrap.models.common import DeletedObject
 from mailtrap.models.projects import Project
 
 
@@ -9,7 +9,7 @@ def __init__(self, client: HttpClient, account_id: str) -> None:
         self.client = client
 
     def get_list(self) -> list[Project]:
-        response = self.client.list(f"/api/accounts/{self.account_id}/projects")
+        response = self.client.get(f"/api/accounts/{self.account_id}/projects")
         return [Project(**project) for project in response]
 
     def get_by_id(self, project_id: int) -> Project:

mailtrap/client.py

@@ -107,11 +107,12 @@ class MailtrapApiClient:
     def __init__(self, token: str) -> None:
         self.token = token
 
-    def testing_api(self, account_id: str, inbox_id: str) -> TestingApi:
-        http_client = HttpClient(host=GENERAL_ENDPOINT, headers=self.get_headers())
+    def testing_api(self, account_id: str, inbox_id: Optional[str] = None) -> TestingApi:
+        http_client = HttpClient(host=GENERAL_ENDPOINT, headers=self.headers)
         return TestingApi(account_id=account_id, inbox_id=inbox_id, client=http_client)
 
-    def get_headers(self) -> dict[str, str]:
+    @property
+    def headers(self) -> dict[str, str]:
         return {
             "Authorization": f"Bearer {self.token}",
             "Content-Type": "application/json",

mailtrap/http.py

@@ -22,40 +22,12 @@ def __init__(
         self._session.headers.update(headers or {})
         self._timeout = timeout
 
-    def _url(self, path: str) -> str:
-        return f"https://{self._host}/{path.lstrip('/')}"
-
-    def _handle_failed_response(self, response: Response) -> NoReturn:
-        status_code = response.status_code
-        try:
-            data = response.json()
-        except ValueError as exc:
-            raise APIError(status_code, errors=["Unknown Error"]) from exc
-
-        errors = _extract_errors(data)
-
-        if status_code == 401:
-            raise AuthorizationError(errors=errors)
-
-        raise APIError(status_code, errors=errors)
-
-    def _process_response(self, response: Response) -> Any:
-        if not response.ok:
-            self._handle_failed_response(response)
-        return response.json()
-
     def get(self, path: str, params: Optional[dict[str, Any]] = None) -> Any:
         response = self._session.get(
             self._url(path), params=params, timeout=self._timeout
         )
         return self._process_response(response)
 
-    def list(self, path: str, params: Optional[dict[str, Any]] = None) -> Any:
-        response = self._session.get(
-            self._url(path), params=params, timeout=self._timeout
-        )
-        return self._process_response(response)
-
     def post(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
         response = self._session.post(self._url(path), json=json, timeout=self._timeout)
         return self._process_response(response)
@@ -72,27 +44,49 @@ def delete(self, path: str) -> Any:
         response = self._session.delete(self._url(path), timeout=self._timeout)
         return self._process_response(response)
 
+    def _url(self, path: str) -> str:
+        return f"https://{self._host}/{path.lstrip('/')}"
+
+    def _process_response(self, response: Response) -> Any:
+        if not response.ok:
+            self._handle_failed_response(response)
+        return response.json()
+
+    def _handle_failed_response(self, response: Response) -> NoReturn:
+        status_code = response.status_code
+        try:
+            data = response.json()
+        except ValueError as exc:
+            raise APIError(status_code, errors=["Unknown Error"]) from exc
+
+        errors = self._extract_errors(data)
+
+        if status_code == 401:
+            raise AuthorizationError(errors=errors)
+
+        raise APIError(status_code, errors=errors)
 
-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]
+    @staticmethod
+    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():
-                if isinstance(value, list):
-                    flat_errors.extend([f"{key}: {v}" for v in value])
-                else:
-                    flat_errors.append(f"{key}: {value}")
-            return flat_errors
+            if isinstance(errors, dict):
+                flat_errors = []
+                for key, value in errors.items():
+                    if isinstance(value, list):
+                        flat_errors.extend([f"{key}: {v}" for v in value])
+                    else:
+                        flat_errors.append(f"{key}: {value}")
+                return flat_errors
 
-        return [str(errors)]
+            return [str(errors)]
 
-    if "errors" in data:
-        return flatten_errors(data["errors"])
+        if "errors" in data:
+            return flatten_errors(data["errors"])
 
-    if "error" in data:
-        return flatten_errors(data["error"])
+        if "error" in data:
+            return flatten_errors(data["error"])
 
-    return ["Unknown error"]
+        return ["Unknown error"]

mailtrap/models/base.py renamed to mailtrap/models/common.py

@@ -0,0 +1,11 @@
+UNAUTHORIZED_STATUS_CODE = 401
+UNAUTHORIZED_ERROR_MESSAGE = "Incorrect API token"
+UNAUTHORIZED_RESPONSE = {"error": UNAUTHORIZED_ERROR_MESSAGE}
+
+FORBIDDEN_STATUS_CODE = 403
+FORBIDDEN_ERROR_MESSAGE = "Access forbidden"
+FORBIDDEN_RESPONSE = {"errors": FORBIDDEN_ERROR_MESSAGE}
+
+NOT_FOUND_STATUS_CODE = 404
+NOT_FOUND_ERROR_MESSAGE = "Not Found"
+NOT_FOUND_RESPONSE = {"error": NOT_FOUND_ERROR_MESSAGE}