django-esi 8.0.0a1__py3-none-any.whl → 8.0.0a3__py3-none-any.whl

esi/openapi_clients.py

@@ -1,11 +1,13 @@
 import logging
 import warnings
-from datetime import datetime
+from datetime import datetime, date
 from hashlib import md5
 from typing import Any
 
 from aiopenapi3 import OpenAPI
 from aiopenapi3._types import ResponseDataType, ResponseHeadersType
+from aiopenapi3.errors import HTTPServerError as base_HTTPServerError
+from aiopenapi3.errors import HTTPClientError as base_HTTPClientError
 from aiopenapi3.request import OperationIndex, RequestBase
 from httpx import (
     AsyncClient, Client, HTTPStatusError, RequestError, Response, Timeout,
@@ -18,7 +20,8 @@ from tenacity import (
 from django.core.cache import cache
 
 from esi import app_settings
-from esi.aiopenapi3.plugins import PatchCompatibilityDatePlugin
+from esi.exceptions import HTTPClientError, HTTPServerError, HTTPNotModified
+from esi.aiopenapi3.plugins import Add304ContentType, PatchCompatibilityDatePlugin, Trim204ContentType
 from esi.exceptions import ESIErrorLimitException
 from esi.models import Token
 from esi.stubs import ESIClientStub
@@ -121,14 +124,14 @@ def _load_aiopenapi_client_sync(
             path=spec_file,
             session_factory=session_factory,
             use_operation_tags=True,
-            plugins=[PatchCompatibilityDatePlugin()]
+            plugins=[PatchCompatibilityDatePlugin(), Trim204ContentType(), Add304ContentType()]
         )
     else:
         return OpenAPI.load_sync(
             url=spec_url,
             session_factory=session_factory,
             use_operation_tags=True,
-            plugins=[PatchCompatibilityDatePlugin()]
+            plugins=[PatchCompatibilityDatePlugin(), Trim204ContentType(), Add304ContentType()]
         )
 
 
@@ -176,14 +179,14 @@ async def _load_aiopenapi_client_async(
             path=spec_file,
             session_factory=session_factory,
             use_operation_tags=True,
-            plugins=[PatchCompatibilityDatePlugin()]
+            plugins=[PatchCompatibilityDatePlugin(), Trim204ContentType(), Add304ContentType()]
         )
     else:
         return await OpenAPI.load_async(
             url=spec_url,
             session_factory=session_factory,
             use_operation_tags=True,
-            plugins=[PatchCompatibilityDatePlugin()]
+            plugins=[PatchCompatibilityDatePlugin(), Trim204ContentType(), Add304ContentType()]
         )
 
 
@@ -322,10 +325,25 @@ class BaseEsiOperation():
         Returns:
             str: Key name
         """
-        data = (self.method + self.url + str(self._args) + str(self._kwargs)).encode('utf-8')
+        # ignore the token this will break the cache
+        ignore_keys = [
+            "token",
+        ]
+        _kwargs = { key:value for key, value in self._kwargs.items() if key not in ignore_keys }
+        data = (self.method + self.url + str(self._args) + str(_kwargs)).encode('utf-8')
         str_hash = md5(data).hexdigest()  # nosec B303
         return f'esi_{str_hash}'
 
+    def _extract_body_param(self) -> Token | None:
+        """Pop the request body from parameters to be able to check the param validity
+        Returns:
+            Any | None: the request body
+        """
+        _body = self._kwargs.pop("body", None)
+        if _body and not getattr(self.operation, "requestBody", False):
+            raise ValueError("Request Body provided on endpoint with no request body paramater.")
+        return _body
+
     def _extract_token_param(self) -> Token | None:
         """Pop token from parameters or use the Client wide token if set
         Returns:
@@ -350,7 +368,7 @@ class BaseEsiOperation():
         """
         return any(p.name == "before" or p.name == "after" for p in self.operation.parameters)
 
-    def _get_cache(self, cache_key: str) -> tuple[ResponseHeadersType | None, Any, Response | None]:
+    def _get_cache(self, cache_key: str, etag: str) -> tuple[ResponseHeadersType | None, Any, Response | None]:
         """Retrieve cached response and validate expiry
         Args:
             cache_key (str): The cache key to retrieve
@@ -366,12 +384,23 @@ class BaseEsiOperation():
 
         if cached_response:
             logger.debug(f"Cache Hit {self.url}")
-            headers, data = self.parse_cached_request(cached_response)
+            expiry = _time_to_expiry(str(cached_response.headers.get('Expires')))
 
-            expiry = _time_to_expiry(str(headers.get('Expires')))
+            # force check to ensure cache isn't expired
             if expiry < 0:
                 logger.warning("Cache expired by %d seconds, forcing expiry", expiry)
                 return None, None, None
+
+            # check if etag is same before building models from cache
+            if etag:
+                if cached_response.headers.get('Expires') == etag:
+                    raise HTTPNotModified(
+                        status_code=304,
+                        headers=cached_response.headers
+                    )
+
+            # build models
+            headers, data = self.parse_cached_request(cached_response)
             return headers, data, cached_response
 
         return None, None, None
@@ -450,7 +479,7 @@ class EsiOperation(BaseEsiOperation):
                     req.req.headers["Authorization"] = f"Bearer {self.token.valid_access_token()}"
             if etag:
                 req.req.headers["If-None-Match"] = etag
-            return req.request(parameters=self._unnormalize_parameters(parameters))
+            return req.request(data=self.body, parameters=self._unnormalize_parameters(parameters))
         return retry(__func)
 
     def result(
@@ -467,6 +496,7 @@ class EsiOperation(BaseEsiOperation):
         """
 
         self.token = self._extract_token_param()
+        self.body = self._extract_body_param()
         parameters = self._kwargs | extra
         cache_key = self._cache_key()
         etag_key = f"{cache_key}_etag"
@@ -474,7 +504,7 @@ class EsiOperation(BaseEsiOperation):
         if not etag and app_settings.ESI_CACHE_RESPONSE:
             etag = cache.get(etag_key)
 
-        headers, data, response = self._get_cache(cache_key)
+        headers, data, response = self._get_cache(cache_key, etag=etag) if use_cache else (None, None, None)
 
         if response and use_cache:
             expiry = _time_to_expiry(str(headers.get('Expires')))
@@ -488,17 +518,41 @@ class EsiOperation(BaseEsiOperation):
 
         if not response:
             logger.debug(f"Cache Miss {self.url}")
-            headers, data, response = self._make_request(parameters, etag)
-            if response.status_code == 420:
-                reset = response.headers.get("X-RateLimit-Reset", None)
-                cache.set("esi_error_limit_reset", reset, timeout=reset)
-                raise ESIErrorLimitException(reset=reset)
-            # if response.status_code == 304 and app_settings.ESI_CACHE_RESPONSE:
-            #     cached = cache.get(cache_key)
-            #     if cached:
-            #         return (cached, response) if return_response else cached
-            # we dont want to do this, if we do this we have to store data longer than ttl. rip ram
-            self._store_cache(cache_key, response)
+            try:
+                headers, data, response = self._make_request(parameters, etag)
+                if response.status_code == 420:
+                    reset = response.headers.get("X-RateLimit-Reset", None)
+                    cache.set("esi_error_limit_reset", reset, timeout=reset)
+                    raise ESIErrorLimitException(reset=reset)
+                self._store_cache(cache_key, response)
+
+                # if response.status_code == 304 and app_settings.ESI_CACHE_RESPONSE:
+                #     cached = cache.get(cache_key)
+                #     if cached:
+                #         return (cached, response) if return_response else cached
+                # we dont want to do this, if we do this we have to store data longer than ttl. rip ram
+
+            # Shim our exceptions into Django-ESI
+            except base_HTTPServerError as e:
+                raise HTTPServerError(
+                    status_code=e.status_code,
+                    headers=e.headers,
+                    data=e.data
+                )
+
+            except base_HTTPClientError as e:
+                raise HTTPClientError(
+                    status_code=e.status_code,
+                    headers=e.headers,
+                    data=e.data
+                )
+
+            # Throw a 304 exception for catching.
+            if response.status_code == 304:
+                raise HTTPNotModified(
+                    status_code=304,
+                    headers=response.headers
+                )
 
         return (data, response) if return_response else data
 
@@ -508,8 +562,8 @@ class EsiOperation(BaseEsiOperation):
             return_response: bool = False,
             use_cache: bool = True,
             **extra) -> tuple[list[Any], Response | Any | None] | list[Any]:
-        all_results = []
-        last_response = None
+        all_results: list[Any] = []
+        last_response: Response | None = None
         """Executes the request and returns the response from ESI for the current
         operation. Response will include all pages if there are more available.
 
@@ -557,10 +611,31 @@ class EsiOperation(BaseEsiOperation):
 
         return (all_results, last_response) if return_response else all_results
 
-    def results_localized(self, languages: str | list[str] = "en", **kwargs) -> list[Any]:
-        # We can either push Accept-Language up to the library level
-        # OR we insert the parameter into each request here
-        raise NotImplementedError()
+    def results_localized(
+            self,
+            languages: list[str] | str | None = None,
+            **kwargs) -> dict[str, list[Any]]:
+        """Executes the request and returns the response from ESI for all default languages and pages (if any).
+        Args:
+            languages: (list[str], str, optional) language(s) to return instead of default languages
+        Raises:
+            ValueError: Invalid or Not Supported Language Code ...
+        Returns:
+            dict[str, list[Any]]: Dict of all responses with the language code as keys.
+        """
+        if not languages:
+            my_languages = list(app_settings.ESI_LANGUAGES)
+        else:
+            my_languages = []
+            for lang in dict.fromkeys(languages):
+                if lang not in app_settings.ESI_LANGUAGES:
+                    raise ValueError('Invalid or Not Supported Language Code: %s' % lang)
+                my_languages.append(lang)
+
+        return {
+            language: self.results(accept_language=language, **kwargs)
+            for language in my_languages
+        }
 
     def required_scopes(self) -> list[str]:
         """Return a simple list of scopes required for an endpoint. #Requires loading and processing a client
@@ -678,8 +753,31 @@ class EsiOperationAsync(BaseEsiOperation):
 
         return (all_results, last_response) if return_response else all_results
 
-    async def results_localized(self, languages: str | list[str] = "en", **kwargs) -> list[Any]:
-        raise NotImplementedError()
+    def results_localized(
+            self,
+            languages: list[str] | str | None = None,
+            **extra) -> dict[str, list[Any]]:
+        """Executes the request and returns the response from ESI for all default languages and pages (if any).
+        Args:
+            languages: (list[str], str, optional) language(s) to return instead of default languages
+        Raises:
+            ValueError: Invalid or Not Supported Language Code ...
+        Returns:
+            dict[str, list[Any]]: Dict of all responses with the language code as keys.
+        """
+        if not languages:
+            my_languages = list(app_settings.ESI_LANGUAGES)
+        else:
+            my_languages = []
+            for lang in dict.fromkeys(languages):
+                if lang not in app_settings.ESI_LANGUAGES:
+                    raise ValueError('Invalid or Not Supported Language Code: %s' % lang)
+                my_languages.append(lang)
+
+        return {
+            language: self.results(accept_language=language, **kwargs)
+            for language in my_languages
+        }
 
     def required_scopes(self) -> list[str]:
         """Return a simple list of scopes required for an endpoint. #Requires loading and processing a client
@@ -749,7 +847,11 @@ class ESIClient(ESIClientStub):
         if tag == "_":
             return self.api._operationindex
 
-        elif tag in set(self.api._operationindex._tags.keys()):
+        # convert pythonic Planetary_Interaction to Planetary Interaction
+        if "_" in tag:
+            tag = tag.replace("_", " ")
+
+        if tag in set(self.api._operationindex._tags.keys()):
             return ESITag(self.api._operationindex._tags[tag], self.api)
 
         raise AttributeError(
@@ -772,7 +874,11 @@ class ESIClientAsync(ESIClientStub):
         if tag == "_":
             return self.api._operationindex
 
-        elif tag in set(self.api._operationindex._tags.keys()):
+        # convert pythonic Planetary_Interaction to Planetary Interaction
+        if "_" in tag:
+            tag = tag.replace("_", " ")
+
+        if tag in set(self.api._operationindex._tags.keys()):
             return ESITagAsync(self.api._operationindex._tags[tag], self.api)
 
         raise AttributeError(
@@ -784,7 +890,7 @@ class ESIClientAsync(ESIClientStub):
 class ESIClientProvider:
     """Class for providing a single ESI client instance for a whole app
     Args:
-        compatibility_date (str): The compatibility date for the ESI client.
+        compatibility_date (str | date): The compatibility date for the ESI client.
         ua_appname (str): Name of the App for generating a User-Agent,
         ua_version (str): Version of the App for generating a User-Agent,
         ua_url (str, Optional): URL To the Source Code or Documentation for generating a User-Agent,
@@ -795,9 +901,12 @@ class ESIClientProvider:
         client_async(): ESIClientAsync
     """
 
+    _client: ESIClient | None = None
+    _client_async: ESIClientAsync | None = None
+
     def __init__(
         self,
-        compatibility_date: str,
+        compatibility_date: str | date,
         ua_appname: str,
         ua_version: str,
         ua_url: str | None = None,
@@ -805,7 +914,10 @@ class ESIClientProvider:
         tenant: str = "tranquility",
         **kwargs
     ) -> None:
-        self._compatibility_date = compatibility_date
+        if type(compatibility_date) is date:
+            self._compatibility_date = self._date_to_string(compatibility_date)
+        else:
+            self._compatibility_date = compatibility_date
         self._ua_appname = ua_appname
         self._ua_version = ua_version
         self._ua_url = ua_url
@@ -841,5 +953,11 @@ class ESIClientProvider:
             self._client_async = ESIClientAsync(api)
         return self._client_async
 
+    @classmethod
+    def _date_to_string(cls, compatibility_date: date) -> str:
+        """Turns a date object in a compatibility_date string"""
+        return f"{compatibility_date.year}-{compatibility_date.month:02}-{compatibility_date.day:02}"
+
+
     def __str__(self) -> str:
         return "ESIClientProvider"