django-esi 8.1.0__py3-none-any.whl

esi/admin.py

@@ -0,0 +1,42 @@
+from django.contrib import admin
+from django.contrib.auth import get_user_model
+from django.db.models import QuerySet
+
+from .models import CallbackRedirect, Scope, Token
+
+admin.site.register(CallbackRedirect)
+
+
+@admin.register(Scope)
+class ScopeAdmin(admin.ModelAdmin):
+    list_display = ('name', 'help_text')
+
+
+@admin.register(Token)
+class TokenAdmin(admin.ModelAdmin):
+    def get_queryset(self, request) -> QuerySet["Token"]:
+        qs = super().get_queryset(request)
+        return qs.select_related('user').prefetch_related('scopes')
+
+    @admin.display(
+        description='Scopes'
+    )
+    def get_scopes(self, obj) -> str:
+        return ", ".join([x.name for x in obj.scopes.all()])
+
+    User = get_user_model()
+    list_display = ('user', 'character_name', 'get_scopes')
+    search_fields = ['user__%s' % User.USERNAME_FIELD, 'character_name', 'scopes__name']
+    list_filter = (
+        ('user', admin.RelatedOnlyFieldListFilter),
+        'character_name'
+    )
+    ordering = ('user',)
+    readonly_fields = (
+        'character_id',
+        'character_name',
+        'token_type',
+        'character_owner_hash',
+        'scopes',
+        'sso_version'
+    )

esi/aiopenapi3/client.py

@@ -0,0 +1,79 @@
+import datetime as dt
+from hashlib import md5
+
+from httpx import URL, Client, Response
+from httpx._client import USE_CLIENT_DEFAULT, UseClientDefault
+from httpx._types import (
+    AuthTypes, CookieTypes, HeaderTypes, QueryParamTypes, RequestExtensions,
+    TimeoutTypes,
+)
+
+from django.core.cache import cache
+from django.utils import timezone
+
+
+class SpecCachingClient(Client):
+
+    def _is_spec(self, url: URL | str) -> bool:
+        return "https://esi.evetech.net/meta/openapi" in str(url)
+
+    def _get_seconds_to_dt(self) -> int:
+        expire_time = timezone.now()
+        if expire_time.hour > 11:
+            expire_time += dt.timedelta(hours=24)
+
+        expire_time = expire_time.replace(hour=11, minute=30, second=0)
+
+        return int((expire_time - timezone.now()).total_seconds())
+
+    def _get_spec_cache(self, url, ):
+        return cache.get(self._get_api_cache_key(url), False)
+
+    def _set_spec_cache(self, url, body):
+        ttl = self._get_seconds_to_dt()
+        cache.set(self._get_api_cache_key(url), body, ttl)
+
+    def _get_api_cache_key(self, url: str) -> str:
+        """
+            provide a unique token for the spec url with compat date.
+        """
+        compat_date = self.headers.get("X-Compatibility-Date", None)
+        return f"ESI_API_CACHE_{md5(f'{url}-{compat_date}'.encode()).hexdigest()}"
+
+    def get(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        if self._is_spec(url):
+            _spec = self._get_spec_cache(url)
+            if not _spec:
+                _spec = super().get(
+                    url,
+                    params=params,
+                    headers=headers,
+                    cookies=cookies,
+                    auth=auth,
+                    follow_redirects=follow_redirects,
+                    timeout=timeout,
+                    extensions=extensions
+                )
+                self._set_spec_cache(url, _spec)
+            return _spec
+        return super().get(
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions
+        )

esi/aiopenapi3/plugins.py

@@ -0,0 +1,224 @@
+import logging
+from typing import Any
+
+from collections.abc import Generator
+from django.conf import settings
+
+from aiopenapi3.plugin import Document, Init
+
+logger = logging.getLogger(__name__)
+
+
+class Trim204ContentType(Document):
+    """
+    Removes and content-type from responses on a 204 reponses
+    A 204 never has content...
+    """
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+        spec = ctx.document
+        # Patch all paths
+        for path_item in spec.get("paths", {}).values():
+            for method_name in ("get", "post", "put", "delete", "patch", "options", "head"):
+                method = path_item.get(method_name)
+                if not method:
+                    continue
+                if "204" in method['responses']:
+                    method['responses']["204"].pop("content", [])
+        return ctx
+
+
+def find_refs_recursively(data: Any, parent: Any = None) -> Generator[Any, None, None]:
+    """
+    Recursively searches for all instances of "#ref" in a dict+children and returns schemas.
+    """
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if key == "$ref":
+                if "#/components/schemas/" in value:
+                    next = value.split("/")[-1]
+                    yield next
+                    if parent:
+                        yield from find_refs_recursively(parent[next], parent)
+            yield from find_refs_recursively(value, parent)
+    elif isinstance(data, list):
+        for item in data:
+            yield from find_refs_recursively(item, parent)
+
+
+class MinifySpec(Document):
+    """
+    Removes operations and schemas from spec to limit memory spam
+    """
+
+    def __init__(self, tags: list[str], operations: list[str]):
+        super().__init__()
+        self.keep_tags = set(tags)
+        self.keep_ops = operations
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+
+        if len(self.keep_tags) == 0 and self.keep_ops == []:
+            logger.error("No tag/path filtering supplied to ESI Client. Using all tags. This throw an error with `DEBUG=False`!", stack_info=True)
+            if not getattr(settings, "DEBUG", False):
+                # we are in production mode throw error to protect RAM.
+                raise AttributeError("No tag/path filtering supplied to ESI Client.")
+            # We are in debug mode allow an unfiltered client.
+            return ctx
+
+        # filter the client.
+        spec = ctx.document
+
+        remove_paths = set()
+        keep_schema = set()
+        logger.debug("Filtering Paths/Tags: ")
+        for name, path_item in spec.get("paths", {}).items():
+            keep = False
+            for method_name in ("get", "post", "put", "delete", "patch", "options", "head"):
+                method = path_item.get(method_name)
+                if not method:
+                    continue
+                if len(self.keep_tags.intersection(method['tags'])) or method["operationId"] in self.keep_ops:
+                    keep = True
+                    schemas = find_refs_recursively(
+                        path_item,
+                        spec["components"]["schemas"]  # find all sub schema's
+                    )
+                    for s in schemas:
+                        keep_schema.add(s)
+
+            if not keep:
+                remove_paths.add(name)
+            else:
+                logger.debug(f" - {name}")
+
+        # remove the  paths we don't care for
+        for name in remove_paths:
+            spec["paths"].pop(name)
+
+        # build new schema from what we need
+        logger.debug("Rebuilding Schema: ")
+        new_schema = {}
+        for name, data in spec["components"]["schemas"].items():
+            if name in keep_schema:
+                logger.debug(f" - {name}")
+                new_schema[name] = data
+
+        # replace schemas with the new schema
+        ctx.document["components"]["schemas"] = new_schema
+
+        return ctx
+
+
+class Add304ContentType(Document):
+    """
+    Adds 304 content-type to responses
+    A 304 never has content. ESI defualt has application/json
+    This is a hack for now
+    """
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+        spec = ctx.document
+        # Patch all paths
+        for path_item in spec.get("paths", {}).values():
+            for method_name in ("get", "post", "put", "delete", "patch", "options", "head"):
+                method = path_item.get(method_name)
+                if not method:
+                    continue
+                if "304" not in method['responses']:
+                    method['responses']["304"] = {
+                        "description": "Not Modified"
+                    }
+        return ctx
+
+
+class RemoveSecurityParameter(Document):
+    """
+    Removes the whole OAuth2 securityScheme
+    """
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+        print("RemoveSecurityParameterPlugin: Removing OAuth2 securityScheme")
+        spec = ctx.document
+        oauth2 = spec.get("components", {}).get("securitySchemes", {}).pop("OAuth2", None)
+        # Patch all paths
+        for path_item in spec.get("paths", {}).values():
+            for method_name in ("get", "post", "put", "delete", "patch", "options", "head"):
+                method = path_item.get(method_name)
+                if not method:
+                    continue
+                method.pop("security", None)
+
+        return ctx
+
+
+class TrimSecurityParameter(Document):
+    """TrimSecurityParameter
+    Trims out of Spec OAuth2 attributes. CCP have fixed this.
+    Leaving in place in case we need a quick reference again.
+    """
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+        print("TrimSecurityParameter: Trimming out of spec attributes")
+        spec = ctx.document
+        oauth2 = spec.get("components", {}).get("securitySchemes", {}).get("OAuth2")
+        if oauth2 and oauth2.get("type") == "oauth2":
+            oauth2.pop("in", None)
+            oauth2.pop("name", None)
+        return ctx
+
+
+class PatchCompatibilityDatePlugin(Document):
+    """
+    Makes the X-Compatibility-Date header optional
+
+    This is because WE specifically add it in the library to the HTTP requests,
+    but without this, it will be a required parameter during request generation before it hits the HTTP library.
+    """
+
+    def parsed(self, ctx: Document.Context) -> Document.Context:
+        logger.debug("PatchCompatibilityDatePlugin: making compatibility date optional")
+        spec = ctx.document
+
+        def patch_param(param):
+            # Follow $ref if present
+            if "$ref" in param:
+                ref = param["$ref"]
+                parts = ref.split("/")
+                if parts[1] == "components" and parts[2] == "parameters":
+                    param_name = parts[-1]
+                    comp_param = spec.get("components", {}).get("parameters", {}).get(param_name)
+                    if comp_param and comp_param.get("name") == "X-Compatibility-Date":
+                        comp_param["required"] = False
+            else:
+                # Inline parameter
+                if (param.get("name") == "X-Compatibility-Date" and param.get("in") == "header"):
+                    param["required"] = False
+
+        # Patch all paths
+        for path_item in spec.get("paths", {}).values():
+            for method_name in ("get", "post", "put", "delete", "patch", "options", "head"):
+                method = path_item.get(method_name)
+                if not method:
+                    continue
+                for param in method.get("parameters", []):
+                    patch_param(param)
+
+        # Patch global parameters in components
+        for param_name, param in spec.get("components", {}).get("parameters", {}).items():
+            if param.get("name") == "X-Compatibility-Date" and param.get("in") == "header":
+                param["required"] = False
+
+        return ctx
+
+
+class DjangoESIInit(Init):
+
+    def __init__(self, ua_appname):
+        super().__init__()
+        self.app_name = ua_appname
+
+    def initialized(self, ctx: Init.Context) -> Init.Context:
+        # Force the app_name into the api client class for etags
+        self.api.app_name = self.app_name
+        return ctx  # noqa

esi/app_settings.py

@@ -0,0 +1,112 @@
+from django.conf import settings
+
+ESI_SSO_CLIENT_ID = getattr(settings, 'ESI_SSO_CLIENT_ID', None)
+"""Client ID of your Eve Online SSO app. REQUIRED."""
+
+ESI_SSO_CLIENT_SECRET = getattr(settings, 'ESI_SSO_CLIENT_SECRET', None)
+"""Client Secret of your Eve Online SSO app. REQUIRED."""
+
+ESI_SSO_CALLBACK_URL = getattr(settings, 'ESI_SSO_CALLBACK_URL', None)
+"""Callback for your Eve Online SSO app. REQUIRED."""
+
+# ESI_SSO_CLIENT_ID, ESI_SSO_CLIENT_SECRET ESI_SSO_CALLBACK_URL
+# are required for SSO to function.
+# Can be left blank if settings.DEBUG is set to True
+
+ESI_API_DATASOURCE = getattr(settings, 'ESI_API_DATASOURCE', 'tranquility')
+"""Change these to switch to Singularity."""
+
+ESI_API_VERSION = getattr(settings, 'ESI_API_VERSION', 'latest')
+"""Change this to access different revisions of the ESI API by default"""
+
+ESI_ALWAYS_CREATE_TOKEN = getattr(settings, 'ESI_ALWAYS_CREATE_TOKEN', False)
+"""Enable to force new token creation every callback."""
+
+ESI_CACHE_RESPONSE = getattr(settings, 'ESI_CACHE_RESPONSE', True)
+"""Disable to stop caching endpoint responses."""
+
+ESI_INFO_LOGGING_ENABLED = getattr(settings, 'ESI_INFO_LOGGING_ENABLED', False)
+"""Enable/disable verbose info logging."""
+
+ESI_LOG_LEVEL_LIBRARIES = str(getattr(settings, 'ESI_LOG_LEVEL_LIBRARIES', 'INFO'))
+"""Set log level for libraries like bravado and urlib3."""
+
+ESI_DEBUG_RESPONSE_CONTENT_LOGGING = getattr(settings, 'ESI_DEBUG_RESPONSE_CONTENT_LOGGING', True)
+"""Enable/Disable logging of ESI response contents."""
+
+ESI_USER_CONTACT_EMAIL = getattr(settings, 'ESI_USER_CONTACT_EMAIL', None)
+"""Contact email address of server owner.
+
+This will be included in the User-Agent header of every request.
+"""
+
+ESI_CONNECTION_POOL_MAXSIZE = getattr(settings, 'ESI_CONNECTION_POOL_MAXSIZE', 10)
+"""Max size of the connection pool.
+
+Increase this setting if you hav more parallel
+threads connected to ESI at the same time.
+"""
+
+ESI_CONNECTION_ERROR_MAX_RETRIES = getattr(
+    settings, 'ESI_CONNECTION_ERROR_MAX_RETRIES', 3
+)
+"""Max retries on failed connections."""
+
+ESI_SERVER_ERROR_MAX_RETRIES = getattr(settings, 'ESI_SERVER_ERROR_MAX_RETRIES', 3)
+"""Max retries on server errors."""
+
+ESI_SERVER_ERROR_BACKOFF_FACTOR = getattr(
+    settings, 'ESI_SERVER_ERROR_BACKOFF_FACTOR', 0.2
+)
+"""Backoff factor for retries on server error."""
+
+ESI_REQUESTS_CONNECT_TIMEOUT = getattr(settings, 'ESI_REQUESTS_CONNECT_TIMEOUT', 5)
+"""Default connection timeouts for all requests to ESI.
+
+Can temporarily overwritten with by passing ``timeout`` with ``result()``
+"""
+
+ESI_REQUESTS_READ_TIMEOUT = getattr(settings, 'ESI_REQUESTS_READ_TIMEOUT', 10)
+"""Default read timeouts for all requests to ESI.
+This should be a maximum of 10s as ESI cuts all requests to the monolith off @ 10s.
+
+Can temporarily overwritten with by passing ``timeout`` with ``result()``
+"""
+
+ESI_REQUESTS_WRITE_TIMEOUT = getattr(settings, 'ESI_REQUESTS_WRITE_TIMEOUT', 5)
+"""Default write timeouts for all requests to ESI.
+
+Can temporarily overwritten with by passing ``timeout`` with ``result()``
+"""
+
+ESI_REQUESTS_POOL_TIMEOUT = getattr(settings, 'ESI_REQUESTS_POOL_TIMEOUT', 5)
+"""Default pool timeouts for all requests to ESI.
+
+Can temporarily overwritten with by passing ``timeout`` with ``result()``
+"""
+
+# These probably won't ever change. Override if needed.
+ESI_API_URL = getattr(settings, 'ESI_API_URL', 'https://esi.evetech.net/')
+ESI_OAUTH_URL = getattr(
+    settings, 'ESI_SSO_BASE_URL', 'https://login.eveonline.com/v2/oauth'
+)
+ESI_OAUTH_LOGIN_URL = getattr(
+    settings, 'ESI_SSO_LOGIN_URL', ESI_OAUTH_URL + "/authorize/"
+)
+ESI_TOKEN_URL = getattr(settings, 'ESI_CODE_EXCHANGE_URL', ESI_OAUTH_URL + "/token")
+
+ESI_TOKEN_VERIFY_URL = getattr(
+    settings, 'ESI_TOKEN_EXCHANGE_URL', ESI_OAUTH_URL + "/verify"
+)  # deprecated
+ESI_TOKEN_JWK_SET_URL = "https://login.eveonline.com/oauth/jwks"
+
+ESI_TOKEN_VALID_DURATION = int(getattr(settings, 'ESI_TOKEN_VALID_DURATION', 1170))
+ESI_SPEC_CACHE_DURATION = int(getattr(settings, 'ESI_SPEC_CACHE_DURATION', 3600))
+
+# Audience claim for JWTs
+ESI_TOKEN_JWT_AUDIENCE = str(getattr(settings, "ESI_TOKEN_JWT_AUDIENCE", "EVE Online"))
+
+# list of all official language codes supported by ESI
+ESI_LANGUAGES = getattr(settings, 'ESI_LANGUAGES', [
+    'en', 'de', 'fr', 'ja', 'ru', 'zh', 'ko', 'es'
+])

esi/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+
+class EsiConfig(AppConfig):
+    default_auto_field = 'django.db.models.AutoField'
+    name = 'esi'
+    verbose_name = 'EVE Swagger Interface (SSO v2)'
+
+    def ready(self) -> None:
+        super().ready()
+        from esi import checks  # noqa

esi/checks.py

@@ -0,0 +1,56 @@
+from django.conf import settings
+from django.core.checks import Error, Tags, Warning, register
+
+
+@register(Tags.security)
+def check_sso_application_settings(*args, **kwargs):
+
+    errors = []
+
+    if (
+        not hasattr(settings, "ESI_SSO_CLIENT_ID")
+        or not hasattr(settings, "ESI_SSO_CLIENT_SECRET")
+        or not hasattr(settings, "ESI_SSO_CALLBACK_URL")
+    ):
+        if settings.DEBUG:
+            errors.append(
+                Warning(
+                    'ESI SSO application settings are not configured.',
+                    hint='SSO features will not work.',
+                    id='esi.W001'
+                )
+            )
+        else:
+            errors.append(
+                Error(
+                    'ESI SSO application settings cannot be blank.',
+                    hint=(
+                        'Register an application at https://developers.eveonline.com '
+                        'and add ESI_SSO_CLIENT_ID, ESI_SSO_CLIENT_SECRET, and '
+                        'ESI_SSO_CALLBACK_URL to your project settings.'
+                    ),
+                    id='esi.E001'
+                )
+            )
+
+    # Check for ESI_USER_CONTACT_EMAIL
+    if hasattr(settings, "ESI_USER_CONTACT_EMAIL"):
+        # Check if ESI_USER_CONTACT_EMAIL is empty
+        if settings.ESI_USER_CONTACT_EMAIL == "":
+            errors.append(
+                Error(
+                    msg="'ESI_USER_CONTACT_EMAIL' is empty. A valid email is required as maintainer contact for CCP.",
+                    hint="",
+                    id="esi.E002",
+                )
+            )
+    # ESI_USER_CONTACT_EMAIL not found
+    else:
+        errors.append(
+            Error(
+                msg="No 'ESI_USER_CONTACT_EMAIL' found is settings. A valid email is required as maintainer contact for CCP.",
+                hint="",
+                id="esi.E003",
+            )
+        )
+    return errors