aa-intel-tool 2.6.1__py3-none-any.whl → 2.6.2__py3-none-any.whl

aa_intel_tool/parser/module/chatlist.py

@@ -2,6 +2,9 @@
 Chat list parser
 """
 
+# Standard Library
+from collections import defaultdict
+
 # Django
 from django.db.models import QuerySet
 from django.utils.translation import gettext_lazy as _
@@ -38,22 +41,13 @@ def _get_character_info(scan_data: list) -> QuerySet[EveCharacter]:
     :rtype:
     """
 
-    fetch_from_eveuniverse = False
+    # Excluding corporation_id=1000001 (Doomheim) to potentially force an update here …
+    eve_characters = EveCharacter.objects.filter(character_name__in=scan_data).exclude(
+        corporation_id=1000001
+    )
 
     # Check if we have to bother Eve Universe or if we have all characters already
-    # Excluding corporation_id=1000001 (Doomheim) to force an update here …
-    try:
-        eve_characters = EveCharacter.objects.filter(
-            character_name__in=scan_data
-        ).exclude(corporation_id=1000001)
-    except EveCharacter.DoesNotExist:  # pylint: disable=no-member
-        fetch_from_eveuniverse = True
-    else:
-        if len(scan_data) != eve_characters.count():
-            fetch_from_eveuniverse = True
-
-    # Fetch the character information from Eve Universe if needed
-    if fetch_from_eveuniverse:
+    if len(scan_data) != eve_characters.count():
         try:
             eve_character_ids = (
                 EveEntity.objects.fetch_by_names_esi(names=scan_data, update=True)
@@ -61,21 +55,16 @@ def _get_character_info(scan_data: list) -> QuerySet[EveCharacter]:
                 .values_list("id", flat=True)
             )
         except EveEntity.DoesNotExist as exc:  # pylint: disable=no-member
-            message = _(
-                "Something went wrong while fetching "
-                "the character information from ESI."
-            )
-
-            raise ParserError(message=message) from exc
-
-        logger.debug(msg=f"Got {len(eve_character_ids)} ID(s) back from Eve Universe …")
+            raise ParserError(
+                message=_(
+                    "Something went wrong while fetching the character information from ESI."
+                )
+            ) from exc
 
         # In case the name does not belong to an Eve character,
         # EveEntity returns an empty object
-        if len(eve_character_ids) == 0:
-            message = _("Character unknown to ESI.")
-
-            raise ParserError(message=message)
+        if not eve_character_ids:
+            raise ParserError(message=_("Character unknown to ESI."))
 
         eve_characters = get_or_create_character(character_ids=eve_character_ids)
 
@@ -110,22 +99,24 @@ def _parse_alliance_info(
     :rtype:
     """
 
-    # Build alliance info dict
     if eve_character.alliance_id is None:
-        alliance_info = _get_unaffiliated_alliance_info()
-    else:
-        alliance_info = {
-            "id": eve_character.alliance_id,
-            "name": eve_character.alliance_name,
-            "ticker": eve_character.alliance_ticker,
-            "logo": eve_character.alliance_logo_url_32,
-        }
-
-        if with_evelinks:
-            alliance_info["dotlan"] = dotlan.alliance_url(eve_character.alliance_name)
-            alliance_info["zkillboard"] = zkillboard.alliance_url(
-                eve_character.alliance_id
-            )
+        return _get_unaffiliated_alliance_info()
+
+    alliance_info = {
+        "id": eve_character.alliance_id,
+        "name": eve_character.alliance_name,
+        "ticker": eve_character.alliance_ticker,
+        "logo": eve_character.alliance_logo_url_32,
+    }
+
+    # Add eve links if requested
+    if with_evelinks:
+        alliance_info.update(
+            {
+                "dotlan": dotlan.alliance_url(eve_character.alliance_name),
+                "zkillboard": zkillboard.alliance_url(eve_character.alliance_id),
+            }
+        )
 
     return alliance_info
 
@@ -153,11 +144,13 @@ def _parse_corporation_info(
 
     # Add eve links if requested
     if with_evelinks:
-        corporation_info["dotlan"] = dotlan.corporation_url(
-            name=eve_character.corporation_name
-        )
-        corporation_info["zkillboard"] = zkillboard.corporation_url(
-            eve_id=eve_character.corporation_id
+        corporation_info.update(
+            {
+                "dotlan": dotlan.corporation_url(name=eve_character.corporation_name),
+                "zkillboard": zkillboard.corporation_url(
+                    eve_id=eve_character.corporation_id
+                ),
+            }
         )
 
     # Add alliance info if requested
@@ -205,52 +198,35 @@ def _parse_chatscan_data(eve_characters: QuerySet[EveCharacter]) -> dict:
     :rtype:
     """
 
-    counter = {}
+    counter = defaultdict(int)
     alliance_info = {}
     corporation_info = {}
     character_info = {}
 
     # Loop through the characters
-    for eve_character in eve_characters:
-        eve_character__alliance_name = "Unaffiliated"
-
-        # If the character is in an alliance, use the alliance name
-        if eve_character.alliance_name is not None:
-            eve_character__alliance_name = eve_character.alliance_name
-
-        counter[eve_character__alliance_name] = (
-            counter.get(eve_character__alliance_name, 0) + 1
-        )
+    for eve_character in list(eve_characters):
+        alliance_name = eve_character.alliance_name or "Unaffiliated"
+        corporation_name = eve_character.corporation_name
 
-        counter[eve_character.corporation_name] = (
-            counter.get(eve_character.corporation_name, 0) + 1
-        )
+        counter[alliance_name] += 1
+        counter[corporation_name] += 1
 
         # Alliance Info
-        if eve_character__alliance_name not in alliance_info:
-            alliance_info[eve_character__alliance_name] = _parse_alliance_info(
-                eve_character=eve_character
-            )
+        if alliance_name not in alliance_info:
+            alliance_info[alliance_name] = _parse_alliance_info(eve_character)
 
         # Corporation Info
-        if eve_character.corporation_name not in corporation_info:
-            corporation_info[eve_character.corporation_name] = _parse_corporation_info(
-                eve_character=eve_character
-            )
+        if corporation_name not in corporation_info:
+            corporation_info[corporation_name] = _parse_corporation_info(eve_character)
 
         # Character Info
         character_info[eve_character.character_name] = _parse_character_info(
-            eve_character=eve_character
+            eve_character
         )
 
         # Update the counter
-        alliance_info[eve_character__alliance_name]["count"] = counter[
-            eve_character__alliance_name
-        ]
-
-        corporation_info[eve_character.corporation_name]["count"] = counter[
-            eve_character.corporation_name
-        ]
+        alliance_info[alliance_name]["count"] = counter[alliance_name]
+        corporation_info[corporation_name]["count"] = counter[corporation_name]
 
     return {
         "pilots": dict_to_list(input_dict=character_info),
@@ -275,60 +251,55 @@ def parse(
     :rtype:
     """
 
-    message = _("The chat list module is currently disabled.")
-
     # Only parse the chat scan if the module is enabled
-    if AppSettings.INTELTOOL_ENABLE_MODULE_CHATSCAN is True:
-        logger.debug(msg=f"{len(scan_data)} name(s) to work through …")
-
-        pilots_in_scan = len(scan_data)
-        max_allowed_pilots = AppSettings.INTELTOOL_CHATSCAN_MAX_PILOTS
-
-        # Check if the number of pilots in the scan exceeds the maximum allowed number
-        if 0 < max_allowed_pilots < pilots_in_scan and ignore_limit is False:
-            logger.debug(
-                msg=(
-                    f"Number of pilots in scan ({pilots_in_scan}) exceeds the maximum "
-                    f"allowed number ({max_allowed_pilots}). Throwing a tantrum …"
-                )
-            )
+    if not AppSettings.INTELTOOL_ENABLE_MODULE_CHATSCAN:
+        raise ParserError(message=_("The chat list module is currently disabled."))
 
-            # Throw a tantrum
-            raise ParserError(
-                message=ngettext(
-                    singular=f"Chat scans are currently limited to a maximum of {max_allowed_pilots} pilot per scan. Your list of pilots exceeds this limit.",  # pylint: disable=line-too-long
-                    plural=f"Chat scans are currently limited to a maximum of {max_allowed_pilots} pilots per scan. Your list of pilots exceeds this limit.",  # pylint: disable=line-too-long
-                    number=max_allowed_pilots,
-                )
-            )
+    logger.debug(msg=f"{len(scan_data)} name(s) to work through …")
 
-        eve_characters = _get_character_info(scan_data=scan_data)
+    pilots_in_scan = len(scan_data)
+    max_allowed_pilots = AppSettings.INTELTOOL_CHATSCAN_MAX_PILOTS
 
+    # Check if the number of pilots in the scan exceeds the maximum allowed number
+    if 0 < max_allowed_pilots < pilots_in_scan and not ignore_limit:
         logger.debug(
-            msg=f"Got {len(eve_characters)} EveCharacter object(s) back from AA …"
+            msg=(
+                f"Number of pilots in scan ({pilots_in_scan}) exceeds the maximum "
+                f"allowed number ({max_allowed_pilots}). Throwing a tantrum …"
+            )
+        )
+
+        # Throw a tantrum
+        raise ParserError(
+            message=ngettext(
+                singular=f"Chat scans are currently limited to a maximum of {max_allowed_pilots} pilot per scan. Your list of pilots exceeds this limit.",
+                plural=f"Chat scans are currently limited to a maximum of {max_allowed_pilots} pilots per scan. Your list of pilots exceeds this limit.",
+                number=max_allowed_pilots,
+            )
         )
 
-        # Parse the data
-        parsed_chatscan = _parse_chatscan_data(eve_characters=eve_characters)
-
-        parsed_data = {
-            "pilots": {
-                "section": ScanData.Section.PILOTLIST,
-                "data": parsed_chatscan["pilots"],
-            },
-            "corporations": {
-                "section": ScanData.Section.CORPORATIONLIST,
-                "data": parsed_chatscan["corporations"],
-            },
-            "alliances": {
-                "section": ScanData.Section.ALLIANCELIST,
-                "data": parsed_chatscan["alliances"],
-            },
-        }
-
-        if safe_to_db is False:
-            return parsed_data
-
-        return safe_scan_to_db(scan_type=Scan.Type.CHATLIST, parsed_data=parsed_data)
-
-    raise ParserError(message=message)
+    eve_characters = _get_character_info(scan_data=scan_data)
+    logger.debug(msg=f"Got {len(eve_characters)} EveCharacter object(s) back from AA …")
+
+    # Parse the data
+    parsed_chatscan = _parse_chatscan_data(eve_characters=eve_characters)
+    parsed_data = {
+        "pilots": {
+            "section": ScanData.Section.PILOTLIST,
+            "data": parsed_chatscan["pilots"],
+        },
+        "corporations": {
+            "section": ScanData.Section.CORPORATIONLIST,
+            "data": parsed_chatscan["corporations"],
+        },
+        "alliances": {
+            "section": ScanData.Section.ALLIANCELIST,
+            "data": parsed_chatscan["alliances"],
+        },
+    }
+
+    return (
+        parsed_data
+        if not safe_to_db
+        else safe_scan_to_db(scan_type=Scan.Type.CHATLIST, parsed_data=parsed_data)
+    )

aa_intel_tool/parser/module/dscan.py

@@ -4,6 +4,7 @@ D-Scan parser
 
 # Standard Library
 import re
+from collections import defaultdict
 
 # Django
 from django.db.models import QuerySet
@@ -49,14 +50,12 @@ def _is_on_grid(distance: str) -> bool:
     )
 
     # Check if we have a distance
-    if re.search(pattern=REGEX_PATTERN["localised_on_grid"], string=distance):
-        distance_sanitised = int(re.sub(pattern=r"[^0-9]", repl="", string=distance))
-
-        # Check if the distance is within the grid size
-        if distance_sanitised <= AppSettings.INTELTOOL_DSCAN_GRID_SIZE:
-            return True
+    match = re.search(pattern=REGEX_PATTERN["localised_on_grid"], string=distance)
 
-        return False
+    # Check if the distance is within the grid size
+    if match:
+        distance_sanitised = int(re.sub(pattern=r"[^0-9]", repl="", string=distance))
+        return distance_sanitised <= AppSettings.INTELTOOL_DSCAN_GRID_SIZE
 
     return False
 
@@ -104,6 +103,25 @@ def _get_ships(eve_types: QuerySet, counter: dict) -> dict:
 
     ships = {"all": {}, "ongrid": {}, "offgrid": {}, "types": {}}
 
+    def _add_ship_info(ship_dict: dict, eve_type: tuple, count: int):
+        """
+        Add ship info to the ship_dict
+
+        :param ship_dict:
+        :type ship_dict:
+        :param eve_type:
+        :type eve_type:
+        :param count:
+        :type count:
+        :return:
+        :rtype:
+        """
+
+        if eve_type[1] not in ship_dict:
+            ship_dict[eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
+            ship_dict[eve_type[1]]["count"] = count
+            ship_dict[eve_type[1]]["mass"] = eve_type[4] * count
+
     # Ship types
     # Get all ship types
     #
@@ -118,33 +136,30 @@ def _get_ships(eve_types: QuerySet, counter: dict) -> dict:
     )
 
     # Loop through all ships types
-    for eve_type in eve_types_ships:
+    for eve_type in list(eve_types_ships):
         # Info for "All Ships" table
         if eve_type[0] in counter["all"]:
-            if eve_type[1] not in ships["all"]:
-                ships["all"][eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                ships["all"][eve_type[1]]["count"] = counter["all"][eve_type[0]]
-                ships["all"][eve_type[1]]["mass"] = (
-                    eve_type[4] * counter["all"][eve_type[0]]
-                )
+            _add_ship_info(
+                ship_dict=ships["all"],
+                eve_type=eve_type,
+                count=counter["all"][eve_type[0]],
+            )
 
         # Info for "On Grid" table
         if eve_type[0] in counter["ongrid"]:
-            if eve_type[1] not in ships["ongrid"]:
-                ships["ongrid"][eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                ships["ongrid"][eve_type[1]]["count"] = counter["ongrid"][eve_type[0]]
-                ships["ongrid"][eve_type[1]]["mass"] = (
-                    eve_type[4] * counter["ongrid"][eve_type[0]]
-                )
+            _add_ship_info(
+                ship_dict=ships["ongrid"],
+                eve_type=eve_type,
+                count=counter["ongrid"][eve_type[0]],
+            )
 
         # Info for "Off Grid" table
         if eve_type[0] in counter["offgrid"]:
-            if eve_type[1] not in ships["offgrid"]:
-                ships["offgrid"][eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                ships["offgrid"][eve_type[1]]["count"] = counter["offgrid"][eve_type[0]]
-                ships["offgrid"][eve_type[1]]["mass"] = (
-                    eve_type[4] * counter["offgrid"][eve_type[0]]
-                )
+            _add_ship_info(
+                ship_dict=ships["offgrid"],
+                eve_type=eve_type,
+                count=counter["offgrid"][eve_type[0]],
+            )
 
         # Info for "Ship Types" table
         if eve_type[3] not in ships["types"]:
@@ -183,25 +198,22 @@ def _get_upwell_structures_on_grid(
         eve_group__eve_category_id__exact=EveCategoryId.STRUCTURE
     )
 
-    upwell_structures = {}
-
-    # Loop through all Upwell structures
-    for eve_type in eve_types_structures:
-        if eve_type[0] in counter["ongrid"]:
-            if eve_type[1] not in upwell_structures:
-                upwell_structures[eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                upwell_structures[eve_type[1]]["count"] = counter["ongrid"][eve_type[0]]
-
-                # If it is an Ansiblex Jump Gate, add the destination system
-                if (
-                    eve_type[0] == UpwellStructureId.ANSIBLEX_JUMP_GATE
-                    and ansiblex_destination
-                ):
-                    upwell_structures[eve_type[1]][
-                        "name"
-                    ] += f" » {ansiblex_destination}"
+    upwell_structures = {
+        eve_type[1]: {
+            **_get_type_info_dict(eve_type=eve_type),
+            "count": counter["ongrid"][eve_type[0]],
+            "name": (
+                f"{eve_type[1]} » {ansiblex_destination}"
+                if eve_type[0] == UpwellStructureId.ANSIBLEX_JUMP_GATE
+                and ansiblex_destination
+                else eve_type[1]
+            ),
+        }
+        for eve_type in list(eve_types_structures)
+        if eve_type[0] in counter["ongrid"]
+    }
 
-    return dict_to_list(upwell_structures)
+    return dict_to_list(input_dict=upwell_structures)
 
 
 def _get_deployables_on_grid(eve_types: QuerySet, counter: dict) -> list:
@@ -220,16 +232,16 @@ def _get_deployables_on_grid(eve_types: QuerySet, counter: dict) -> list:
         eve_group__eve_category_id__exact=AdditionalEveCategoryId.DEPLOYABLE
     )
 
-    deployables = {}
-
-    # Loop through all deployables
-    for eve_type in eve_types_deployables:
-        if eve_type[0] in counter["ongrid"]:
-            if eve_type[1] not in deployables:
-                deployables[eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                deployables[eve_type[1]]["count"] = counter["ongrid"][eve_type[0]]
+    deployables = {
+        eve_type[1]: {
+            **_get_type_info_dict(eve_type=eve_type),
+            "count": counter["ongrid"][eve_type[0]],
+        }
+        for eve_type in list(eve_types_deployables)
+        if eve_type[0] in counter["ongrid"]
+    }
 
-    return dict_to_list(deployables)
+    return dict_to_list(input_dict=deployables)
 
 
 def _get_starbases_on_grid(eve_types: QuerySet, counter: dict) -> list:
@@ -248,16 +260,16 @@ def _get_starbases_on_grid(eve_types: QuerySet, counter: dict) -> list:
         eve_group__eve_category_id__exact=AdditionalEveCategoryId.STARBASE
     )
 
-    starbases = {}
-
-    # Loop through all starbases
-    for eve_type in eve_types_starbase:
-        if eve_type[0] in counter["ongrid"]:
-            if eve_type[1] not in starbases:
-                starbases[eve_type[1]] = _get_type_info_dict(eve_type=eve_type)
-                starbases[eve_type[1]]["count"] = counter["ongrid"][eve_type[0]]
+    starbases = {
+        eve_type[1]: {
+            **_get_type_info_dict(eve_type=eve_type),
+            "count": counter["ongrid"][eve_type[0]],
+        }
+        for eve_type in list(eve_types_starbase)
+        if eve_type[0] in counter["ongrid"]
+    }
 
-    return dict_to_list(starbases)
+    return dict_to_list(input_dict=starbases)
 
 
 def _get_ansiblex_jumpgate_destination(ansiblex_name: str) -> str:
@@ -270,10 +282,9 @@ def _get_ansiblex_jumpgate_destination(ansiblex_name: str) -> str:
     :rtype:
     """
 
-    name_parts = re.split(pattern=r" - ", string=ansiblex_name)
-    gate_systems = re.split(pattern=r" » ", string=name_parts[0])
-
-    return gate_systems[1]
+    return re.split(
+        pattern=r" » ", string=re.split(pattern=r" - ", string=ansiblex_name)[0]
+    )[1]
 
 
 def _get_scan_details(scan_data: list) -> tuple:
@@ -292,8 +303,8 @@ def _get_scan_details(scan_data: list) -> tuple:
     )
 
     ansiblex_destination = None
-    counter = {"all": {}, "ongrid": {}, "offgrid": {}, "type": {}}
-    eve_ids = {"all": [], "ongrid": [], "offgrid": []}
+    counter = defaultdict(lambda: defaultdict(int))
+    eve_ids = defaultdict(list)
 
     # Let's split this list up
     #
@@ -314,11 +325,11 @@ def _get_scan_details(scan_data: list) -> tuple:
         line = re.search(pattern=REGEX_PATTERN["dscan"], string=entry)
         entry_id = int(line.group(1))
 
-        counter["all"][entry_id] = counter["all"].get(entry_id, 0) + 1
+        counter["all"][entry_id] += 1
 
         # Check if the entry is "on grid" or not
-        if _is_on_grid(line.group(4)):
-            counter["ongrid"][entry_id] = counter["ongrid"].get(entry_id, 0) + 1
+        if _is_on_grid(distance=line.group(4)):
+            counter["ongrid"][entry_id] += 1
 
             # If it is an Ansiblex Jump Gate, get its destination system
             if entry_id == UpwellStructureId.ANSIBLEX_JUMP_GATE:
@@ -328,8 +339,7 @@ def _get_scan_details(scan_data: list) -> tuple:
 
             eve_ids["ongrid"].append(entry_id)
         else:
-            counter["offgrid"][entry_id] = counter["offgrid"].get(entry_id, 0) + 1
-
+            counter["offgrid"][entry_id] += 1
             eve_ids["offgrid"].append(entry_id)
 
         eve_ids["all"].append(entry_id)
@@ -347,82 +357,40 @@ def parse(scan_data: list) -> Scan:
     :rtype:
     """
 
-    message = _("The D-Scan module is currently disabled.")
-
-    # Only parse the D-Scan when the module is enabled
-    if AppSettings.INTELTOOL_ENABLE_MODULE_DSCAN is True:
-        parsed_data = {}
-        (
-            ansiblex_destination,  # pylint: disable=unused-variable
-            counter,
-            eve_ids,
-        ) = _get_scan_details(scan_data=scan_data)
-
-        eve_types = EveType.objects.bulk_get_or_create_esi(
-            ids=set(eve_ids["all"]), include_children=True
-        ).values_list(
-            "id", "name", "eve_group__id", "eve_group__name", "mass", named=True
-        )
-
-        # Parse the data parts
-        ships = _get_ships(eve_types=eve_types, counter=counter)
-        upwell_structures = _get_upwell_structures_on_grid(
-            eve_types=eve_types,
-            counter=counter,
-            # ansiblex_destination=ansiblex_destination,
-        )
-        deployables = _get_deployables_on_grid(eve_types=eve_types, counter=counter)
-        starbases = _get_starbases_on_grid(eve_types=eve_types, counter=counter)
-
-        # Add "ships all" to the parsed data when available
-        if ships["all"]:
-            parsed_data["all"] = {
-                "section": ScanData.Section.SHIPLIST,
-                "data": ships["all"],
-            }
-
-        # Add "ships on grid" to the parsed data when available
-        if ships["ongrid"]:
-            parsed_data["ongrid"] = {
-                "section": ScanData.Section.SHIPLIST_ON_GRID,
-                "data": ships["ongrid"],
-            }
+    # Only parse the d-scan if the module is enabled
+    if not AppSettings.INTELTOOL_ENABLE_MODULE_DSCAN:
+        raise ParserError(message=_("The D-Scan module is currently disabled."))
 
-        # Add "ships off grid" to parsed data when available
-        if ships["offgrid"]:
-            parsed_data["offgrid"] = {
-                "section": ScanData.Section.SHIPLIST_OFF_GRID,
-                "data": ships["offgrid"],
-            }
+    parsed_data = {}
+    ansiblex_destination, counter, eve_ids = _get_scan_details(scan_data=scan_data)
 
-        # Add "ship types" to the parsed data when available
-        if ships["types"]:
-            parsed_data["shiptypes"] = {
-                "section": ScanData.Section.SHIPTYPES,
-                "data": ships["types"],
-            }
+    eve_types = EveType.objects.bulk_get_or_create_esi(
+        ids=set(eve_ids["all"]), include_children=True
+    ).values_list("id", "name", "eve_group__id", "eve_group__name", "mass", named=True)
 
-        # Add "Upwell structures on grid" to the parsed data when available
-        if upwell_structures:
-            parsed_data["sructures_on_grid"] = {
-                "section": ScanData.Section.STRUCTURES_ON_GRID,
-                "data": upwell_structures,
-            }
-
-        # Add "deployables on grid" to the parsed data when available
-        if deployables:
-            parsed_data["deployables"] = {
-                "section": ScanData.Section.DEPLOYABLES_ON_GRID,
-                "data": deployables,
-            }
-
-        # Add "starbases on grid" to parsed data when available
-        if starbases:
-            parsed_data["starbases"] = {
-                "section": ScanData.Section.STARBASES_ON_GRID,
-                "data": starbases,
-            }
+    # Parse the data parts
+    ships = _get_ships(eve_types=eve_types, counter=counter)
+    upwell_structures = _get_upwell_structures_on_grid(
+        eve_types=eve_types,
+        counter=counter,
+        ansiblex_destination=ansiblex_destination,
+    )
+    deployables = _get_deployables_on_grid(eve_types=eve_types, counter=counter)
+    starbases = _get_starbases_on_grid(eve_types=eve_types, counter=counter)
+
+    # Add parsed data when available
+    sections = {
+        "all": (ScanData.Section.SHIPLIST, ships["all"]),
+        "ongrid": (ScanData.Section.SHIPLIST_ON_GRID, ships["ongrid"]),
+        "offgrid": (ScanData.Section.SHIPLIST_OFF_GRID, ships["offgrid"]),
+        "shiptypes": (ScanData.Section.SHIPTYPES, ships["types"]),
+        "structures_on_grid": (ScanData.Section.STRUCTURES_ON_GRID, upwell_structures),
+        "deployables": (ScanData.Section.DEPLOYABLES_ON_GRID, deployables),
+        "starbases": (ScanData.Section.STARBASES_ON_GRID, starbases),
+    }
 
-        return safe_scan_to_db(scan_type=Scan.Type.DSCAN, parsed_data=parsed_data)
+    for key, (section, data) in sections.items():
+        if data:
+            parsed_data[key] = {"section": section, "data": data}
 
-    raise ParserError(message=message)
+    return safe_scan_to_db(scan_type=Scan.Type.DSCAN, parsed_data=parsed_data)