aa-moonmining 2.2.2__tar.gz → 3.0.0a1__tar.gz

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aa-moonmining
-Version: 2.2.2
+Version: 3.0.0a1
 Summary: Alliance Auth app for tracking moon extractions and scouting new moons.
 Author-email: Erik Kalkoken <kaloken87@gmail.com>
 Requires-Python: >=3.8
@@ -8,29 +8,33 @@ Description-Content-Type: text/markdown
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
 Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 License-File: LICENSE
-Requires-Dist: allianceauth-app-utils>=1.27
-Requires-Dist: allianceauth>=4,<5
+Requires-Dist: allianceauth-app-utils>=1.31.0a1
+Requires-Dist: allianceauth>=4,<6
+Requires-Dist: django-esi>=8,<10
 Requires-Dist: django-bootstrap-form
 Requires-Dist: django-datatables-view>=1.20
-Requires-Dist: django-eveuniverse>=1.0
+Requires-Dist: django-eveuniverse>=2.0.0a5
 Requires-Dist: django-navhelper
 Requires-Dist: PyYAML
+Requires-Dist: coverage ; extra == "test"
+Requires-Dist: factory_boy ; extra == "test"
+Requires-Dist: pook ; extra == "test"
 Project-URL: Changelog, https://gitlab.com/ErikKalkoken/aa-moonmining/-/blob/master/CHANGELOG.md
 Project-URL: Homepage, https://gitlab.com/ErikKalkoken/aa-moonmining
 Project-URL: Source, https://gitlab.com/ErikKalkoken/aa-moonmining
 Project-URL: Tracker, https://gitlab.com/ErikKalkoken/aa-moonmining/-/issues
+Provides-Extra: test
 
 # Moon Mining
 

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/__init__.py

@@ -3,5 +3,5 @@
 # pylint: disable = invalid-name
 default_app_config = "moonmining.apps.MoonMiningConfig"
 
-__version__ = "2.2.2"
+__version__ = "3.0.0a1"
 __title__ = "Moon Mining"

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/constants.py

@@ -7,19 +7,24 @@ class EveCategoryId(IntEnum):
     """An Eve category ID."""
 
     ASTEROID = 25
+    CELESTIAL = 2
+    MATERIAL = 4
+    STRUCTURE = 65
 
 
 class EveGroupId(IntEnum):
     """An Eve group ID."""
 
-    MOON = 8
+    CITADEL = 1657
+    COMMON_MOON_ASTEROIDS = 1920
+    EXCEPTIONAL_MOON_ASTEROIDS = 1923
     MINERAL = 18
+    MOON = 8
+    MOON_MATERIALS = 427
+    RARE_MOON_ASTEROIDS = 1922
     REFINERY = 1406
     UBIQUITOUS_MOON_ASTEROIDS = 1884
-    COMMON_MOON_ASTEROIDS = 1920
     UNCOMMON_MOON_ASTEROIDS = 1921
-    RARE_MOON_ASTEROIDS = 1922
-    EXCEPTIONAL_MOON_ASTEROIDS = 1923
 
 
 class EveTypeId(IntEnum):

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/core.py

@@ -100,7 +100,11 @@ class CalculatedExtractionProduct:
     @classmethod
     def create_list_from_dict(cls, ores: dict) -> List["CalculatedExtractionProduct"]:
         """Return list of newly created objs from a dict."""
-        return [cls(ore_type_id, volume) for ore_type_id, volume in ores.items()]
+        lst = sorted(
+            [cls(ore_type_id, volume) for ore_type_id, volume in ores.items()],
+            key=lambda o: o.ore_type_id,
+        )
+        return lst
 
 
 @dataclass

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/helpers.py

@@ -5,6 +5,7 @@ from collections import defaultdict
 from typing import List
 
 from django.utils.html import format_html
+from esi.exceptions import HTTPError
 from eveuniverse.models import EveEntity
 
 from allianceauth.authentication.models import User
@@ -29,7 +30,7 @@ def eve_entity_get_or_create_esi_safe(id):
         try:
             entity, _ = EveEntity.objects.get_or_create_esi(id=id)
             return entity
-        except OSError:
+        except HTTPError:
             pass
     return None
 

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/management/commands/moonmining_calculate_all.py

@@ -2,14 +2,12 @@ import logging
 
 from django.core.management.base import BaseCommand
 
-from app_utils.logging import LoggerAddTag
-
-from moonmining import __title__, tasks
+from moonmining import tasks
 from moonmining.models import Extraction, Moon
 
 from . import get_input
 
-logger = LoggerAddTag(logging.getLogger(__name__), __title__)
+logger = logging.getLogger(__name__)
 
 
 class Command(BaseCommand):

aa_moonmining-3.0.0a1/moonmining/management/commands/moonmining_import_moons.py

@@ -0,0 +1,136 @@
+import csv
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List
+
+from django.core.management.base import BaseCommand, CommandError
+from eveuniverse.core.esitools import is_esi_online
+from eveuniverse.models import EveMoon
+
+from allianceauth.services.hooks import get_extension_logger
+
+from moonmining.core import CalculatedMoonProduct
+from moonmining.models import EveOreType, Moon, MoonProduct
+
+logger = get_extension_logger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Import moons from an CSV file."
+
+    def add_arguments(self, parser):
+        parser.add_argument("input_file", help="Path of CSV file to be imported")
+        parser.add_argument(
+            "--overwrite-existing",
+            action="store_const",
+            const=True,
+            default=False,
+            help="When set will overwrite existing moon surveys",
+        )
+        parser.add_argument(
+            "--disable-esi-check",
+            action="store_const",
+            const=False,
+            default=False,
+            help="When set script will not check if ESI is online",
+        )
+
+    def handle(self, *args, **options):
+        if not options["disable_esi_check"] and not is_esi_online():
+            raise CommandError("ESI if offline. Aborting")
+
+        input_file = Path(options["input_file"])
+        if not input_file.exists():
+            raise CommandError(
+                f"Could not find a file with the path: {input_file.resolve()}"
+            )
+
+        moons = self.read_moons(input_file)
+        total = len(moons.keys())
+        self.stdout.write(f"Read {total:,} moons from file.")
+        if not options["overwrite_existing"]:
+            found = self.remove_existing_moons(moons)
+            if found > 0:
+                self.stdout.write(
+                    f"Skipping update of {found:,} moons with existing surveys."
+                )
+
+        total_2 = len(moons.keys())
+        self.stdout.write(f"Starting update of {total_2:,} moons.")
+
+        try:
+            self.update_moons(moons)
+        except KeyboardInterrupt:
+            self.stdout.write(self.style.WARNING("Aborted"))
+
+        self.stdout.write(self.style.SUCCESS("DONE"))
+
+    def read_moons(self, input_file: Path) -> Dict[int, List[CalculatedMoonProduct]]:
+        self.stdout.write(f"Importing moons from: {input_file} ...")
+        moons: Dict[int, List[CalculatedMoonProduct]] = defaultdict(list)
+        with input_file.open("r", encoding="utf-8") as fp:
+            csv_reader = csv.DictReader(fp)
+            for row in csv_reader:
+                try:
+                    moon_id = int(row["moon_id"])
+                    ore_type_id = int(row["ore_type_id"])
+                    amount = float(row["amount"])
+                except KeyError:
+                    continue
+
+                product = CalculatedMoonProduct(
+                    ore_type_id=ore_type_id,
+                    amount=amount,
+                )
+                moons[moon_id].append(product)
+
+        if not len(moons.keys()):
+            raise CommandError("Could not find any moons in the input file.")
+
+        return moons
+
+    def remove_existing_moons(
+        self, moons: Dict[int, List[CalculatedMoonProduct]]
+    ) -> int:
+        existing = set(
+            Moon.objects.filter(products__isnull=False).values_list(
+                "eve_moon__id", flat=True
+            )
+        )
+        overlapping = existing.intersection(moons.keys())
+        removed = 0
+        for moon_id in overlapping:
+            del moons[moon_id]
+            removed += 1
+
+        return removed
+
+    def update_moons(self, moons: Dict[int, List[CalculatedMoonProduct]]):
+        amount = len(moons)
+        completed = 0
+        for eve_moon_id, products in moons.items():
+            created_ores = []
+            for p in products:
+                _, created = EveOreType.objects.get_or_create_esi(id=p.ore_type_id)
+                created_ores.append(created)
+            if any(created_ores):
+                EveOreType.objects.update_current_prices()
+
+            eve_moon, _ = EveMoon.objects.get_or_create_esi(id=eve_moon_id)
+            moon, _ = Moon.objects.get_or_create(eve_moon=eve_moon)
+
+            product_objects = []
+            for p in products:
+                product_objects.append(
+                    MoonProduct(
+                        moon_id=moon.id, ore_type_id=p.ore_type_id, amount=p.amount
+                    )
+                )
+            moon.update_products(product_objects)
+
+            completed += 1
+            progress = round(completed / amount * 100, 1)
+            self.stdout.write(f"Updated: {str(moon):30} [Progress: {progress}%]")
+            logger.info(
+                "Added survey for moon ID %d with import command", moon.eve_moon.id
+            )

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/management/commands/moonmining_load_eve.py

@@ -3,15 +3,13 @@ from eveuniverse.models import EveType
 from eveuniverse.tasks import update_or_create_eve_object
 
 from allianceauth.services.hooks import get_extension_logger
-from app_utils.logging import LoggerAddTag
 
-from moonmining import __title__
 from moonmining.constants import EveCategoryId
 from moonmining.models import EveOreType
 
 from . import get_input
 
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = get_extension_logger(__name__)
 
 
 class Command(BaseCommand):

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/managers.py

@@ -17,9 +17,7 @@ from eveuniverse.models import EveMoon
 
 from allianceauth.notifications import notify
 from allianceauth.services.hooks import get_extension_logger
-from app_utils.logging import LoggerAddTag
 
-from . import __title__
 from .app_settings import (
     MOONMINING_REPROCESSING_YIELD,
     MOONMINING_USE_REPROCESS_PRICING,
@@ -30,7 +28,7 @@ from .helpers import eve_entity_get_or_create_esi_safe
 
 MAX_THREAD_WORKERS = 20
 BULK_BATCH_SIZE = 500
-logger = LoggerAddTag(get_extension_logger(__name__), __title__)
+logger = get_extension_logger(__name__)
 
 SurveyProcessResult = namedtuple(
     "SurveyProcessResult", ["moon_name", "success", "error_name"]
@@ -50,11 +48,12 @@ class EveOreTypeManger(EveTypeManager):
 
     def update_current_prices(self, use_process_pricing: Optional[bool] = None):
         """Update current prices for all ores."""
-        from .models import EveOreTypeExtras
+        from .models import EveOreType, EveOreTypeExtras
 
         if use_process_pricing is None:
             use_process_pricing = MOONMINING_USE_REPROCESS_PRICING
 
+        obj: EveOreType
         for obj in self.filter(published=True).select_related("market_price"):
             if use_process_pricing:
                 price = obj.calc_refined_value_per_unit(MOONMINING_REPROCESSING_YIELD)
@@ -413,9 +412,3 @@ class ExtractionManagerBase(models.Manager):
 
 
 ExtractionManager = ExtractionManagerBase.from_queryset(ExtractionQuerySet)
-
-
-class RefineryManager(models.Manager):
-    def ids(self) -> set:
-        """Return IDs of this queryset."""
-        return set(self.values_list("id", flat=True))

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/models/extractions.py

@@ -213,7 +213,7 @@ class Extraction(models.Model):
         return self.duration.total_seconds() / (60 * 60 * 24)
 
     @property
-    def status_enum(self) -> "Extraction.Status":
+    def status_2(self) -> "Extraction.Status":
         """Return current status as enum type."""
         return self.Status(self.status)
 

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/models/moons.py

@@ -120,6 +120,11 @@ class Moon(models.Model):
         """Return name of this moon."""
         return self.eve_moon.name.replace("Moon ", "")
 
+    @property
+    def id(self) -> int:
+        """Return id of this moon."""
+        return self.eve_moon.id
+
     def region(self) -> EveRegion:
         """Return region."""
         return self.solar_system().eve_constellation.eve_region

{aa_moonmining-2.2.2 → aa_moonmining-3.0.0a1}/moonmining/models/notifications.py

@@ -105,10 +105,10 @@ class Notification(models.Model):
 
     def to_calculated_extraction(self) -> CalculatedExtraction:
         """Generate a calculated extraction from this notification."""
-        params = {"refinery_id": self.details["structureID"]}
-        if self.notif_type == NotificationType.MOONMINING_EXTRACTION_STARTED:
-            params.update(
-                {
+        match self.notif_type:
+            case NotificationType.MOONMINING_EXTRACTION_STARTED:
+                params = {
+                    "refinery_id": self.details["structureID"],
                     "status": CalculatedExtraction.Status.STARTED,
                     "chunk_arrival_at": ldap_time_2_datetime(self.details["readyTime"]),
                     "auto_fracture_at": ldap_time_2_datetime(self.details["autoTime"]),
@@ -118,23 +118,28 @@ class Notification(models.Model):
                         self.details["oreVolumeByType"]
                     ),
                 }
-            )
-        elif self.notif_type == NotificationType.MOONMINING_EXTRACTION_FINISHED:
-            params.update(
-                {
+
+            case NotificationType.MOONMINING_EXTRACTION_CANCELLED:
+                params = {
+                    "refinery_id": self.details["structureID"],
+                    "status": CalculatedExtraction.Status.CANCELED,
+                    "canceled_at": self.timestamp,
+                    "canceled_by": self.details.get("cancelledBy"),
+                }
+
+            case NotificationType.MOONMINING_EXTRACTION_FINISHED:
+                params = {
+                    "refinery_id": self.details["structureID"],
                     "status": CalculatedExtraction.Status.READY,
                     "auto_fracture_at": ldap_time_2_datetime(self.details["autoTime"]),
                     "products": CalculatedExtractionProduct.create_list_from_dict(
                         self.details["oreVolumeByType"]
                     ),
                 }
-            )
-        elif self.notif_type in {
-            NotificationType.MOONMINING_LASER_FIRED,
-            NotificationType.MOONMINING_AUTOMATIC_FRACTURE,
-        }:
-            params.update(
-                {
+
+            case NotificationType.MOONMINING_LASER_FIRED:
+                params = {
+                    "refinery_id": self.details["structureID"],
                     "fractured_by": self.details.get("firedBy"),
                     "fractured_at": self.timestamp,
                     "status": CalculatedExtraction.Status.COMPLETED,
@@ -142,13 +147,18 @@ class Notification(models.Model):
                         self.details["oreVolumeByType"]
                     ),
                 }
-            )
-        elif self.notif_type == NotificationType.MOONMINING_EXTRACTION_CANCELLED:
-            params.update(
-                {
-                    "status": CalculatedExtraction.Status.CANCELED,
-                    "canceled_at": self.timestamp,
-                    "canceled_by": self.details.get("cancelledBy"),
+
+            case NotificationType.MOONMINING_AUTOMATIC_FRACTURE:
+                params = {
+                    "refinery_id": self.details["structureID"],
+                    "fractured_at": self.timestamp,
+                    "status": CalculatedExtraction.Status.COMPLETED,
+                    "products": CalculatedExtractionProduct.create_list_from_dict(
+                        self.details["oreVolumeByType"]
+                    ),
                 }
-            )
+
+            case _:
+                raise NotImplementedError(f"not implemented for: {self.notif_type}")
+
         return CalculatedExtraction(**params)