From the SMT line
to the ledger: factory auto-pilot

# modbus_read.py — older PLC over Modbus/TCP holding registers
from pymodbus.client import ModbusTcpClient   # pip install pymodbus

def read_modbus(host="10.20.0.7", unit=1):
    c = ModbusTcpClient(host); c.connect()
    # 40001-40002 = good (32-bit), 40003 = scrap
    rr = c.read_holding_registers(0, 3, slave=unit)
    good = (rr.registers[0] << 16) + rr.registers[1]
    scrap = rr.registers[2]; c.close()
    return {"good": good, "scrap": scrap,
            "yield": round(good / max(1, good + scrap), 4)}

# mqtt_read.py — Industry-4.0 gateway publishing to a broker
import json, paho.mqtt.client as mqtt   # pip install paho-mqtt
latest = {}

def on_message(client, _u, msg):
    latest.update(json.loads(msg.payload))   # {"good":..,"scrap":..}

def subscribe(host="10.20.0.9", topic="factory/lineA/shift"):
    cli = mqtt.Client(); cli.on_message = on_message
    cli.connect(host, 1883); cli.subscribe(topic); cli.loop_start()
    return latest   # read latest["good"] / latest["scrap"] any time

# batch.py — turn raw counts into a production batch + BOM consumption
import datetime as dt

YIELD_FLOOR = 0.95

# Bill of Materials: finished SKU -> {component: qty per unit}
BOM = {
  "LED-A19-9W":  {"LED-CHIP-2835": 12, "PCB-A19": 1, "DRIVER-IC": 1, "HOUSING-A19": 1},
  "LED-T8-18W":  {"LED-CHIP-2835": 96, "PCB-T8": 1, "DRIVER-IC": 1, "TUBE-T8": 1},
  "LED-PNL-36W": {"LED-CHIP-2835": 144, "PCB-PNL": 1, "DRIVER-36W": 1, "FRAME-PNL": 1},
}

def build_batch(sku, line, shift, telem):
    good, scrap = telem["good"], telem["scrap"]
    y = good / max(1, good + scrap)
    batch = {
      "batch_id": f"{line}-{dt.date.today()}-{shift}",
      "sku": sku, "good": good, "scrap": scrap, "yield": round(y, 4),
      "consume": {c: q * good for c, q in BOM[sku].items()},
      "hold": y < YIELD_FLOOR,            # QC gate
    }
    return batch

def validate(batch):
    errs = []
    if batch["hold"]: errs.append(f"yield {batch['yield']:.1%} below floor")
    if batch["good"] < 0 or batch["scrap"] < 0: errs.append("negative count")
    return errs

# zoho_post.py — stock-in finished goods, consume components, auto-PO
import os, requests
BASE = "https://www.zohoapis.com/inventory/v1"
ORG  = os.environ["ZOHO_ORG_ID"]
H    = {"Authorization": f"Zoho-oauthtoken {os.environ['ZOHO_OAUTH_TOKEN']}"}

def item(sku):
    r = requests.get(f"{BASE}/items", headers=H, params={"organization_id": ORG, "sku": sku})
    hits = r.json().get("items", []); return hits[0] if hits else None

def adjust(sku, qty, reason):
    """One stock adjustment = one call. +qty stock-in, -qty consume."""
    it = item(sku)
    body = {"reason": reason, "adjustment_type": "quantity",
            "date": __import__("datetime").date.today().isoformat(),
            "line_items": [{"item_id": it["item_id"], "quantity_adjusted": qty}]}
    r = requests.post(f"{BASE}/inventoryadjustments?organization_id={ORG}", headers=H, json=body)
    r.raise_for_status(); return r.json()["inventory_adjustment"]["inventory_adjustment_id"]

def reorder_check(sku):
    """Below reorder point? Draft a PO to the preferred vendor."""
    it = item(sku)
    if float(it["stock_on_hand"]) >= float(it.get("reorder_level", 0)): return None
    qty = int(it.get("reorder_level", 0)) * 2   # simple reorder qty
    po = {"vendor_id": it["vendor_id"], "line_items": [
            {"item_id": it["item_id"], "quantity": qty, "rate": float(it["purchase_rate"])}]}
    r = requests.post(f"{BASE}/purchaseorders?organization_id={ORG}", headers=H, json=po)
    r.raise_for_status(); return r.json()["purchaseorder"]["purchaseorder_number"]

def post_batch(batch):
    log = [("stockin", batch["sku"], batch["good"], adjust(batch["sku"], batch["good"], "Production"))]
    for comp, qty in batch["consume"].items():
        log.append(("consume", comp, -qty, adjust(comp, -qty, f"BOM {batch['batch_id']}")))
        po = reorder_check(comp)
        if po: log.append(("reorder", comp, qty, po))
    return log

# webhook.py — receive line events + WhatsApp /post commands (FastAPI)
from fastapi import FastAPI, Request
import os, requests, line_read, batch, zoho_post

app = FastAPI()

def whatsapp(to, body):
    requests.post(f"https://graph.facebook.com/v21.0/{os.environ['WA_PHONE_ID']}/messages",
        headers={"Authorization": f"Bearer {os.environ['WA_TOKEN']}"},
        json={"messaging_product": "whatsapp", "to": to,
              "type": "text", "text": {"body": body}})

@app.get("/webhook")                       # Meta verification handshake
def verify(req: Request):
    p = req.query_params
    return int(p["hub.challenge"]) if p.get("hub.verify_token") == os.environ["VERIFY"] else "no"

@app.post("/webhook")                      # inbound WhatsApp messages
async def inbound(req: Request):
    data = await req.json()
    msg = data["entry"][0]["changes"][0]["value"]["messages"][0]
    text, sender = msg["text"]["body"], msg["from"]
    if text.startswith("/post"):
        _, line, date, shift = text.split()
        telem = await line_read.read_shift(line)
        b = batch.build_batch(SKU_FOR[line], line, shift, telem)
        errs = batch.validate(b)
        if errs:
            whatsapp(sender, f"HELD {b['batch_id']}: {', '.join(errs)}"); return {"ok": True}
        # dry-run summary first — wait for "yes" before zoho_post.post_batch(b)
        whatsapp(sender, f"{b['good']} good, {b['scrap']} scrap, "
                         f"{b['yield']:.1%} yield. Reply YES to post.")
    return {"ok": True}