🎨 Refactor some data scripts a bit.

Author: coderanger

py/droprates.py

@@ -17,6 +17,33 @@ def total_drops() -> dict[str, dict[str, int]]:
     return totals
 
 
+def rates_per_stam() -> dict[str, dict[str, float]]:
+    rates = {}
+    for loc, loc_data in total_drops().items():
+        loc_rates = {}
+        for item, drops in loc_data["drops"].items():
+            if item == "ALL":
+                continue
+            loc_rates[item] = drops / loc_data["stamina"]
+        rates[loc] = loc_rates
+    return rates
+
+
+def drop_rates() -> dict[str, dict[str, float]]:
+    rates = {}
+    for loc, loc_data in total_drops().items():
+        zone_total = sum(
+            drops for item, drops in loc_data["drops"].items() if item != "ALL"
+        )
+        loc_rates = {}
+        for item, drops in loc_data["drops"].items():
+            if item == "ALL":
+                continue
+            loc_rates[item] = drops / zone_total
+        rates[loc] = loc_rates
+    return rates
+
+
 if __name__ == "__main__":
     item_filter = sys.argv[1] if len(sys.argv) > 1 else None
     combined_stam_per_drop = {}
@@ -25,11 +52,11 @@ def total_drops() -> dict[str, dict[str, int]]:
         for item, drops in sorted(zone_totals["drops"].items()):
             if item_filter and item != item_filter:
                 continue
-            stam_per_drop = zone_totals['stamina'] / drops
+            stam_per_drop = zone_totals["stamina"] / drops
             if stam_per_drop < combined_stam_per_drop.get(item, 1000000000000):
                 combined_stam_per_drop[item] = stam_per_drop
             print(f"\t{item}: {stam_per_drop} ({drops})")
 
     print("Combined:")
     for item, stam_per_drop in sorted(combined_stam_per_drop.items()):
-        print(f"        \"{item}\": {stam_per_drop},")
+        print(f'        "{item}": {stam_per_drop},')

py/exp_vs_lem.py

@@ -0,0 +1,21 @@
+import droprates
+import lemonade
+
+lem = lemonade.drop_rates()
+# exp = droprates.rates_per_stam()
+exp = droprates.drop_rates()
+
+locations = set(lem.keys()) | set(exp.keys())
+
+for loc in sorted(locations):
+    print(f"{loc}:")
+    lem_data = lem.get(loc, {})
+    exp_data = exp.get(loc, {})
+    items = set(lem_data.keys()) | set(exp_data.keys())
+    for item in sorted(items):
+        lem_rate = lem_data.get(item, 0)
+        exp_rate = exp_data.get(item, 0)
+        if lem_rate == 0 or exp_rate == 0:
+            print(f"\t{item}: NO MATCH")
+        else:
+            print(f"\t{item}: {lem_rate / exp_rate}")

py/fishrates.py

@@ -1,36 +1,50 @@
 import fixtures
 import parse_logs
 
-totals = {}
 
-prices = {}
-for item in fixtures.load_items():
-    if item.sell_price:
-        prices[item.name] = item.sell_price
+def net_totals() -> dict[str, dict[str:float]]:
+    totals = {}
+    for row in parse_logs.parse_logs("net"):
+        zone_name = row["results"].get("location")
+        if not zone_name:
+            continue
+        zone_totals = totals.setdefault(zone_name, {"nets": 0, "drops": {}})
+        zone_totals["nets"] += 1
+        for item in row["results"]["items"]:
+            zone_totals["drops"][item["item"]] = (
+                zone_totals["drops"].get(item["item"], 0) + 1
+            )
+    return totals
 
-for row in parse_logs.parse_logs("net"):
-    zone_name = row["results"].get("location")
-    if not zone_name:
-        continue
-    zone_totals = totals.setdefault(zone_name, {"nets": 0, "drops": {}})
-    zone_totals["nets"] += 1
-    for item in row["results"]["items"]:
-        zone_totals["drops"][item["item"]] = (
-            zone_totals["drops"].get(item["item"], 0) + 1
-        )
 
-for zone, zone_data in sorted(totals.items()):
-    print(f"{zone} ({zone_data['nets']}):")
-    zone_total = sum(zone_data["drops"].values())
-    percs = {
-        item: (count, (count / zone_total) * 100)
-        for item, count in zone_data["drops"].items()
-    }
-    value_of_drop = 0
-    for item, (count, percent) in sorted(
-        percs.items(), reverse=True, key=lambda kv: kv[1][1]
-    ):
-        print(f"\t{item}: {percent:.4f}% ({count})")
-        if item in prices:
-            value_of_drop += (percent / 100) * prices[item]
-    print(f"\tNet: {value_of_drop * 15}")
+def net_rates() -> dict[str, dict[str:float]]:
+    rates = {}
+    for zone, zone_data in net_totals().items():
+        zone_total = sum(zone_data["drops"].values())
+        rates[zone] = {
+            item: count / zone_total for item, count in zone_data["drops"].items()
+        }
+    return rates
+
+
+if __name__ == "__main__":
+    prices = {}
+    for item in fixtures.load_items():
+        if item.sell_price:
+            prices[item.name] = item.sell_price
+
+    for zone, zone_data in sorted(net_totals().items()):
+        print(f"{zone} ({zone_data['nets']}):")
+        zone_total = sum(zone_data["drops"].values())
+        percs = {
+            item: (count, (count / zone_total) * 100)
+            for item, count in zone_data["drops"].items()
+        }
+        value_of_drop = 0
+        for item, (count, percent) in sorted(
+            percs.items(), reverse=True, key=lambda kv: kv[1][1]
+        ):
+            print(f"\t{item}: {percent:.4f}% ({count})")
+            if item in prices:
+                value_of_drop += (percent / 100) * prices[item]
+        print(f"\tNet: {value_of_drop * 15}")

py/lemonade.py

@@ -1,26 +1,51 @@
+from collections import Counter
+
+import fixtures
 import parse_logs
 
-totals = {}
-
-for row in parse_logs.parse_logs("lemonade"):
-    zone_name = row["results"].get("location")
-    if not zone_name:
-        continue
-    zone_totals = totals.setdefault(zone_name, {"lemonades": 0, "drops": {}})
-    zone_totals["lemonades"] += 1
-    for item in row["results"]["items"]:
-        zone_totals["drops"][item["item"]] = (
-            zone_totals["drops"].get(item["item"], 0) + 1
-        )
-
-for zone, zone_data in sorted(totals.items()):
-    print(f"{zone} ({zone_data['lemonades']}):")
-    zone_total = sum(zone_data["drops"].values())
-    percs = {
-        item: (count, (count / zone_total) * 100)
-        for item, count in zone_data["drops"].items()
-    }
-    for item, (count, percent) in sorted(
-        percs.items(), reverse=True, key=lambda kv: kv[1][1]
-    ):
-        print(f"\t{item}: {percent:.4f}% ({count})")
+
+def total_drops():
+    totals = {}
+    for row in parse_logs.parse_logs("lemonade"):
+        zone_name = row["results"].get("location")
+        if not zone_name:
+            continue
+        zone_totals = totals.setdefault(zone_name, {"lemonades": 0, "drops": {}})
+        zone_totals["lemonades"] += 1
+        for item in row["results"]["items"]:
+            zone_totals["drops"][item["item"]] = (
+                zone_totals["drops"].get(item["item"], 0) + 1
+            )
+    return totals
+
+
+def drop_rates() -> dict[str, dict[str, float]]:
+    rates = {}
+    for zone, zone_data in total_drops().items():
+        zone_total = sum(zone_data["drops"].values())
+        rates[zone] = {
+            item: count / zone_total for item, count in zone_data["drops"].items()
+        }
+    return rates
+
+
+if __name__ == "__main__":
+    items = {it.name: it for it in fixtures.load_items()}
+
+    for zone, zone_data in sorted(total_drops().items()):
+        print(f"{zone} ({zone_data['lemonades']}):")
+        zone_total = sum(zone_data["drops"].values())
+        percs = {
+            item: (count, (count / zone_total) * 100)
+            for item, count in zone_data["drops"].items()
+        }
+        for item, (count, percent) in sorted(
+            percs.items(), reverse=True, key=lambda kv: kv[1][1]
+        ):
+            print(f"\t{item}: {percent:.4f}% ({count})")
+
+        drops_by_rarity: Counter[str, int] = Counter()
+        for item, count in zone_data["drops"].items():
+            drops_by_rarity[items[item].rarity or "NONE"] += count
+        for rarity, count in sorted(drops_by_rarity.items()):
+            print(f"\t{rarity.upper()}: {(count * 100 / zone_total):.4f}")