aa-bb 3.2.0__tar.gz → 3.2.2__tar.gz

{aa_bb-3.2.0 → aa_bb-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aa_bb
-Version: 3.2.0
+Version: 3.2.2
 Summary: BigBrother
 Project-URL: Changelog, https://github.com/BroodLK/aa_bb/blob/main/CHANGELOG.md
 Project-URL: Issue / Bug Reports, https://github.com/BroodLK/aa_bb/issues
@@ -76,8 +76,6 @@ All while invisible to the general membership unless you chose to expose it to t
 ### The following AllianceAuth plugins are **_required_**:
 
 ```md
-allianceauth-afat >= 4.1.1
-allianceauth-blacklist >= 0.1.1
 allianceauth-corptools >= 2.12.0 (this app will adopt 3.0.0 as soon as version 3 is out of beta)
 allianceauth-discordbot >= 4.1.0
 aa-charlink >= 1.11.1
@@ -88,6 +86,8 @@ You do not have to use afat, but it does need to be installed.
 
 ### Optional plugins
 ```md
+allianceauth-afat >= 4.1.1
+allianceauth-blacklist >= 0.1.1
 aa-contacts >= 0.10.2
 ```
 As stated, this plugin is optional but is obviously required for using it to sync your hostiles.
@@ -98,7 +98,7 @@ After making sure to add the above prerequisite applications.
 source /home/allianceserver/venv/auth/bin/activate && cd /home/allianceserver/myauth/
 ```
 ```bash
-pip install aa-bb==3.1.0b2
+pip install aa-bb==3.2.1
 ```
 ```bash
 vi myauth/settings/local.py

{aa_bb-3.2.0 → aa_bb-3.2.2}/README.md

@@ -36,8 +36,6 @@ All while invisible to the general membership unless you chose to expose it to t
 ### The following AllianceAuth plugins are **_required_**:
 
 ```md
-allianceauth-afat >= 4.1.1
-allianceauth-blacklist >= 0.1.1
 allianceauth-corptools >= 2.12.0 (this app will adopt 3.0.0 as soon as version 3 is out of beta)
 allianceauth-discordbot >= 4.1.0
 aa-charlink >= 1.11.1
@@ -48,6 +46,8 @@ You do not have to use afat, but it does need to be installed.
 
 ### Optional plugins
 ```md
+allianceauth-afat >= 4.1.1
+allianceauth-blacklist >= 0.1.1
 aa-contacts >= 0.10.2
 ```
 As stated, this plugin is optional but is obviously required for using it to sync your hostiles.
@@ -58,7 +58,7 @@ After making sure to add the above prerequisite applications.
 source /home/allianceserver/venv/auth/bin/activate && cd /home/allianceserver/myauth/
 ```
 ```bash
-pip install aa-bb==3.1.0b2
+pip install aa-bb==3.2.1
 ```
 ```bash
 vi myauth/settings/local.py

{aa_bb-3.2.0 → aa_bb-3.2.2}/aa_bb/__init__.py

@@ -1,4 +1,4 @@
 """Initialize the app"""
 
-__version__ = "3.2.0"
+__version__ = "3.2.2"
 __title__ = "BigBrother"

{aa_bb-3.2.0 → aa_bb-3.2.2}/aa_bb/auth_hooks.py

@@ -11,6 +11,7 @@ from allianceauth.services.hooks import MenuItemHook, UrlHook
 from aa_bb import urls, urls_loa, urls_cb, urls_paps
 from .models import BigBrotherConfig, LeaveRequest
 
+from .app_settings import afat_active
 
 class CorpBrotherMenuItem(MenuItemHook):
     """This class ensures only authorized users will see the menu entry"""
@@ -174,10 +175,11 @@ def register_paps_menu():
     """Register the PAP stats sidebar entry."""
     return PapsMenuItem()
 
-@hooks.register("url_hook")
-def register_paps_urls():
-    """Wire the PAP URLconf into AllianceAuth."""
-    return UrlHook(urls_paps, "paps", r"^paps/")
+if afat_active():
+    @hooks.register("url_hook")
+    def register_paps_urls():
+        """Wire the PAP URLconf into AllianceAuth."""
+        return UrlHook(urls_paps, "paps", r"^paps/")
 
 
 @hooks.register('discord_cogs_hook')

{aa_bb-3.2.0 → aa_bb-3.2.2}/aa_bb/checks/awox.py

@@ -6,30 +6,33 @@ cache management, and rendering helpers so the calling views do not have to
 care about throttling or HTML generation.
 """
 
-import requests
 import time
-import logging
-from django.utils.html import format_html
-from django.utils.safestring import mark_safe
-from allianceauth.authentication.models import CharacterOwnership
+from functools import lru_cache
 
-from ..models import BigBrotherConfig,AwoxKillsCache
+import requests
+from allianceauth.authentication.models import CharacterOwnership
 from django.utils import timezone
+from django.utils.html import format_html
+from django.utils.safestring import mark_safe
 from esi.exceptions import HTTPNotModified
-from ..esi_client import esi, call_result
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
 from ..app_settings import (
     DATASOURCE,
     esi_tenant_kwargs,
-    get_site_url,
     get_contact_email,
     get_owner_name,
-    send_message,
+    get_site_url,
     resolve_alliance_name,
+    send_message,
 )
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
 
-logger = logging.getLogger(__name__)
+from ..esi_client import call_result, esi
+from ..models import AwoxKillsCache, BigBrotherConfig
+
+from allianceauth.services.hooks import get_extension_logger
+logger = get_extension_logger(__name__)
 
 USER_AGENT = f"{get_site_url()} Maintainer: {get_owner_name()} {get_contact_email()}"
 HEADERS = {
@@ -38,6 +41,17 @@ HEADERS = {
     "Accept": "application/json",
 }
 
+# How long we consider the cached awox data "fresh"
+AWOX_CACHE_TTL_SECONDS = 60 * 60  # 60 minutes
+
+# How many recent zKill entries we will hydrate per character (prevents runaway ESI calls)
+MAX_KILLS_PER_CHARACTER = 25
+
+# Limit zKill "down" notifications to once every 2 hours
+_last_zkill_down_notice_monotonic = 0.0
+
+
+@lru_cache(maxsize=512)
 def _get_corp_name(corp_id):
     if not corp_id:
         return "None"
@@ -48,21 +62,21 @@ def _get_corp_name(corp_id):
     except Exception:
         return f"Unknown ({corp_id})"
 
-# Limit zKill "down" notifications to once every 2 hours
-_last_zkill_down_notice_monotonic = 0.0
 
+@lru_cache(maxsize=512)
+def _get_alliance_name(alliance_id):
+    if not alliance_id:
+        return None
+    try:
+        return resolve_alliance_name(alliance_id)
+    except Exception:
+        return None
 
-def _notify_zkill_down_once(preview: str, status: int | None, content_type: str | None):
-    """
-    Fire a single Discord notification when zKill returns junk.
 
-    An in-memory timestamp prevents duplicate warnings within the last
-    ~hour so alerts do not spam when zKill is flaking.
-    """
+def _notify_zkill_down_once(preview: str, status: int | None, content_type: str | None):
     global _last_zkill_down_notice_monotonic
     now = time.monotonic()
-    # 2 hours = 7200 seconds
-    if now - _last_zkill_down_notice_monotonic < 3500:  # Skip notification if a warning was sent recently.
+    if now - _last_zkill_down_notice_monotonic < 2 * 60 * 60:
         return
     _last_zkill_down_notice_monotonic = now
     msg = (
@@ -71,13 +85,23 @@ def _notify_zkill_down_once(preview: str, status: int | None, content_type: str
         f"body preview: ```{preview}```"
     )
     try:
-        awox_notify = BigBrotherConfig.awox_notify
+        awox_notify = BigBrotherConfig.get_solo().awox_notify
         if awox_notify:
             send_message(msg)
     except Exception as e:
         logger.warning(f"Failed to send zKill down notification: {e}")
 
 
+def _get_requests_session() -> requests.Session:
+    session = requests.Session()
+    session.headers.update(HEADERS)
+    retries = Retry(total=3, backoff_factor=0.2, status_forcelist=[500, 502, 503, 504])
+    adapter = HTTPAdapter(max_retries=retries)
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+    return session
+
+
 def fetch_awox_kills(user_id, delay=0.2):
     """
     Return a deduplicated list of awox kill summaries for the given user.
@@ -86,48 +110,64 @@ def fetch_awox_kills(user_id, delay=0.2):
     recent awox activity is pulled from zKill, the full mail is hydrated
     via ESI, and the resulting summary is cached for future calls.
     """
-    # Indefinite DB cache: return cached kills if present
+    now = timezone.now()
+
+    # DB cache with TTL: return cached kills if present & fresh
     try:
         cache = AwoxKillsCache.objects.get(pk=user_id)
         try:
-            cache.last_accessed = timezone.now()
-            cache.save(update_fields=["last_accessed"])
+            last_accessed = cache.last_accessed
         except Exception:
-            cache.save()
-        return cache.data or []
+            last_accessed = None
+
+        if last_accessed and (now - last_accessed).total_seconds() < AWOX_CACHE_TTL_SECONDS:
+            try:
+                cache.last_accessed = now
+                cache.save(update_fields=["last_accessed"])
+            except Exception:
+                try:
+                    cache.save()
+                except Exception:
+                    pass
+            return cache.data or None
     except AwoxKillsCache.DoesNotExist:
-        pass
-    characters = CharacterOwnership.objects.filter(user__id=user_id)
-    char_ids = [c.character.character_id for c in characters]
-    char_id_map = {c.character.character_id: c.character.character_name for c in characters}
+        cache = None
+    except Exception:
+        cache = None
 
+    characters = CharacterOwnership.objects.filter(user__id=user_id).select_related("character")
+    char_ids_list = [c.character.character_id for c in characters if getattr(c, "character", None)]
+    char_ids = set(char_ids_list)
+    if not char_ids_list:
+        return None
 
     kills_by_id = {}
+    session = _get_requests_session()
 
-    session = requests.Session()
-    session.headers.update(HEADERS)
-    session.headers.update({"Connection": "close"})
-    retries = Retry(total=3, backoff_factor=0.2, status_forcelist=[500, 502, 503, 504])
-    session.mount("https://", HTTPAdapter(max_retries=retries))
-
-    for char_id in char_ids:
+    for char_id in char_ids_list:
         zkill_url = f"https://zkillboard.com/api/characterID/{char_id}/awox/1/"
+        start_ts = time.monotonic()
         try:
             response = session.get(zkill_url, timeout=(3, 10))
             response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.warning(f"Error fetching awox for {char_id}: {e}")
-            continue
+        finally:
+            elapsed = time.monotonic() - start_ts
+            logger.info(
+                "[AWOX][zKill] char_id=%s elapsed=%.3fs status=%s",
+                char_id,
+                elapsed,
+                getattr(response, "status_code", "ERR"),
+            )
 
-        # zKill may return HTML/Cloudflare challenge or a custom error page
         content_type = response.headers.get("Content-Type", "")
-        text_preview = (response.text or "").strip()[:200]
         text_lower = (response.text or "").lower()
+        text_preview = (response.text or "").strip()[:200]
+
         if (
             not content_type.startswith("application/json")
             or "so a big oops happened" in text_lower
             or "cdn-cgi/challenge-platform" in text_lower
-        ):  # Bail out when zKill returns HTML (Cloudflare/error) instead of JSON payloads.
+        ):
             logger.warning(
                 "Non-JSON response from zKillboard for %s: status=%s content_type=%s body='%s'",
                 char_id,
@@ -150,14 +190,19 @@ def fetch_awox_kills(user_id, delay=0.2):
             _notify_zkill_down_once(text_preview, response.status_code, content_type)
             continue
 
+        if isinstance(killmails, list):
+            killmails = killmails[:MAX_KILLS_PER_CHARACTER]
+        else:
+            continue
+
         for kill in killmails:
             kill_id = kill.get("killmail_id")
             hash_ = kill.get("zkb", {}).get("hash")
             value = kill.get("zkb", {}).get("totalValue", 0)
 
-            if not kill_id or not hash_:  # Ignore malformed entries that lack identifiers.
+            if not kill_id or not hash_:
                 continue
-            if kill_id in kills_by_id:  # Skip duplicates pulled from multiple characters.
+            if kill_id in kills_by_id:
                 continue
 
             operation = esi.client.Killmails.GetKillmailsKillmailIdKillmailHash(
@@ -165,45 +210,50 @@ def fetch_awox_kills(user_id, delay=0.2):
                 killmail_hash=hash_,
                 **esi_tenant_kwargs(DATASOURCE),
             )
+
             try:
                 full_kill, _ = call_result(operation)
             except HTTPNotModified:
-                full_kill, _ = call_result(operation, use_etag=False)
+                continue
             except Exception as e:
-                logger.warning("Failed to fetch ESI killmail %s: %s", kill_id, e)
+                logger.warning(f"Error fetching killmail from ESI for kill_id={kill_id}: {e}")
                 continue
 
-            attackers = full_kill.get("attackers", [])
             victim = full_kill.get("victim", {})
             victim_id = victim.get("character_id")
+            if not victim_id or victim_id not in char_ids:
+                continue
 
-            attacker_names = set()
+            attackers = full_kill.get("attackers", []) or []
             attacker_affiliations = []
-
-            for attacker in attackers:
-                a_id = attacker.get("character_id")
-                if a_id in char_ids and a_id != victim_id:  # Friendly fire only counts when attacker differs from victim.
-                    attacker_names.add(char_id_map.get(a_id))
+            attacker_names = []
+
+            for a in attackers:
+                a_id = a.get("character_id")
+                if not a_id:
+                    continue
+                if a_id in char_ids:
+                    attacker_names.append(a_id)
                     attacker_affiliations.append({
-                        "corp_id": attacker.get("corporation_id"),
-                        "alliance_id": attacker.get("alliance_id")
+                        "corp_id": a.get("corporation_id"),
+                        "alliance_id": a.get("alliance_id"),
                     })
 
-            if not attacker_names:  # No awox behaviour detected for this killmail.
+            if not attacker_names:
                 continue
 
             # Resolve names
-            att_info = attacker_affiliations[0]
-            att_corp = _get_corp_name(att_info["corp_id"])
-            att_alli = resolve_alliance_name(att_info["alliance_id"]) if att_info["alliance_id"] else None
+            att_info = attacker_affiliations[0] if attacker_affiliations else {}
+            att_corp = _get_corp_name(att_info.get("corp_id"))
+            att_alli = _get_alliance_name(att_info.get("alliance_id"))
 
             vic_corp_id = victim.get("corporation_id")
             vic_alli_id = victim.get("alliance_id")
             vic_corp = _get_corp_name(vic_corp_id)
-            vic_alli = resolve_alliance_name(vic_alli_id) if vic_alli_id else None
+            vic_alli = _get_alliance_name(vic_alli_id)
 
             kills_by_id[kill_id] = {
-                "value": int(value),
+                "value": int(value) if value is not None else 0,
                 "link": f"https://zkillboard.com/kill/{kill_id}/",
                 "chars": attacker_names,
                 "att_corp": att_corp,
@@ -213,16 +263,24 @@ def fetch_awox_kills(user_id, delay=0.2):
                 "date": full_kill.get("killmail_time"),
             }
 
+        time.sleep(delay)
+
     data_list = list(kills_by_id.values()) if kills_by_id else []
     try:
         AwoxKillsCache.objects.update_or_create(
             user_id=user_id,
-            defaults={"data": data_list, "last_accessed": timezone.now()},
+            defaults={"data": data_list, "last_accessed": now},
         )
     except Exception:
-        pass
-    return data_list if data_list else None
+        try:
+            if cache:
+                cache.data = data_list
+                cache.last_accessed = now
+                cache.save()
+        except Exception:
+            pass
 
+    return data_list if data_list else None
 
 def render_awox_kills_html(userID):
     """
@@ -269,7 +327,7 @@ def get_awox_kill_links(user_id):
     without having to duplicate the fetch/cache logic.
     """
     kills = fetch_awox_kills(user_id)
-    if not kills:  # No cached kills yet; callers expect empty list.
+    if not kills:  # No cached kills yet
         return []
 
     results = []

{aa_bb-3.2.0 → aa_bb-3.2.2}/aa_bb/checks/clone_state.py

@@ -14,6 +14,7 @@ from django.utils import timezone
 import json
 import os
 import logging
+from datetime import timedelta, time
 
 try:
     from corptools.models import CharacterAudit, Skill
@@ -23,6 +24,41 @@ except Exception:
 
 logger = logging.getLogger(__name__)
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MAX_CACHE_AGE = timedelta(hours=24)
+UTC_WINDOW_START = time(6, 0)   # 06:00 UTC
+UTC_WINDOW_END   = time(10, 0)  # 10:00 UTC
+
+
+def _load_fallback_skill_ids():
+    """
+    Load skills.json and return a sorted list of all skill IDs contained.
+    skills.json is a mapping of category name -> list[dict], where the 2nd dict
+    contains skill_id(str) -> skill_name.
+    """
+    skills_json_file = os.path.join(BASE_DIR, "skills.json")
+    try:
+        with open(skills_json_file, "r") as f:
+            skills_by_cat = json.load(f)
+    except Exception:
+        logger.exception("Failed to load skills.json fallback list.")
+        return []
+
+    ids = set()
+    for _cat, blocks in skills_by_cat.items():
+        for block in blocks:
+            for k in block.keys():
+                if k == "Category ID":
+                    continue
+                try:
+                    ids.add(int(k))
+                except Exception:
+                    continue
+
+    return sorted(ids)
+
+def in_utc_update_window(now):
+    utc_time = now.time()
+    return UTC_WINDOW_START <= utc_time < UTC_WINDOW_END
 
 
 def determine_character_state(user_id, save: bool = False):
@@ -31,12 +67,16 @@ def determine_character_state(user_id, save: bool = False):
     """
     alpha_skills_file = os.path.join(BASE_DIR, "alpha_skills.json")
 
-    # Load alpha skill caps
+    # Load skill
     with open(alpha_skills_file, "r") as f:
         alpha_skills = json.load(f)
     alpha_caps = {skill["id"]: skill["cap"] for skill in alpha_skills}
     alpha_skill_ids = [skill["id"] for skill in alpha_skills]
 
+    skills_json_file = os.path.join(BASE_DIR, "skills.json")
+    with open(skills_json_file, "r") as f:
+        skills = json.load(f)
+
     char_db_records = {
         rec.char_id: rec for rec in CharacterAccountState.objects.all()
     }
@@ -57,7 +97,6 @@ def determine_character_state(user_id, save: bool = False):
 
     char_ids = list(all_char_ids)
 
-    # Build total_sp map (FAST: select_related only, no skill prefetch)
     audits = (
         CharacterAudit.objects
         .filter(character__character_id__in=char_ids)
@@ -72,31 +111,27 @@ def determine_character_state(user_id, save: bool = False):
         except Exception:
             total_sp_by_char[cid] = None
 
-    # Decide which characters need checking (SP gate)
     chars_to_check = []
     for char_id in char_ids:
         db_record = char_db_records.get(char_id)
-        total_sp = total_sp_by_char.get(char_id)
 
-        # If we have a previous SP and it's unchanged, reuse cached state
-        if db_record and total_sp is not None and db_record.last_total_sp is not None:
-            if int(db_record.last_total_sp) == int(total_sp) and db_record.state in ("alpha", "omega", "unknown"):
-                result[char_id] = {
-                    "state": db_record.state,
-                    "skill_used": db_record.skill_used,
-                    "last_state": db_record.state,
-                }
-                continue
-
-        chars_to_check.append(char_id)
+        # Reuse cached state unless it's been 24 hours since last
+        now = timezone.now()
+        if db_record and db_record.last_checked_at and (now - db_record.last_checked_at) < MAX_CACHE_AGE and in_utc_update_window(now):
+            result[char_id] = {
+                "state": db_record.state if db_record.state else "unknown",
+                "skill_used": db_record.skill_used,
+                "last_state": db_record.state,
+                "last_checked_at": db_record.last_checked_at,
+            }
+            continue
+        else:
+            chars_to_check.append(char_id)
 
     # Nothing to do
     if not chars_to_check:
         return result
 
-    # Build the minimal set of skill IDs to fetch:
-    #   - all alpha-locked skills
-    #   - plus any cached skill_used for chars needing check (so we keep the fast shortcut idea)
     extra_skill_ids = set()
     for char_id in chars_to_check:
         db_record = char_db_records.get(char_id)
@@ -105,7 +140,6 @@ def determine_character_state(user_id, save: bool = False):
 
     skill_ids_to_fetch = sorted(set(alpha_skill_ids) | extra_skill_ids)
 
-    # Single query: pull only the relevant Skill rows for just these characters
     skill_rows = (
         Skill.objects
         .filter(character__character__character_id__in=chars_to_check, skill_id__in=skill_ids_to_fetch)
@@ -126,8 +160,7 @@ def determine_character_state(user_id, save: bool = False):
             "active": int(row["active_skill_level"]),
         }
 
-    now = timezone.now()
-
+    fallback_skill_ids = _load_fallback_skill_ids()
     for char_id in chars_to_check:
         db_record = char_db_records.get(char_id)
         total_sp = total_sp_by_char.get(char_id)
@@ -167,6 +200,32 @@ def determine_character_state(user_id, save: bool = False):
                     skill_used = sid
                     break
 
+        # 3) Fallback: if still unknown, check skills.json list
+        if state is None and fallback_skill_ids:
+            fb_rows = (
+                Skill.objects
+                .filter(
+                    character__character__character_id=char_id,
+                    skill_id__in=fallback_skill_ids
+                )
+                .values("skill_id", "trained_skill_level", "active_skill_level")
+            )
+
+            for row in fb_rows:
+                sid = int(row["skill_id"])
+                trained = int(row["trained_skill_level"])
+                active = int(row["active_skill_level"])
+                cap = alpha_caps.get(sid, 5)
+
+                if active > cap:
+                    state = "omega"
+                    skill_used = sid
+                    break
+                elif trained > active:
+                    state = "alpha"
+                    skill_used = sid
+                    break
+
         if state is None:
             state = "unknown"
             skill_used = None
@@ -179,6 +238,7 @@ def determine_character_state(user_id, save: bool = False):
         }
 
         if save:
+            now = timezone.now()
             with transaction.atomic():
                 CharacterAccountState.objects.update_or_create(
                     char_id=char_id,
@@ -186,7 +246,7 @@ def determine_character_state(user_id, save: bool = False):
                         "state": state,
                         "skill_used": skill_used,
                         "last_total_sp": total_sp,
-                        "sp_last_checked": now,
+                        "last_checked_at": now,
                     },
                 )
 

{aa_bb-3.2.0 → aa_bb-3.2.2}/aa_bb/checks/sus_contacts.py

@@ -38,11 +38,9 @@ def get_user_contacts(user_id: int) -> dict[int, dict]:
     Fetch and filter contacts for a user, excluding NPCs and self-contacts,
     and annotate each with standing, grouping support.
     """
-    # 1. Build a dict of the user's characters { character_id: character_name }
     user_chars = get_user_characters(user_id)
     user_char_ids = set(user_chars.keys())
 
-    # 2. Pull in all CharacterContact rows for those character IDs
     qs = CharacterContact.objects.filter(
         character__character__character_id__in=user_char_ids
     ).select_related('contact_name', 'character__character')
@@ -131,7 +129,6 @@ def get_cell_style_for_row(cid: int, column: str, row: dict) -> str:
     Determine inline CSS used when rendering the contact tables so that
     hostiles/blacklist hits pop out immediately.
     """
-    # standing color (not shown in the 3-col table but kept for compatibility)
     if column == 'standing':  # Legacy standing column retains rainbow colors.
         s = row.get('standing', 0)
         if s >= 6:  # High positive standings.
@@ -204,7 +201,6 @@ def render_contacts(user_id: int) -> str:
             html_parts.append('<p>No contacts in this category.</p>')
             continue
 
-        # Fixed 3-column table per requirements
         headers = ['character', 'corporation', 'alliance']
         html_parts.append('<table class="table table-striped table-hover stats">')
         html_parts.append('  <thead>')
@@ -240,7 +236,6 @@ def get_user_hostile_notifications(user_id: int) -> dict[int, str]:
     contacts = get_user_contacts(user_id)
     notifications: dict[int, str] = {}
 
-    # Shortcut to the current hostile lists
     cfg = BigBrotherConfig.get_solo()
     hostile_corps = cfg.hostile_corporations
     hostile_allis = cfg.hostile_alliances
@@ -248,7 +243,6 @@ def get_user_hostile_notifications(user_id: int) -> dict[int, str]:
 
     for cid, info in contacts.items():
         ctype     = info['contact_type']      # 'character' | 'corporation' | 'alliance'
-        # derive a display name based on the type
         if ctype == 'character':  # Display actual character name for hostile characters.
             cname = info.get('character') or ''
         elif ctype == 'corporation':  # Corporations show corp display name.
@@ -267,23 +261,19 @@ def get_user_hostile_notifications(user_id: int) -> dict[int, str]:
         alerts: list[str] = []
         logger.info(f"{cname},{aid},{alli_name}")
 
-        # 1) Character-specific blacklist check
         if aablacklist_active():
             if ctype == 'character' and check_char_corp_bl(cid):  # Character is on blacklist.
                 alerts.append(f"**{cname}** is on blacklist")
 
-        # 2) Hostile corporation check (characters & corporations)
         if ctype in ('character', 'corporation') and coid != 0:  # Evaluate corp affiliation when present.
             if str(coid) in hostile_corps:  # Corp matches hostile list.
                 alerts.append(f"corporation **{corp_name}** is on hostile list")
 
-        # 3) Hostile alliance check (characters, corporations & alliances)
         if aid != 0 and str(aid) in hostile_allis:  # Alliance belongs to hostile list.
             alerts.append(f"alliance **{alli_name}** is on hostile list")
 
         if alerts:  # Build notification only when this contact triggered alerts.
             char_list = ', '.join(sorted(chars)) if chars else 'no characters'
-            # Build a single notification string
             message = (
                 f"- A {s} **{ctype}** type contact **{cname}** found on **{char_list}**, flags: "
                 + "; ".join(alerts)