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

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)

aa_intel_tool/parser/module/fleetcomp.py

@@ -51,45 +51,49 @@ def get_fleet_composition(pilots: dict, ships: dict) -> dict:
         ids=set(ship_class_ids), include_children=True
     ).values_list("id", "name", "eve_group__id", "eve_group__name", "mass", named=True)
 
-    # Loop through ship classes
-    for ship_class in ship_class_details:
+    # Build ship class and type dictionaries
+    for ship_class in list(ship_class_details):
         # Build ship class dict
-        ships["class"][ship_class.name]["id"] = ship_class.id
-        ships["class"][ship_class.name]["name"] = ship_class.name
-        ships["class"][ship_class.name]["type_id"] = ship_class.eve_group__id
-        ships["class"][ship_class.name]["type_name"] = ship_class.eve_group__name
-        ships["class"][ship_class.name]["image"] = eveimageserver.type_icon_url(
-            type_id=ship_class.id, size=32
-        )
-        ships["class"][ship_class.name]["mass"] = (
-            ship_class.mass * ships["class"][ship_class.name]["count"]
+        ships["class"][ship_class.name].update(
+            {
+                "id": ship_class.id,
+                "name": ship_class.name,
+                "type_id": ship_class.eve_group__id,
+                "type_name": ship_class.eve_group__name,
+                "image": eveimageserver.type_icon_url(type_id=ship_class.id, size=32),
+                "mass": ship_class.mass * ships["class"][ship_class.name]["count"],
+            }
         )
 
         # Build ship type dict
-        ships["type"][ship_class.eve_group__name]["id"] = ship_class.eve_group__id
-        ships["type"][ship_class.eve_group__name]["name"] = ship_class.eve_group__name
+        ships["type"][ship_class.eve_group__name].update(
+            {
+                "id": ship_class.eve_group__id,
+                "name": ship_class.eve_group__name,
+            }
+        )
 
     # Pilots
-    pilot_details = _get_character_info(scan_data=list(set(pilots)))
-
-    # Loop through pilots
-    for pilot in pilot_details:
-        # Get ship class details for a pilot
-        pilot__ship_class = ship_class_details.filter(
-            name=pilots[pilot.character_name]["ship"]
-        ).get()
-
-        # Build pilots dict
-        pilots[pilot.character_name]["id"] = pilot.character_id
-        pilots[pilot.character_name]["portrait"] = pilot.portrait_url_32
-        pilots[pilot.character_name]["evewho"] = evewho.character_url(
-            pilot.character_id
+    pilot_details = _get_character_info(scan_data=list(pilots))
+
+    # Build pilots dictionary
+    for pilot in list(pilot_details):
+        pilot_ship_class = next(
+            ship_class
+            for ship_class in ship_class_details
+            if ship_class.name == pilots[pilot.character_name]["ship"]
         )
-        pilots[pilot.character_name]["zkillboard"] = zkillboard.character_url(
-            pilot.character_id
+
+        pilots[pilot.character_name].update(
+            {
+                "id": pilot.character_id,
+                "portrait": pilot.portrait_url_32,
+                "evewho": evewho.character_url(pilot.character_id),
+                "zkillboard": zkillboard.character_url(pilot.character_id),
+                "ship_id": pilot_ship_class.id,
+                "ship_type_id": pilot_ship_class.eve_group__id,
+            }
         )
-        pilots[pilot.character_name]["ship_id"] = pilot__ship_class.id
-        pilots[pilot.character_name]["ship_type_id"] = pilot__ship_class.eve_group__id
 
     return {
         "classes": dict_to_list(input_dict=ships["class"]),
@@ -117,12 +121,9 @@ def parse_line(line) -> list:
     # line[4] => Position in Fleet
     # line[5] => Skills (FC - WC - SC)
     # line[6] => Wing Name / Squad Name
-    line = re.split(pattern=r"\t+", string=line.rstrip("\t"))
+    line = re.split(r"\t+", line.rstrip("\t"))
 
-    if len(line) == 6:
-        line.append("")
-
-    return line
+    return line if len(line) > 6 else line + [""]
 
 
 def update_ships(ships, line) -> dict:
@@ -137,14 +138,8 @@ def update_ships(ships, line) -> dict:
     :rtype:
     """
 
-    if line[2] not in ships["class"]:
-        ships["class"][line[2]] = {"count": 0}
-
-    if line[3] not in ships["type"]:
-        ships["type"][line[3]] = {"count": 0}
-
-    ships["class"][line[2]]["count"] += 1
-    ships["type"][line[3]]["count"] += 1
+    ships["class"].setdefault(line[2], {"count": 0})["count"] += 1
+    ships["type"].setdefault(line[3], {"count": 0})["count"] += 1
 
     return ships
 
@@ -162,14 +157,11 @@ def handle_fleet_composition_and_participation(pilots, ships) -> tuple:
     """
 
     fleet_composition = get_fleet_composition(pilots=pilots, ships=ships)
-    participation = None
-
-    if AppSettings.INTELTOOL_ENABLE_MODULE_CHATSCAN is True:
-        participation = parse_pilots(
-            scan_data=list(set(pilots)),
-            safe_to_db=False,
-            ignore_limit=True,
-        )
+    participation = (
+        parse_pilots(scan_data=list(set(pilots)), safe_to_db=False, ignore_limit=True)
+        if AppSettings.INTELTOOL_ENABLE_MODULE_CHATSCAN
+        else None
+    )
 
     return fleet_composition, participation
 
@@ -184,59 +176,50 @@ def parse(scan_data: list) -> Scan:
     :rtype:
     """
 
-    message = _("The fleet composition module is currently disabled.")
-
-    if AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP is True:
-        parsed_data = {}
-        pilots = {}
-        ships = {"type": {}, "class": {}}
-        lines = []
-
-        # Loop through the scan data
-        for entry in scan_data:
-            line = parse_line(entry)
-
-            pilots[line[0]] = {
-                "name": line[0],
-                "solarsystem": line[1],
-                "ship": line[2],
-                "ship_type": line[3],
-            }
-            ships = update_ships(ships=ships, line=line)
-
-            lines.append(line)
-
-        fleet_composition, participation = handle_fleet_composition_and_participation(
-            pilots=pilots, ships=ships
+    if not AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP:
+        raise ParserError(
+            message=_("The fleet composition module is currently disabled.")
         )
 
-        logger.debug(msg=fleet_composition)
+    parsed_data = {}
+    pilots = {}
+    ships = {"type": {}, "class": {}}
 
-        # Add "ship classes" to parsed data when available
-        if fleet_composition["classes"]:
-            parsed_data["classes"] = {
-                "section": ScanData.Section.SHIPLIST,
-                "data": fleet_composition["classes"],
-            }
-
-        # Add "ship types" to parsed data when available
-        if fleet_composition["types"]:
-            parsed_data["shiptypes"] = {
-                "section": ScanData.Section.SHIPTYPES,
-                "data": fleet_composition["types"],
-            }
+    # Loop through the scan data
+    for entry in scan_data:
+        line = parse_line(entry)
 
-        # Add "who is flying what" (the actual fleet composition) to parsed data when available
-        if fleet_composition["pilots"]:
-            parsed_data["pilots_flying"] = {
-                "section": ScanData.Section.FLEETCOMPOSITION,
-                "data": fleet_composition["pilots"],
-            }
-
-        # Add fleet participation data to the parsed data
-        if participation:
-            parsed_data.update(participation)
+        pilots[line[0]] = {
+            "name": line[0],
+            "solarsystem": line[1],
+            "ship": line[2],
+            "ship_type": line[3],
+        }
+        ships = update_ships(ships=ships, line=line)
 
-        return safe_scan_to_db(scan_type=Scan.Type.FLEETCOMP, parsed_data=parsed_data)
+    fleet_composition, participation = handle_fleet_composition_and_participation(
+        pilots=pilots, ships=ships
+    )
 
-    raise ParserError(message=message)
+    logger.debug(msg=fleet_composition)
+
+    # Add parsed data when available
+    if fleet_composition["classes"]:
+        parsed_data["classes"] = {
+            "section": ScanData.Section.SHIPLIST,
+            "data": fleet_composition["classes"],
+        }
+    if fleet_composition["types"]:
+        parsed_data["shiptypes"] = {
+            "section": ScanData.Section.SHIPTYPES,
+            "data": fleet_composition["types"],
+        }
+    if fleet_composition["pilots"]:
+        parsed_data["pilots_flying"] = {
+            "section": ScanData.Section.FLEETCOMPOSITION,
+            "data": fleet_composition["pilots"],
+        }
+    if participation:
+        parsed_data.update(participation)
+
+    return safe_scan_to_db(scan_type=Scan.Type.FLEETCOMP, parsed_data=parsed_data)

aa_intel_tool/static/aa_intel_tool/css/aa-intel-tool.css

@@ -34,27 +34,18 @@
         font-size: 1.25em;
     }
 
-    .aa-intel-tool .aa-intel-alliance-logo-wrapper,
-    .aa-intel-tool .aa-intel-corporation-logo-wrapper,
-    .aa-intel-tool .aa-intel-pilot-avatar-wrapper,
-    .aa-intel-tool .aa-intel-ship-image-wrapper {
+    .aa-intel-tool .aa-intel-eve-image-wrapper {
         display: inline-block;
         margin-right: 0.5rem;
     }
 
-    .aa-intel-tool .aa-intel-alliance-information-wrapper,
-    .aa-intel-tool .aa-intel-corporation-information-wrapper,
-    .aa-intel-tool .aa-intel-pilot-information-wrapper {
+    .aa-intel-tool .aa-intel-eve-information-wrapper {
         display: inline-block;
         vertical-align: inherit;
     }
 
-    .aa-intel-tool .aa-intel-alliance-name-wrapper,
-    .aa-intel-tool .aa-intel-alliance-links-wrapper,
-    .aa-intel-tool .aa-intel-corporation-name-wrapper,
-    .aa-intel-tool .aa-intel-corporation-links-wrapper,
-    .aa-intel-tool .aa-intel-pilot-name-wrapper,
-    .aa-intel-tool .aa-intel-pilot-links-wrapper {
+    .aa-intel-tool .aa-intel-eve-name-wrapper,
+    .aa-intel-tool .aa-intel-additional-information-wrapper {
         display: block;
     }
 }
@@ -84,11 +75,6 @@
 /* Data Tables
 ------------------------------------------------------------------------------------- */
 @media all {
-    .aa-intel-tool div.dataTables_filter input[type="search"] {
-        margin-left: 0 !important;
-        width: 100% !important;
-    }
-
     .aa-intel-tool div.dataTables_wrapper div.dataTables_info {
         padding-top: 8px;
         white-space: initial;
@@ -124,15 +110,11 @@
         white-space: nowrap;
     }
 
-    .aa-intel-alliance-information-wrapper,
-    .aa-intel-corporation-information-wrapper,
-    .aa-intel-pilot-information-wrapper {
+    .aa-intel-tool .aa-intel-eve-information-wrapper {
         max-width: calc(100% - 35px);
     }
 
-    .aa-intel-alliance-name-wrapper,
-    .aa-intel-corporation-name-wrapper,
-    .aa-intel-pilot-name-wrapper {
+    .aa-intel-tool .aa-intel-eve-name-wrapper {
         overflow: hidden;
         text-overflow: ellipsis;
     }