initial commit

main.py

@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from math import ceil
+from typing import Dict, List, Tuple, Optional
+
+from flask import Flask, render_template, request
+from pydantic import BaseModel, Field
+
+app = Flask(__name__)
+
+class Item(BaseModel):
+    name: str
+
+class Machine(BaseModel):
+    name: str
+
+class Machines(Enum):
+    Miner = Machine(name="Miner")
+    Smelter =  Machine(name="Smelter")
+    Constructor = Machine(name="Constructor")
+    Assembler = Machine(name="Assembler")
+    Sorter = Machine(name="Sorter")
+    Crusher = Machine(name="Crusher")
+    Foundry = Machine(name="Foundry")
+
+class Items(Enum):
+    IronIngot = Item(name="Iron Ingot")
+    CopperIngot = Item(name="Copper Ingot")
+    Limestone = Item(name="Limestone")
+    IronOre = Item(name="Iron Ore")
+    CopperOre = Item(name="Copper Ore")
+    IronPlate = Item(name="Iron Plate")
+    IronRod = Item(name="Iron Rod")
+    Wire = Item(name="Wire")
+    Cable = Item(name="Cable")
+    Concrete = Item(name="Concrete")
+    ReinforcedIronPlate = Item(name="Reinforced Iron Plate")
+    ModularFrame = Item(name="Modular Frame")
+    BronzeBeam = Item(name="Bronze Beam")
+    TinPlate = Item(name="Tin Plate")
+    TinIngot = Item(name="Tin Ingot")
+    CrushedTin = Item(name="Crushed Tin")
+    CrushedIron = Item(name="Crushed Iron")
+    CrushedGangue = Item(name="Crushed Gangue")
+    CrushedSiterite = Item(name="Crushed Siterite")
+    SiteriteOre = Item(name="Siterite Ore")
+    Screws = Item(name="Screws")
+    BronzeIngot = Item(name="Bronze Ingot")
+    CrushedCopper = Item(name="Crushed Copper")
+    CrushedMagnesium = Item(name="Crushed Magnesium")
+    CrushedCallanite = Item(name="Crushed Callanite")
+    CallaniteOre = Item(name="Callanite Ore")
+
+class RawResources(Enum):
+    IronOre = Items.IronOre
+    CopperOre = Items.CopperOre
+    Limestone = Items.Limestone
+
+
+# --- Domain model (minimal, extensible) ---
+class Recipe(BaseModel):
+    name: str                 # Human-friendly name
+    building: Machines         # e.g., "Smelter", "Constructor"
+    outputs: Dict[Items, float]          # Produced item name
+    inputs: Dict[Items, float] = Field(default_factory=dict)
+
+
+# A very small starter dataset (default, non-alternate recipes)
+# Rates are per building per minute, matching Satisfactory default recipes.
+class Recipes(Enum):
+    ModularFrame = Recipe(
+        name="Modular Frame",
+        building=Machines.Assembler,
+        outputs={Items.ModularFrame: 6.0},
+        inputs={
+            Items.ReinforcedIronPlate: 7.5,
+            Items.BronzeBeam: 7.5,
+        },
+    )
+    ReinforcedIronPlate = Recipe(
+        name="Reinforced Iron Plate",
+        building=Machines.Assembler,
+        outputs={Items.ReinforcedIronPlate: 5.0},
+        inputs={
+            Items.TinPlate: 20.0,
+            Items.Screws: 37.5,
+        },
+    )
+    TinPlate = Recipe(
+        name="Tin Plate",
+        building=Machines.Assembler,
+        outputs={Items.TinPlate: 40.0},
+        inputs={
+            Items.IronPlate: 20.0,
+            Items.TinIngot: 30.0,
+        },
+    )
+    TinIngot = Recipe(
+        name="Tin Ingot",
+        building=Machines.Smelter,
+        outputs={Items.TinIngot: 15.0},
+        inputs={Items.CrushedTin: 15.0},
+    )
+    CrushedIron = Recipe(
+        name="Crushed Iron",
+        building=Machines.Sorter,
+        outputs={
+            Items.CrushedIron: 90.0,
+            Items.CrushedTin: 60.0,
+            Items.CrushedGangue: 40.0,
+        },
+        inputs={Items.CrushedSiterite: 120.0},
+    )
+    CrushedSiterite = Recipe(
+        name="Crushed Siterite",
+        building=Machines.Crusher,
+        outputs={
+            Items.CrushedSiterite: 60.0,
+            Items.CrushedGangue: 25.0,
+        },
+        inputs={Items.SiteriteOre: 60.0},
+    )
+    IronPlate = Recipe(
+        name="Iron Plate",
+        building=Machines.Constructor,
+        outputs={Items.IronPlate: 20.0},
+        inputs={Items.IronIngot: 30.0},
+    )
+    IronIngot = Recipe(
+        name="Iron Ingot",
+        building=Machines.Smelter,
+        outputs={Items.IronIngot: 30.0},
+        inputs={Items.CrushedIron: 30.0},
+    )
+    Screws = Recipe(
+        name="Screws",
+        building=Machines.Constructor,
+        outputs={Items.Screws: 50.0},
+        inputs={Items.IronRod: 20.0},
+    )
+    IronRod = Recipe(
+        name="Iron Rod",
+        building=Machines.Constructor,
+        outputs={Items.IronRod: 15.0},
+        inputs={Items.IronIngot: 15.0},
+    )
+    BronzeBeam = Recipe(
+        name="Bronze Beam",
+        building=Machines.Constructor,
+        outputs={Items.BronzeBeam: 7.5},
+        inputs={Items.BronzeIngot: 22.5},
+    )
+    BronzeIngot = Recipe(
+        name="Bronze Ingot",
+        building=Machines.Foundry,
+        outputs={Items.BronzeIngot: 45.0},
+        inputs={
+            Items.CopperIngot: 36.0,
+            Items.TinIngot: 15.0,
+        },
+    )
+    CopperIngot = Recipe(
+        name="Copper Ingot",
+        building=Machines.Smelter,
+        outputs={Items.CopperIngot: 48.0},
+        inputs={Items.CrushedCopper: 48.0},
+    )
+    CrushedCopper = Recipe(
+        name="Crushed Copper",
+        building=Machines.Sorter,
+        outputs={
+            Items.CrushedCopper: 96.0,
+            Items.CrushedMagnesium: 80.0,
+            Items.CrushedGangue: 40.0,
+        },
+        inputs={Items.CrushedCallanite: 120.0},
+    )
+    CrushedCallanite = Recipe(
+        name="Crushed Callanite",
+        building=Machines.Sorter,
+        outputs={
+            Items.CrushedCallanite: 60.0,
+            Items.CrushedGangue: 25.0,
+        },
+        inputs={Items.CallaniteOre: 60.0},
+    )
+
+
+# Items which are considered raw resources (mined); they have no crafting recipes here
+RAW_RESOURCES = {
+    Items.IronOre,
+    Items.CopperOre,
+    Items.Limestone,
+    Items.SiteriteOre,
+}
+
+
+def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[dict], Dict[str, float], Dict[str, float]]:
+    """
+    Given desired output rates (item -> units/min), compute:
+    - required raw input rates (raw item -> units/min)
+    - a flat list of steps with building counts and per-building utilization
+    - total production rates (echo of targets summed if multiple entries per item)
+    - unused byproducts (items/min) produced by multi-output recipes but not consumed or targeted
+    Uses the Recipes enum and Items objects.
+    """
+    # Build a mapping from output item -> recipe that produces it (default recipe set)
+    output_to_recipe: Dict[Items, Recipe] = {}
+    for r in Recipes:
+        recipe = r.value
+        for out_item in recipe.outputs.keys():
+            # prefer the first seen; can be extended to handle alternates later
+            output_to_recipe.setdefault(out_item, recipe)
+
+    # Aggregate demands for each item
+    demand: Dict[Items, float] = {}
+
+    def add_demand(item: Items, rate: float) -> None:
+        if rate == 0:
+            return
+        demand[item] = demand.get(item, 0.0) + rate
+
+    for item, rate in targets.items():
+        add_demand(item, rate)
+
+    # Work lists
+    steps: List[dict] = []
+    raw_requirements: Dict[str, float] = {}
+
+    # Track produced and consumed rates to calculate unused byproducts
+    produced: Dict[Items, float] = {}
+    consumed: Dict[Items, float] = {}
+
+    # Expand demanded craftable items into their inputs until only raw remain
+    while True:
+        craftable_item = next(
+            (i for i, r in demand.items() if r > 1e-9 and i in output_to_recipe),
+            None,
+        )
+        if craftable_item is None:
+            break
+
+        needed_rate = demand[craftable_item]
+        recipe = output_to_recipe[craftable_item]
+        per_building_output = recipe.outputs[craftable_item]
+
+        # Buildings needed
+        buildings = needed_rate / per_building_output
+        buildings_ceiled = ceil(buildings - 1e-9)
+        utilization = 0.0 if buildings_ceiled == 0 else buildings / buildings_ceiled
+
+        # Record the step (as display-friendly strings)
+        steps.append({
+            "item": craftable_item.value.name,
+            "recipe": recipe.name,
+            "building": recipe.building.value.name,
+            "target_rate": needed_rate,
+            "per_building_output": per_building_output,
+            "buildings_float": buildings,
+            "buildings": buildings_ceiled,
+            "utilization": utilization,
+        })
+
+        # Consume this demand and add input demands
+        demand[craftable_item] -= needed_rate
+
+        scale = buildings  # exact fractional buildings to match demand exactly
+
+        # Account for all outputs produced by this recipe at the chosen scale
+        for out_item, out_rate_per_build in (recipe.outputs or {}).items():
+            produced[out_item] = produced.get(out_item, 0.0) + out_rate_per_build * scale
+
+        # Add input demands and track consumption
+        for in_item, in_rate_per_build in (recipe.inputs or {}).items():
+            rate_needed = in_rate_per_build * scale
+            add_demand(in_item, rate_needed)
+            consumed[in_item] = consumed.get(in_item, 0.0) + rate_needed
+
+    # What's left in demand are raw items
+    for item, rate in demand.items():
+        if rate <= 1e-9:
+            continue
+        if item in RAW_RESOURCES or item not in output_to_recipe:
+            raw_requirements[item.value.name] = raw_requirements.get(item.value.name, 0.0) + rate
+        else:
+            # Shouldn't happen, but guard
+            raw_requirements[item.value.name] = raw_requirements.get(item.value.name, 0.0) + rate
+
+    # Merge steps for same item/building
+    merged: Dict[Tuple[str, str], dict] = {}
+    for s in steps:
+        key = (s["item"], s["building"])
+        if key not in merged:
+            merged[key] = {**s}
+        else:
+            m = merged[key]
+            m["target_rate"] += s["target_rate"]
+            m["buildings_float"] += s["buildings_float"]
+            m["buildings"] += s["buildings"]
+            total_buildings = m["buildings"]
+            m["utilization"] = 0.0 if total_buildings == 0 else m["buildings_float"] / total_buildings
+
+    merged_steps = sorted(merged.values(), key=lambda x: (x["building"], x["item"]))
+
+    # Echo total outputs (same as targets possibly aggregated), as item-name -> rate
+    total_outputs: Dict[str, float] = {}
+    for item, rate in targets.items():
+        total_outputs[item.value.name] = total_outputs.get(item.value.name, 0.0) + rate
+
+    # Compute unused byproducts: produced but not consumed and not part of explicit targets
+    unused_byproducts: Dict[str, float] = {}
+    for item, qty_produced in produced.items():
+        qty_consumed = consumed.get(item, 0.0)
+        qty_targeted = targets.get(item, 0.0)
+        unused = qty_produced - qty_consumed - qty_targeted
+        if unused > 1e-9:
+            unused_byproducts[item.value.name] = unused
+
+    return raw_requirements, merged_steps, total_outputs, unused_byproducts
+
+
+@app.route("/", methods=["GET", "POST"])
+def index():
+    # Build selectable items list from Items enum (display names)
+    item_names = sorted([i.value.name for i in Items])
+    name_to_item = {i.value.name: i for i in Items}
+
+    result = None
+    error = None
+    selected_item = item_names[0] if item_names else ""
+    selected_rate = 60.0
+
+    if request.method == "POST":
+        item_name = request.form.get("item") or selected_item
+        rate_str = request.form.get("rate")
+        try:
+            rate = float(rate_str)
+            if rate < 0:
+                raise ValueError
+        except (TypeError, ValueError):
+            error = "Please enter a valid non-negative number for rate (items per minute)."
+            rate = None
+
+        selected_item = item_name
+        if rate is not None:
+            selected_rate = rate
+
+        if not error and item_name and rate is not None:
+            item_obj = name_to_item.get(item_name)
+            if item_obj is None:
+                error = "Unknown item selected."
+            else:
+                targets = {item_obj: rate}
+                raw, steps, outputs, unused = compute_chain(targets)
+                result = {
+                    "targets": {item_name: rate},
+                    "raw": raw,
+                    "steps": steps,
+                    "outputs": outputs,
+                    "unused": unused,
+                }
+
+    return render_template(
+        "index.html",
+        items=item_names,
+        result=result,
+        error=error,
+        selected_item=selected_item,
+        selected_rate=selected_rate,
+    )
+
+
+def create_app():
+    return app
+
+
+if __name__ == "__main__":
+    # For local dev: python main.py
+    app.run(host="0.0.0.0", port=5000, debug=True)