aa-killtracker 0.17.0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

killtracker/core/{discord_messages.py → trackers.py}

@@ -1,9 +1,12 @@
-"""Create discord messages from killmails."""
+"""Generate Discord messages from tracked killmails."""
 
-from typing import NamedTuple, Optional
+from __future__ import annotations
+
+from dataclasses import dataclass
+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,33 +19,54 @@ from app_utils.urls import static_file_absolute_url
 from app_utils.views import humanize_value
 
 from killtracker import __title__
-from killtracker.models import Tracker
-
-from .killmails import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
+from killtracker.core.discord import DiscordMessage
+from killtracker.core.zkb import ZKB_KILLMAIL_BASEURL, Killmail, TrackerInfo
 
-ICON_SIZE = 128
+if TYPE_CHECKING:
+    from killtracker.models import Tracker
 
+_ICON_SIZE = 128
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 
 
-class MainOrgInfo(NamedTuple):
+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)
+class _MainOrgInfo:
     """Infos about a main organization."""
 
-    text: str = ""
+    icon_url: str = ""
     name: str = ""
-    icon_url: str = eveimageserver.alliance_logo_url(1, size=ICON_SIZE)
     show_as_fleet_kill: bool = False
+    text: str = ""
+
+    def __post_init__(self):
+        if self.icon_url == "":
+            icon_url = eveimageserver.alliance_logo_url(1, size=_ICON_SIZE)
+            object.__setattr__(self, "icon_url", icon_url)
 
 
-class FinalAttackerInfo(NamedTuple):
+@dataclass(frozen=True)
+class _FinalAttackerInfo:
     """Infos about the final attacker on a killmail."""
 
     name: str = ""
     ship_type: str = ""
 
 
-class VictimInfo(NamedTuple):
+@dataclass(frozen=True)
+class _VictimInfo:
     """Infos about the victim of a killmail."""
 
     name: str
@@ -53,9 +77,11 @@ class VictimInfo(NamedTuple):
     ship_type_icon_url: str
 
 
-def create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
+def _create_content(tracker: Tracker, intro_text: Optional[str] = None) -> str:
     """Create content for Discord message for a killmail."""
 
+    from killtracker.models import Tracker
+
     intro_parts = []
 
     if tracker.ping_type == Tracker.ChannelPingType.EVERYBODY:
@@ -69,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,
@@ -102,7 +128,7 @@ def _import_discord_user():
     return DiscordUser
 
 
-def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
+def _create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
     """Create Discord embed for a killmail."""
 
     resolver: EveEntityNameResolver = EveEntity.objects.bulk_resolve_names(  # type: ignore
@@ -111,7 +137,7 @@ def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
 
     # self info
     distance_text = ""
-    main_org = MainOrgInfo()
+    main_org = _MainOrgInfo()
     main_ship_group_text = ""
     tracked_ship_types_text = ""
 
@@ -137,10 +163,24 @@ def create_embed(tracker: Tracker, killmail: Killmail) -> dhooks_lite.Embed:
     title = _calc_title(killmail, resolver, main_org, victim)
     thumbnail_url = _calc_thumbnail_url(victim, main_org)
 
-    return _create_embed(killmail, tracker, victim, description, title, thumbnail_url)
+    author = _calc_author(victim)
+    zkb_icon_url = static_file_absolute_url("killtracker/zkb_icon.png")
+    embed_color = int(tracker.color[1:], 16) if tracker and tracker.color else None
+
+    embed = dhooks_lite.Embed(
+        author=author,
+        description=description,
+        title=title,
+        url=f"{ZKB_KILLMAIL_BASEURL}{killmail.id}/",
+        thumbnail=dhooks_lite.Thumbnail(url=thumbnail_url),
+        footer=dhooks_lite.Footer(text="zKillboard", icon_url=zkb_icon_url),
+        timestamp=killmail.time,
+        color=embed_color,
+    )
+    return embed
 
 
-def _calc_author(victim: VictimInfo):
+def _calc_author(victim: _VictimInfo):
     # TODO This is a workaround for Embed.Author.name. Address in dhooks_lite
     return (
         dhooks_lite.Author(
@@ -158,10 +198,10 @@ def _calc_description(
     killmail: Killmail,
     resolver: EveEntityNameResolver,
     distance_text: str,
-    main_org: MainOrgInfo,
+    main_org: _MainOrgInfo,
     main_ship_group_text: str,
     tracked_ship_types_text: str,
-    victim: VictimInfo,
+    victim: _VictimInfo,
 ):
     solar_system_text = _calc_solar_system(tracker, killmail)
     total_value = (
@@ -186,18 +226,18 @@ def _calc_description(
 
 def _calc_victim(
     tracker: Tracker, killmail: Killmail, resolver: EveEntityNameResolver
-) -> VictimInfo:
+) -> _VictimInfo:
     if killmail.victim.alliance_id:
         victim_organization = resolver.to_name(killmail.victim.alliance_id)
         victim_org_url = zkillboard.alliance_url(killmail.victim.alliance_id)
         victim_org_icon_url = eveimageserver.alliance_logo_url(
-            killmail.victim.alliance_id, size=ICON_SIZE
+            killmail.victim.alliance_id, size=_ICON_SIZE
         )
     elif killmail.victim.corporation_id:
         victim_organization = resolver.to_name(killmail.victim.corporation_id)
         victim_org_url = zkillboard.corporation_url(killmail.victim.corporation_id)
         victim_org_icon_url = eveimageserver.corporation_logo_url(
-            killmail.victim.corporation_id, size=ICON_SIZE
+            killmail.victim.corporation_id, size=_ICON_SIZE
         )
     else:
         victim_organization = ""
@@ -229,12 +269,12 @@ def _calc_victim(
     ship_type = resolver.to_name(ship_type_id) if ship_type_id else ""
 
     ship_type_icon_url = (
-        eveimageserver.type_icon_url(ship_type_id, size=ICON_SIZE)
+        eveimageserver.type_icon_url(ship_type_id, size=_ICON_SIZE)
         if ship_type_id
         else ""
     )
 
-    return VictimInfo(
+    return _VictimInfo(
         organization=victim_organization,
         org_url=victim_org_url,
         org_icon_url=victim_org_icon_url,
@@ -246,7 +286,7 @@ def _calc_victim(
 
 def _calc_final_attacker(
     tracker: Tracker, killmail: Killmail, resolver: EveEntityNameResolver
-) -> FinalAttackerInfo:
+) -> _FinalAttackerInfo:
     for attacker in killmail.attackers:
         if attacker.is_final_blow:
             final_attacker = attacker
@@ -255,7 +295,7 @@ def _calc_final_attacker(
         final_attacker = None
 
     if not final_attacker:
-        return FinalAttackerInfo()
+        return _FinalAttackerInfo()
 
     if final_attacker.corporation_id:
         final_attacker_corporation_zkb_link = _corporation_zkb_link(
@@ -286,7 +326,7 @@ def _calc_final_attacker(
 
     ship_type = resolver.to_name(ship_type_id) if ship_type_id else ""
 
-    return FinalAttackerInfo(name=final_attacker_str, ship_type=ship_type)
+    return _FinalAttackerInfo(name=final_attacker_str, ship_type=ship_type)
 
 
 def _calc_solar_system(tracker: Tracker, killmail: Killmail):
@@ -338,12 +378,12 @@ def _calc_main_group(
         if main_org_entity.is_corporation:
             main_org_link = _corporation_zkb_link(tracker, main_org_entity.id, resolver)
             main_org_icon_url = eveimageserver.corporation_logo_url(
-                main_org_entity.id, size=ICON_SIZE
+                main_org_entity.id, size=_ICON_SIZE
             )
         else:
             main_org_link = _alliance_zkb_link(tracker, main_org_entity.id, resolver)
             main_org_icon_url = eveimageserver.alliance_logo_url(
-                main_org_entity.id, size=ICON_SIZE
+                main_org_entity.id, size=_ICON_SIZE
             )
         main_org_text = f" | Main group: {main_org_link} ({main_org_entity.count})"
         show_as_fleet_kill = tracker.identify_fleets
@@ -351,7 +391,7 @@ def _calc_main_group(
         show_as_fleet_kill = False
         main_org_text = main_org_name = main_org_icon_url = ""
 
-    return MainOrgInfo(
+    return _MainOrgInfo(
         text=main_org_text,
         name=main_org_name,
         icon_url=main_org_icon_url,
@@ -380,7 +420,7 @@ def _calc_tracked_ship_types(
     return f"\nTracked ship types involved: **{ship_types_text}**"
 
 
-def _calc_thumbnail_url(victim: VictimInfo, main_org: MainOrgInfo):
+def _calc_thumbnail_url(victim: _VictimInfo, main_org: _MainOrgInfo):
     if main_org.show_as_fleet_kill:
         return main_org.icon_url
 
@@ -390,8 +430,8 @@ def _calc_thumbnail_url(victim: VictimInfo, main_org: MainOrgInfo):
 def _calc_title(
     killmail: Killmail,
     resolver: EveEntityNameResolver,
-    main_org: MainOrgInfo,
-    victim: VictimInfo,
+    main_org: _MainOrgInfo,
+    victim: _VictimInfo,
 ):
     solar_system_name = (
         resolver.to_name(killmail.solar_system_id) if killmail.solar_system_id else ""
@@ -403,31 +443,6 @@ def _calc_title(
     return f"{solar_system_name} | {victim.ship_type} | Killmail"
 
 
-def _create_embed(
-    killmail: Killmail,
-    tracker: Tracker,
-    victim: VictimInfo,
-    description: str,
-    title: str,
-    thumbnail_url: str,
-):
-    author = _calc_author(victim)
-    zkb_icon_url = static_file_absolute_url("killtracker/zkb_icon.png")
-    embed_color = int(tracker.color[1:], 16) if tracker and tracker.color else None
-
-    embed = dhooks_lite.Embed(
-        author=author,
-        description=description,
-        title=title,
-        url=f"{ZKB_KILLMAIL_BASEURL}{killmail.id}/",
-        thumbnail=dhooks_lite.Thumbnail(url=thumbnail_url),
-        footer=dhooks_lite.Footer(text="zKillboard", icon_url=zkb_icon_url),
-        timestamp=killmail.time,
-        color=embed_color,
-    )
-    return embed
-
-
 def _character_zkb_link(
     tracker: Tracker, entity_id: int, resolver: EveEntityNameResolver
 ) -> str:

killtracker/core/workers.py

@@ -0,0 +1,46 @@
+"""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.
+"""
+
+from celery import Task
+
+from django.core.cache import cache
+
+from allianceauth.services.hooks import get_extension_logger
+from app_utils.logging import LoggerAddTag
+
+from killtracker import __title__
+
+_TIMEOUT_SECONDS = 120
+
+logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+
+
+def state_reset(hostname: str) -> None:
+    """Resets the shutting down state for a worker."""
+    cache.delete(_make_key(hostname))
+
+
+def state_set(hostname: str) -> None:
+    """Sets a worker into the shutting down state."""
+    cache.set(_make_key(hostname), "shutting down", timeout=_TIMEOUT_SECONDS)
+
+
+def is_shutting_down(task: Task) -> bool:
+    """Reports whether the worker of a celery task is currently shutting down."""
+    try:
+        hostname = str(task.request.hostname)
+    except (AttributeError, TypeError, ValueError):
+        logger.warning("Failed to retrieve hostname: %s", task)
+        return False
+
+    if cache.get(_make_key(hostname)) is None:
+        return False
+
+    return True
+
+
+def _make_key(hostname: str) -> str:
+    return f"killtracker-worker-shutting-down-{hostname}"

killtracker/core/{killmails.py → zkb.py}

@@ -1,54 +1,69 @@
-"""Fetching killmails from ZKB."""
+"""Fetch killmails from zKillboard."""
 
 # pylint: disable = redefined-builtin
 
+import datetime as dt
 import json
 from copy import deepcopy
 from dataclasses import asdict, dataclass
-from datetime import datetime
 from http import HTTPStatus
+from time import sleep
 from typing import List, Optional, Set
 from urllib.parse import quote_plus
 
 import requests
 from dacite import DaciteError, from_dict
-from redis.exceptions import LockError
 from simplejson.errors import JSONDecodeError
 
-from django.conf import settings
 from django.core.cache import cache
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.dateparse import parse_datetime
+from django.utils.timezone import now
 from eveuniverse.models import EveType
 
 from allianceauth.services.hooks import get_extension_logger
-from app_utils.allianceauth import get_redis_client
 from app_utils.json import JSONDateTimeDecoder, JSONDateTimeEncoder
 from app_utils.logging import LoggerAddTag
 
 from killtracker import USER_AGENT_TEXT, __title__
 from killtracker.app_settings import (
     KILLTRACKER_QUEUE_ID,
-    KILLTRACKER_REDISQ_LOCK_TIMEOUT,
     KILLTRACKER_REDISQ_TTW,
     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)
 
-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
 
 
+class ZKBTooManyRequestsError(Exception):
+    """ZKB RedisQ API has returned 429 Too Many Requests HTTP status code."""
+
+    def __init__(self, retry_at: dt.datetime, is_original: bool = True):
+        self.retry_at = retry_at
+        self.is_original = is_original
+
+
+class KillmailDoesNotExist(Exception):
+    """Killmail does not exist in storage."""
+
+
 @dataclass
 class _KillmailBase:
     """Base class for all Killmail."""
@@ -160,7 +175,7 @@ class Killmail(_KillmailBase):
     _STORAGE_BASE_KEY = "killtracker_storage_killmail_"
 
     id: int
-    time: datetime
+    time: dt.datetime
     victim: KillmailVictim
     attackers: List[KillmailAttacker]
     position: KillmailPosition
@@ -256,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(
@@ -363,7 +378,10 @@ class Killmail(_KillmailBase):
 
     @classmethod
     def get(cls, id: int) -> "Killmail":
-        """Fetch a killmail from temporary storage."""
+        """Fetch a killmail from temporary storage.
+
+        Raises KillmailDoesNotExist if killmail does not exit.
+        """
         data = cache.get(key=cls._storage_key(id))
         if not data:
             raise KillmailDoesNotExist(
@@ -391,9 +409,14 @@ class Killmail(_KillmailBase):
 
     @classmethod
     def create_from_zkb_redisq(cls) -> Optional["Killmail"]:
-        """Fetches and returns a killmail from ZKB.
+        """Fetches and returns a killmail from ZKB REDISQ API.
+
+        Will automatically wait for a free rate limit slot if needed.
+        Will re-raise TooManyRequests if a recent 429 timeout is not yet expired.
 
-        Returns None if no killmail is received.
+        This method is not thread safe.
+
+        Returns None if no killmail was received.
         """
         if not KILLTRACKER_QUEUE_ID:
             raise ImproperlyConfigured(
@@ -403,51 +426,70 @@ class Killmail(_KillmailBase):
         if "," in KILLTRACKER_QUEUE_ID:
             raise ImproperlyConfigured("A queue ID must not contains commas.")
 
-        redis = get_redis_client()
-        params = {
-            "queueID": quote_plus(KILLTRACKER_QUEUE_ID),
-            "ttw": KILLTRACKER_REDISQ_TTW,
-        }
-        try:
-            logger.info("Trying to fetch killmail from ZKB RedisQ...")
-            with redis.lock(
-                cls.lock_key(), blocking_timeout=KILLTRACKER_REDISQ_LOCK_TIMEOUT
-            ):
-                response = requests.get(
-                    ZKB_REDISQ_URL,
-                    params=params,
-                    timeout=REQUESTS_TIMEOUT,
-                    headers={"User-Agent": USER_AGENT_TEXT},
-                )
-        except LockError:
+        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("ZKB API: Waiting %f seconds for next free slot", seconds)
+                sleep(seconds)
+
+        response = requests.get(
+            _ZKB_REDISQ_URL,
+            params={
+                "queueID": quote_plus(KILLTRACKER_QUEUE_ID),
+                "ttw": KILLTRACKER_REDISQ_TTW,
+            },
+            timeout=_REQUESTS_TIMEOUT,
+            headers={"User-Agent": USER_AGENT_TEXT},
+        )
+        cache.set(_KEY_LAST_REQUEST, now(), timeout=KILLTRACKER_ZKB_REQUEST_DELAY + 30)
+        logger.debug(
+            "Response from ZKB API: %d %s %s",
+            response.status_code,
+            response.headers,
+            response.text,
+        )
+
+        if not response.ok:
             logger.warning(
-                "Failed to acquire lock for atomic access to RedisQ.",
-                exc_info=settings.DEBUG,  # provide details in DEBUG mode
+                "ZKB API returned error: %d %s", response.status_code, response.text
             )
-            return None
+            if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+                try:
+                    retry_after = int(response.headers["Retry-After"])
+                except KeyError:
+                    retry_after = _ZKB_429_DEFAULT_TIMEOUT
+                retry_at = now() + dt.timedelta(seconds=retry_after)
+                cache.set(_KEY_RETRY_AT, retry_at, timeout=retry_after + 60)
+                raise ZKBTooManyRequestsError(retry_at=retry_at, is_original=True)
 
-        if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
-            logger.error("429 Client Error: Too many requests: %s", response.text)
             return None
 
-        response.raise_for_status()
-
         try:
             data = response.json()
         except JSONDecodeError:
-            logger.error("Error from ZKB API:\n%s", response.text)
+            logger.error("Error parsing ZKB API response:\n%s", response.text)
             return None
 
-        if data:
-            logger.debug("data:\n%s", data)
+        if not data or "package" not in data or not data["package"]:
+            logger.info("ZKB did not return a killmail")
+            return None
 
-        if data and "package" in data and data["package"]:
-            logger.info("Received a killmail from ZKB RedisQ")
-            package_data = data["package"]
-            return cls._create_from_dict(package_data)
+        package_data = data["package"]
+        km = cls._create_from_dict(package_data)
+        if km is not None:
+            logger.info("ZKB returned killmail %d", km.id)
+        else:
+            logger.info("Failed to parse killmail from ZKB")
 
-        logger.debug("Did not received a killmail from ZKB RedisQ")
-        return None
+        return km
 
     @classmethod
     def create_from_zkb_api(cls, killmail_id: int) -> Optional["Killmail"]:
@@ -464,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()
@@ -601,20 +643,3 @@ class Killmail(_KillmailBase):
                     params[prop] = zkb_data[prop]
 
         return KillmailZkb(**params)
-
-    @staticmethod
-    def lock_key() -> str:
-        """Key used for lock operation on Redis."""
-        return f"{__title__.upper()}_REDISQ_LOCK"
-
-    @classmethod
-    def reset_lock_key(cls):
-        """Delete lock key if it exists.
-
-        It can happen that a lock key is not cleaned up
-        and then prevents this class from ever acquiring a lock again.
-        To prevent this we are deleting the lock key at system start.
-        """
-        redis = get_redis_client()
-        if redis.delete(cls.lock_key()) > 0:
-            logger.warning("A stuck lock key was cleared.")

killtracker/forms.py

@@ -7,7 +7,7 @@ from django.core.exceptions import ValidationError
 from django.forms.widgets import TextInput
 from django.utils.translation import gettext_lazy as _
 
-from .models import Tracker
+from killtracker.models import Tracker
 
 
 def field_nice_display(name: str) -> str:

killtracker/managers.py

@@ -13,9 +13,9 @@ from allianceauth.services.hooks import get_extension_logger
 from app_utils.caching import ObjectCacheMixin
 from app_utils.logging import LoggerAddTag
 
-from . import __title__
-from .app_settings import KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS
-from .core.killmails import Killmail, _KillmailCharacter
+from killtracker import __title__
+from killtracker.app_settings import KILLTRACKER_PURGE_KILLMAILS_AFTER_DAYS
+from killtracker.core.zkb import Killmail, _KillmailCharacter
 
 logger = LoggerAddTag(get_extension_logger(__name__), __title__)
 

killtracker/models/trackers.py

@@ -28,10 +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.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__)
 
@@ -881,12 +881,9 @@ class Tracker(models.Model):
     def generate_killmail_message(
         self, killmail: Killmail, intro_text: Optional[str] = None
     ) -> int:
-        """generate a message from given killmail and enqueue for later sending
+        """Generate a message from given killmail and enqueue for later sending.
 
-        returns new queue size
+        Returns the new queue size.
         """
-        from killtracker.core import discord_messages
-
-        content = discord_messages.create_content(self, intro_text)
-        embed = discord_messages.create_embed(self, killmail)
-        return self.webhook.enqueue_message(content=content, embeds=[embed])
+        message = create_discord_message_from_killmail(self, killmail, intro_text)
+        return self.webhook.enqueue_message(message)