aa-killtracker 0.18.0a2__tar.gz → 1.0.0__tar.gz

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: aa-killtracker
-Version: 0.18.0a2
+Version: 1.0.0
 Summary: An app for running killmail trackers with Alliance Auth and Discord.
 Author-email: Erik Kalkoken <kalkoken87@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
-Classifier: Framework :: Django :: 4.0
 Classifier: Framework :: Django :: 4.2
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: MIT License
@@ -17,15 +16,16 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 License-File: LICENSE
-Requires-Dist: allianceauth-app-utils>=1.19.0
-Requires-Dist: allianceauth>=3
+Requires-Dist: allianceauth-app-utils>=1.26
+Requires-Dist: allianceauth>=4,<5
 Requires-Dist: dacite
-Requires-Dist: dhooks-lite>=1.0
-Requires-Dist: django-eveuniverse>=1.3
-Requires-Dist: redis-simple-mq>=0.5
+Requires-Dist: dhooks-lite>=1.1
+Requires-Dist: django-eveuniverse>=1.5
+Requires-Dist: redis-simple-mq>=1.0
 Project-URL: Home, https://gitlab.com/ErikKalkoken/aa-killtracker
 
 # Killtracker
@@ -242,7 +242,6 @@ Note that all settings are optional and the app will use the documented default
 Name | Description | Default
 -- | -- | --
 `KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER`| Ignore killmails that are older than the given number in minutes. Sometimes killmails appear belated on ZKB, this feature ensures they don't create new alerts | `60`
-`KILLTRACKER_MAX_KILLMAILS_PER_RUN`| Maximum number of killmails retrieved from ZKB by task run. This value should be set such that the task that fetches new killmails from ZKB every minute will reliable finish within one minute. To test this run a "Catch all" tracker and see how many killmails your system is capable of processing. Note that you can get that information from the worker's log file. It will look something like this: `Total killmails received from ZKB in 49 secs: 100`   | `100`
 `KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS`| Killmails older than set number of days will be purged from the database. If you want to keep all killmails set this to 0. Note that this setting is only relevant if you have storing killmails enabled.  | `30`
 `KILLTRACKER_QUEUE_ID`| Unique ID used to identify this server when fetching killmails from zKillboard. This setting is mandatory.  | ``
 `KILLTRACKER_STORING_KILLMAILS_ENABLED`| If set to true Killtracker will automatically store all received killmails in the local database. This can be useful if you want to run analytics on killmails etc. However, please note that Killtracker itself currently does not use stored killmails in any way.  | `False`

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/README.md

@@ -212,7 +212,6 @@ Note that all settings are optional and the app will use the documented default
 Name | Description | Default
 -- | -- | --
 `KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER`| Ignore killmails that are older than the given number in minutes. Sometimes killmails appear belated on ZKB, this feature ensures they don't create new alerts | `60`
-`KILLTRACKER_MAX_KILLMAILS_PER_RUN`| Maximum number of killmails retrieved from ZKB by task run. This value should be set such that the task that fetches new killmails from ZKB every minute will reliable finish within one minute. To test this run a "Catch all" tracker and see how many killmails your system is capable of processing. Note that you can get that information from the worker's log file. It will look something like this: `Total killmails received from ZKB in 49 secs: 100`   | `100`
 `KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS`| Killmails older than set number of days will be purged from the database. If you want to keep all killmails set this to 0. Note that this setting is only relevant if you have storing killmails enabled.  | `30`
 `KILLTRACKER_QUEUE_ID`| Unique ID used to identify this server when fetching killmails from zKillboard. This setting is mandatory.  | ``
 `KILLTRACKER_STORING_KILLMAILS_ENABLED`| If set to true Killtracker will automatically store all received killmails in the local database. This can be useful if you want to run analytics on killmails etc. However, please note that Killtracker itself currently does not use stored killmails in any way.  | `False`

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/killtracker/__init__.py

@@ -3,7 +3,7 @@
 # pylint: disable = invalid-name
 default_app_config = "killtracker.apps.KillmailsConfig"
 
-__version__ = "0.18.0a2"
+__version__ = "1.0.0"
 __title__ = "Killtracker"
 
 APP_NAME = "aa-killtracker"

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/killtracker/admin.py

@@ -12,7 +12,7 @@ from django.utils.safestring import mark_safe
 from allianceauth import NAME as site_header
 
 from killtracker import tasks
-from killtracker.core.killmails import Killmail
+from killtracker.core.zkb import Killmail
 from killtracker.forms import (
     TrackerAdminForm,
     TrackerAdminKillmailIdForm,

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/killtracker/app_settings.py

@@ -13,13 +13,8 @@ sometimes killmails appear belated on ZKB,
 this feature ensures they don't create new alerts.
 """
 
-KILLTRACKER_MAX_KILLMAILS_PER_RUN = clean_setting(
-    "KILLTRACKER_MAX_KILLMAILS_PER_RUN", 500
-)
-"""Maximum number of killmails retrieved from ZKB by task run."""
-
 KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS = clean_setting(
-    "KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS", 30
+    "KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS", default_value=30, min_value=0
 )
 """Killmails older than set number of days will be purged from the database.
 If you want to keep all killmails set this to 0.
@@ -103,9 +98,21 @@ KILLTRACKER_STORAGE_KILLMAILS_LIFETIME = clean_setting(
 )
 """Max lifetime of killmails in temporary storage in seconds."""
 
-KILLTRACKER_ZKB_REQUEST_DELAY = clean_setting("KILLTRACKER_ZKB_REQUEST_DELAY", 500)
+KILLTRACKER_ZKB_REQUEST_DELAY = clean_setting(
+    "KILLTRACKER_ZKB_REQUEST_DELAY", default_value=500, min_value=500
+)
 """Delay between subsequent calls to ZKB API in milliseconds.
 
 This delay ensures the app does not breach the CloudFlare rate limit of currently
 two (2) requests per second per IP address.
 """
+
+KILLTRACKER_MAX_KILLMAILS_PER_RUN = clean_setting(
+    "KILLTRACKER_MAX_KILLMAILS_PER_RUN", default_value=500, min_value=1
+)
+"""Maximum number of killmails retrieved from ZKB by task run."""
+
+KILLTRACKER_MAX_MESSAGES_SENT_PER_RUN = clean_setting(
+    "KILLTRACKER_MAX_MESSAGES_SENT_PER_RUN", default_value=10, min_value=1
+)
+"""Maximum number of messages processed per task run."""

aa_killtracker-1.0.0/killtracker/core/discord.py

@@ -0,0 +1,162 @@
+"""Send messages to Discord webhooks."""
+
+import datetime as dt
+import json
+from copy import copy
+from dataclasses import dataclass
+from http import HTTPStatus
+from time import sleep
+from typing import List, Optional
+
+import dhooks_lite
+
+from django.core.cache import cache
+from django.utils.timezone import now
+
+from allianceauth.services.hooks import get_extension_logger
+from app_utils.json import JSONDateTimeDecoder, JSONDateTimeEncoder
+from app_utils.logging import LoggerAddTag
+
+from killtracker import APP_NAME, HOMEPAGE_URL, __title__, __version__
+from killtracker.app_settings import KILLTRACKER_DISCORD_SEND_DELAY
+from killtracker.core.helpers import datetime_or_none
+
+_DEFAULT_429_TIMEOUT = 600
+
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
+
+class HTTPError(Exception):
+    """A HTTP error."""
+
+    def __init__(self, status_code: int):
+        self.status_code = status_code
+
+
+class WebhookRateLimitExhausted(Exception):
+    """The rate limit of a webhook has been exhausted."""
+
+    def __init__(self, retry_at: dt.datetime, is_original: bool = True):
+        self.retry_at = retry_at
+        self.is_original = is_original
+
+
+@dataclass
+class DiscordMessage:
+    """A Discord message created from a Killmail."""
+
+    avatar_url: Optional[str] = None
+    content: Optional[str] = None
+    embeds: Optional[List[dhooks_lite.Embed]] = None
+    killmail_id: int = 0  # Killmail ID this message from created from
+    username: Optional[str] = None
+
+    def __post_init__(self):
+        if not self.content and not self.embeds:
+            raise ValueError("Message must have content or embeds to be valid")
+
+    def to_json(self) -> str:
+        """Converts a Discord message into a JSON object and returns it."""
+
+        if self.embeds:
+            embeds_list = [obj.asdict() for obj in self.embeds]
+        else:
+            embeds_list = None
+
+        message = {}
+        if self.killmail_id:
+            message["killmail_id"] = self.killmail_id
+        if self.content:
+            message["content"] = self.content
+        if embeds_list:
+            message["embeds"] = embeds_list
+        if self.username:
+            message["username"] = self.username
+        if self.avatar_url:
+            message["avatar_url"] = self.avatar_url
+
+        return json.dumps(message, cls=JSONDateTimeEncoder)
+
+    @classmethod
+    def from_json(cls, s: str) -> "DiscordMessage":
+        """Creates a DiscordMessage object from an JSON object and returns it."""
+        message1: dict = json.loads(s, cls=JSONDateTimeDecoder)
+        message2 = copy(message1)
+        if message1.get("embeds"):
+            message2["embeds"] = [
+                dhooks_lite.Embed.from_dict(embed_dict)
+                for embed_dict in message1.get("embeds")
+            ]
+        else:
+            message2["embeds"] = None
+        return cls(**message2)
+
+
+def send_message_to_webhook(name: str, url: str, message: DiscordMessage) -> int:
+    """Send a message to a Discord webhook and returns the ID of new message."""
+
+    key_retry_at = _make_key_retry_at(url)
+    retry_at = datetime_or_none(cache.get(key_retry_at))
+    if retry_at is not None and retry_at > now():
+        raise WebhookRateLimitExhausted(retry_at=retry_at, is_original=False)
+
+    key_last_request = _make_key_last_request(url)
+    last_request = datetime_or_none(cache.get(key_last_request))
+    if last_request is not None:
+        next_slot = last_request + dt.timedelta(seconds=KILLTRACKER_DISCORD_SEND_DELAY)
+        seconds = (next_slot - now()).total_seconds()
+        if seconds > 0:
+            logger.debug(
+                "%s: Waiting %f seconds for next free slot for webhook", name, seconds
+            )
+            sleep(seconds)
+
+    hook = dhooks_lite.Webhook(
+        url=url,
+        user_agent=dhooks_lite.UserAgent(
+            name=APP_NAME, url=HOMEPAGE_URL, version=__version__
+        ),
+    )
+    response = hook.execute(
+        content=message.content,
+        embeds=message.embeds,
+        username=message.username,
+        avatar_url=message.avatar_url,
+        wait_for_response=True,
+        max_retries=0,  # we will handle retries ourselves
+    )
+    cache.set(key_last_request, now(), timeout=KILLTRACKER_DISCORD_SEND_DELAY + 30)
+    logger.debug(
+        "%s: Response from Discord for creating message from killmail %d: %s %s %s",
+        name,
+        message.killmail_id,
+        response.status_code,
+        response.headers,
+        response.content,
+    )
+    if not response.status_ok:
+        if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+            try:
+                retry_after = int(response.headers["Retry-After"])
+            except KeyError:
+                retry_after = _DEFAULT_429_TIMEOUT
+            retry_at = now() + dt.timedelta(seconds=retry_after)
+            cache.set(key_retry_at, retry_at, timeout=retry_after + 60)
+            raise WebhookRateLimitExhausted(retry_at=retry_at, is_original=True)
+
+        raise HTTPError(response.status_code)
+
+    try:
+        message_id = int(response.content.get("id"))
+    except (AttributeError, ValueError):
+        message_id = 0
+
+    return message_id
+
+
+def _make_key_last_request(url):
+    return f"killtracker-webhook-last-request-{url}"
+
+
+def _make_key_retry_at(url):
+    return f"killtracker-webhook-retry-at-{url}"

aa_killtracker-1.0.0/killtracker/core/helpers.py

@@ -0,0 +1,13 @@
+"""Helper functions for core modules."""
+
+import datetime as dt
+from typing import Any, Optional
+
+
+def datetime_or_none(v: Any) -> Optional[dt.datetime]:
+    """Returns as datetime when it is a datetime else returns None."""
+    if v is None:
+        return None
+    if not isinstance(v, dt.datetime):
+        return None
+    return v

aa_killtracker-0.18.0a2/killtracker/core/discord_messages.py → aa_killtracker-1.0.0/killtracker/core/trackers.py

@@ -1,14 +1,12 @@
-"""This module allows to create Discord messages from killmails."""
+"""Generate Discord messages from tracked killmails."""
 
 from __future__ import annotations
 
-import json
-from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 import dhooks_lite
-from requests.exceptions import HTTPError
+import requests
 
 from eveuniverse.helpers import EveEntityNameResolver
 from eveuniverse.models import EveEntity, EveSolarSystem
@@ -16,89 +14,32 @@ from eveuniverse.models import EveEntity, EveSolarSystem
 from allianceauth.eveonline.evelinks import dotlan, eveimageserver, zkillboard
 from allianceauth.services.hooks import get_extension_logger
 from app_utils.django import app_labels
-from app_utils.json import JSONDateTimeDecoder, JSONDateTimeEncoder
 from app_utils.logging import LoggerAddTag
 from app_utils.urls import static_file_absolute_url
 from app_utils.views import humanize_value
 
 from killtracker import __title__
-
-from .killmails import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
+from killtracker.core.discord import DiscordMessage
+from killtracker.core.zkb import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
 
 if TYPE_CHECKING:
     from killtracker.models import Tracker
 
-
 _ICON_SIZE = 128
 
-
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
 
-@dataclass
-class DiscordMessage:
-    """A Discord message created from a Killmail."""
-
-    avatar_url: Optional[str] = None
-    content: Optional[str] = None
-    embeds: Optional[List[dhooks_lite.Embed]] = None
-    killmail_id: int = 0  # Killmail ID this message from created from
-    tts: Optional[bool] = None
-    username: Optional[str] = None
-
-    def __post_init__(self):
-        if not self.content and not self.embeds:
-            raise ValueError("Message must have content or embeds to be valid")
-
-    def to_json(self) -> str:
-        """Converts a Discord message into a JSON object and returns it."""
-
-        if self.embeds:
-            embeds_list = [obj.asdict() for obj in self.embeds]
-        else:
-            embeds_list = None
-
-        message = {}
-        if self.killmail_id:
-            message["killmail_id"] = self.killmail_id
-        if self.content:
-            message["content"] = self.content
-        if embeds_list:
-            message["embeds"] = embeds_list
-        if self.tts:
-            message["tts"] = self.tts
-        if self.username:
-            message["username"] = self.username
-        if self.avatar_url:
-            message["avatar_url"] = self.avatar_url
-
-        return json.dumps(message, cls=JSONDateTimeEncoder)
-
-    @classmethod
-    def from_json(cls, s: str) -> "DiscordMessage":
-        """Creates a DiscordMessage object from an JSON object and returns it."""
-        message1: dict = json.loads(s, cls=JSONDateTimeDecoder)
-        message2 = copy(message1)
-        if message1.get("embeds"):
-            message2["embeds"] = [
-                dhooks_lite.Embed.from_dict(embed_dict)
-                for embed_dict in message1.get("embeds")
-            ]
-        else:
-            message2["embeds"] = None
-        return cls(**message2)
-
-    @classmethod
-    def from_killmail(
-        cls, tracker: Tracker, killmail: Killmail, intro_text: Optional[str] = None
-    ) -> "DiscordMessage":
-        """Creates a DiscordMessage object from a Killmail and returns it."""
-        m = DiscordMessage(
-            killmail_id=killmail.id,
-            content=_create_content(tracker, intro_text),
-            embeds=[_create_embed(tracker, killmail)],
-        )
-        return m
+def create_discord_message_from_killmail(
+    tracker: Tracker, killmail: Killmail, intro_text: Optional[str] = None
+) -> "DiscordMessage":
+    """Creates a Discord message from a Killmail and returns it."""
+    m = DiscordMessage(
+        killmail_id=killmail.id,
+        content=_create_content(tracker, intro_text),
+        embeds=[_create_embed(tracker, killmail)],
+    )
+    return m
 
 
 @dataclass(frozen=True)
@@ -154,7 +95,7 @@ def _create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
             for group in tracker.ping_groups.all():
                 try:
                     role = DiscordUser.objects.group_to_role(group)  # type: ignore
-                except HTTPError:
+                except requests.exceptions.HTTPError:
                     logger.warning(
                         "Failed to get Discord roles. Can not ping groups.",
                         exc_info=True,

aa_killtracker-0.18.0a2/killtracker/core/worker_shutdown.py → aa_killtracker-1.0.0/killtracker/core/workers.py

@@ -1,5 +1,4 @@
-"""Module worker_shutdown allows tasks to find out
-whether their worker is currently shutting down.
+"""Allows tasks to find out whether their worker is currently shutting down.
 
 This enables long running tasks to abort early,
 which helps to speed up a warm worker shutdown.
@@ -19,12 +18,12 @@ _TIMEOUT_SECONDS = 120
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
 
-def reset(hostname: str) -> None:
+def state_reset(hostname: str) -> None:
     """Resets the shutting down state for a worker."""
     cache.delete(_make_key(hostname))
 
 
-def set(hostname: str) -> None:
+def state_set(hostname: str) -> None:
     """Sets a worker into the shutting down state."""
     cache.set(_make_key(hostname), "shutting down", timeout=_TIMEOUT_SECONDS)
 

aa_killtracker-0.18.0a2/killtracker/core/killmails.py → aa_killtracker-1.0.0/killtracker/core/zkb.py

@@ -1,4 +1,4 @@
-"""Fetching killmails from ZKB."""
+"""Fetch killmails from zKillboard."""
 
 # pylint: disable = redefined-builtin
 
@@ -32,19 +32,22 @@ from killtracker.app_settings import (
     KILLTRACKER_STORAGE_KILLMAILS_LIFETIME,
     KILLTRACKER_ZKB_REQUEST_DELAY,
 )
-from killtracker.exceptions import KillmailDoesNotExist
+from killtracker.core.helpers import datetime_or_none
 from killtracker.providers import esi
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
-
-ZKB_REDISQ_URL = "https://zkillredisq.stream/listen.php"
-ZKB_API_URL = "https://zkillboard.com/api/"
 ZKB_KILLMAIL_BASEURL = "https://zkillboard.com/kill/"
-REQUESTS_TIMEOUT = (5, 30)
-DEFAULT_429_TIMEOUT = 10
 
-MAIN_MINIMUM_COUNT = 2
-MAIN_MINIMUM_SHARE = 0.25
+_KEY_RETRY_AT = "killtracker-zkb-retry-at"
+_KEY_LAST_REQUEST = "killtracker-zkb-last-request"
+_MAIN_MINIMUM_COUNT = 2
+_MAIN_MINIMUM_SHARE = 0.25
+_REQUESTS_TIMEOUT = (5, 30)
+_ZKB_429_DEFAULT_TIMEOUT = 10
+_ZKB_API_URL = "https://zkillboard.com/api/"
+_ZKB_REDISQ_URL = "https://zkillredisq.stream/listen.php"
+
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
 
 # TODO: Factor out logic for accessing the API to another module
 
@@ -57,6 +60,10 @@ class ZKBTooManyRequestsError(Exception):
         self.is_original = is_original
 
 
+class KillmailDoesNotExist(Exception):
+    """Killmail does not exist in storage."""
+
+
 @dataclass
 class _KillmailBase:
     """Base class for all Killmail."""
@@ -264,8 +271,8 @@ class Killmail(_KillmailBase):
         jumps: Optional[int] = None,
         distance: Optional[float] = None,
         matching_ship_type_ids: Optional[List[int]] = None,
-        minimum_count: int = MAIN_MINIMUM_COUNT,
-        minimum_share: float = MAIN_MINIMUM_SHARE,
+        minimum_count: int = _MAIN_MINIMUM_COUNT,
+        minimum_share: float = _MAIN_MINIMUM_SHARE,
     ) -> "Killmail":
         """Clone this killmail and add tracker info."""
         main_ship_group = self._calc_main_attacker_ship_group(
@@ -419,45 +426,30 @@ class Killmail(_KillmailBase):
         if "," in KILLTRACKER_QUEUE_ID:
             raise ImproperlyConfigured("A queue ID must not contains commas.")
 
-        key_retry_at = "killtracker-retry-at"
-        if (v := cache.get(key_retry_at)) is not None:
-            try:
-                retry_at = dt.datetime.fromisoformat(v)
-            except (TypeError, ValueError):
-                cache.delete(key_retry_at)
-                logger.warning("unable to parse timestamp of retry at")
-                return None
-
-            if retry_at > now():
-                raise ZKBTooManyRequestsError(retry_at=retry_at, is_original=False)
-
-        key_last_request = "killtracker-last-request"
-        if (v := cache.get(key_last_request)) is not None:
-            try:
-                last_request = dt.datetime.fromisoformat(v)
-            except (TypeError, ValueError):
-                cache.delete(key_last_request)
-                logger.warning("unable to parse timestamp of last request")
-                last_request = now()
+        retry_at = datetime_or_none(cache.get(_KEY_RETRY_AT))
+        if retry_at is not None and retry_at > now():
+            raise ZKBTooManyRequestsError(retry_at=retry_at, is_original=False)
 
+        last_request = datetime_or_none(cache.get(_KEY_LAST_REQUEST))
+        if last_request is not None:
             next_slot = last_request + dt.timedelta(
                 milliseconds=KILLTRACKER_ZKB_REQUEST_DELAY
             )
             seconds = (next_slot - now()).total_seconds()
             if seconds > 0:
-                logger.debug("Waiting %f seconds to for next free slot", seconds)
+                logger.debug("ZKB API: Waiting %f seconds for next free slot", seconds)
                 sleep(seconds)
 
         response = requests.get(
-            ZKB_REDISQ_URL,
+            _ZKB_REDISQ_URL,
             params={
                 "queueID": quote_plus(KILLTRACKER_QUEUE_ID),
                 "ttw": KILLTRACKER_REDISQ_TTW,
             },
-            timeout=REQUESTS_TIMEOUT,
+            timeout=_REQUESTS_TIMEOUT,
             headers={"User-Agent": USER_AGENT_TEXT},
         )
-        cache.set(key_last_request, dt.datetime.isoformat(now()), timeout=30)
+        cache.set(_KEY_LAST_REQUEST, now(), timeout=KILLTRACKER_ZKB_REQUEST_DELAY + 30)
         logger.debug(
             "Response from ZKB API: %d %s %s",
             response.status_code,
@@ -473,9 +465,9 @@ class Killmail(_KillmailBase):
                 try:
                     retry_after = int(response.headers["Retry-After"])
                 except KeyError:
-                    retry_after = DEFAULT_429_TIMEOUT
+                    retry_after = _ZKB_429_DEFAULT_TIMEOUT
                 retry_at = now() + dt.timedelta(seconds=retry_after)
-                cache.set(key_retry_at, retry_at.isoformat(), timeout=retry_after + 60)
+                cache.set(_KEY_RETRY_AT, retry_at, timeout=retry_after + 60)
                 raise ZKBTooManyRequestsError(retry_at=retry_at, is_original=True)
 
             return None
@@ -514,9 +506,9 @@ class Killmail(_KillmailBase):
             "Trying to fetch killmail from ZKB API with killmail ID %d ...",
             killmail_id,
         )
-        url = f"{ZKB_API_URL}killID/{killmail_id}/"
+        url = f"{_ZKB_API_URL}killID/{killmail_id}/"
         response = requests.get(
-            url, timeout=REQUESTS_TIMEOUT, headers={"User-Agent": USER_AGENT_TEXT}
+            url, timeout=_REQUESTS_TIMEOUT, headers={"User-Agent": USER_AGENT_TEXT}
         )
         response.raise_for_status()
         zkb_data = response.json()

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/killtracker/managers.py

@@ -15,7 +15,7 @@ from app_utils.logging import LoggerAddTag
 
 from killtracker import __title__
 from killtracker.app_settings import KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS
-from killtracker.core.killmails import Killmail, _KillmailCharacter
+from killtracker.core.zkb import Killmail, _KillmailCharacter
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 

{aa_killtracker-0.18.0a2 → aa_killtracker-1.0.0}/killtracker/models/trackers.py

@@ -28,11 +28,10 @@ from app_utils.logging import LoggerAddTag
 from killtracker import __title__
 from killtracker.app_settings import KILLTRACKER_KILLMAIL_MAX_AGE_FOR_TRACKER
 from killtracker.constants import EveCategoryId, EveGroupId
-from killtracker.core.discord_messages import DiscordMessage
-from killtracker.core.killmails import Killmail
+from killtracker.core.trackers import create_discord_message_from_killmail
+from killtracker.core.zkb import Killmail
 from killtracker.managers import TrackerManager
-
-from .webhooks import Webhook
+from killtracker.models.webhooks import Webhook
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
@@ -886,5 +885,5 @@ class Tracker(models.Model):
 
         Returns the new queue size.
         """
-        message = DiscordMessage.from_killmail(self, killmail, intro_text)
+        message = create_discord_message_from_killmail(self, killmail, intro_text)
         return self.webhook.enqueue_message(message)