Pashudhan Nutri AI API

curl -X POST https://pashudhan-nutri-ai.web.app/api/formulate \
  -H "x-api-key: pd_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ ... }'

Python >= 3.8
requests >= 2.28

import pashudhan_ai

# Option 1: Pass key directly
client = pashudhan_ai.Client(api_key="pd_your_key_here")

# Option 2: Set environment variable PASHUDHAN_API_KEY
client = pashudhan_ai.Client()  # reads from env automatically

result = client.formulate(
    animal_type       = "cow",
    breed             = "Sahiwal",
    body_weight_kg    = 380,
    milk_yield_kg_day = 10,
    fat_pct           = 4.2,
    production_stage  = "mid_lactation",
    state             = "Rajasthan",
    month             = 11,
    use_ai            = True,      # enable AI Nutritionist critique
    location          = "Jaipur"   # fetch live weather data
)

# Access all 4 strategies
for opt in result.formulations:
    print(f"[{opt.mode}] Cost: {opt.total_cost_local_day}/day  NEL={opt.nutrients.nel_mcal_kg_dm} Mcal/kg")

# Access AI Explanation
if result.ai_explanation:
    print("AI says:", result.ai_explanation)

# Access Live THI data
if result.thi_report:
    print(f"Live THI: {result.thi_report.thi} ({result.thi_report.category})")

# Access Metabolic Report (Requires Pro/Enterprise Plan)
if result.metabolic_report:
    print(f"Methane: {result.metabolic_report.methane.enteric_ch4_g_day} g/day")
    print(f"RUP/RDP Status: {result.metabolic_report.rup_rdp.ratio_status}")

status = client.status()
print(status.plan)          # "starter" / "pro" / "pro_max"
print(status.calls_used)    # API calls used this month
print(status.calls_limit)   # monthly limit

{
  "request_id": "req_abc123",
  "formulations": [
    {
      "mode": "least_cost",
      "total_cost_local_day": 248.50,
      "feed_cost_local_day": 220.0,
      "formulation": {
        "ingredients": [
          { "name": "Wheat Straw",  "kg_fresh_day": 5.0, "cost_local_day": 22.5 },
          { "name": "Maize Grain",  "kg_fresh_day": 3.5, "cost_local_day": 87.5 }
        ],
        "nutrient_summary": { "NEL_Mcal_day": 22.1, "CP_g_day": 1680, "NDF_pct_DM": 32.4 },
        "ai_explanation": "Option 1 is the cheapest but has severe nutrient gaps. A calcium supplement MUST be added.",
        "ai_warnings": [
          "DANGEROUS Ca:P RATIO: The calcium-to-phosphorus ratio is 0.51 — far below the safe minimum of 1.5:1."
        ]
      },
      "palatability": { "score": 88, "refusal_probability_pct": 8 },
      "adaptive_reasoning": ["Ration is nutritionally balanced. Consider adding bypass fat..."],
      "biogas_analysis": {
        "effective_mode": "balanced_biogas",
        "mode_override_reason": "Lactating animal \u2014 auto-switched to balanced_biogas",
        "fresh_dung_kg": 42.4,
        "fecal_dm_kg": 7.2,
        "biogas_liters": 1350,
        "methane_liters": 810,
        "slurry_kg": 22.0,
        "economics": {
          "biogas_revenue_day": 47.0,
          "milk_revenue_change_day": -14.0,
          "slurry_revenue_day": 11.0,
          "net_benefit_day": 44.0,
          "net_benefit_month": 1320.0
        }
      }
    }
  ],
  "thi_report": { "thi": 78, "category": "mild_stress", "adjusted_water_L_day": 82 },
  "metabolic_report": { 
    "methane": { "enteric_CH4_g_day": 345, "CO2e_kg_year": 3524, "vs_benchmark_pct": -4, "mitigation_tips": ["Increase fat"], "applicable": true },
    "rup_rdp": { "ratio_status": "Optimal", "actual_rdp_rup_ratio": "65:35", "applicable": true }
  }
}

{
  "state": "Punjab",
  "month": 5,
  "farmer_ingredients": ["Wheat Straw", "Maize Grain"],
  "groups": [
    {
      "category": "Lactating",
      "entries": [
        {
          "animal_type": "cow",
          "breed": "HF_crossbred",
          "count": 10,
          "body_weight_kg": 500,
          "milk_yield_kg_day": 20,
          "milk_fat_pct": 3.5,
          "production_stage": "mid_lactation"
        }
      ]
    }
  ]
}

{
  "herd_summary": {
    "total_animals": 10,
    "total_feed_cost_inr": 2485.00,
    "avg_cost_per_animal_inr": 248.50,
    "thi": 78
  },
  "groups": [
    {
      "category": "Lactating",
      "animal_count": 10,
      "total_group_cost_inr": 2485.00,
      "formulation": {
        "strategy": "least_cost",
        "ingredients": [
          { "name": "Wheat Straw", "kg_fresh_day": 50.0, "cost_inr": 225.0 },
          { "name": "Maize Grain", "kg_fresh_day": 35.0, "cost_inr": 875.0 }
        ],
        "nutrients": { "NEL_Mcal_day": 221.0, "CP_g_day": 16800 },
        "ai_explanation": "Group is well-balanced. Monitor heat stress impact on DMI."
      }
    }
  ]
}

curl https://pashudhan-nutri-ai.web.app/api/plans

curl https://pashudhan-nutri-ai.web.app/api/enterprise/status \
  -H "x-api-key: pd_your_key_here"

# Response:
{
  "plan": "starter",
  "monthly_limit": 1000,
  "requests_used": 142
}

# India (Default)
curl "https://pashudhan-nutri-ai.web.app/api/ingredients-list?country=India" \
  -H "x-api-key: pd_your_key_here"

# USA
curl "https://pashudhan-nutri-ai.web.app/api/ingredients-list?country=USA" \
  -H "x-api-key: pd_your_key_here"

curl https://pashudhan-nutri-ai.web.app/api/countries

# India (Default)
curl "https://pashudhan-nutri-ai.web.app/api/breeds?country=India"

# USA
curl "https://pashudhan-nutri-ai.web.app/api/breeds?country=USA"

import pashudhan_ai

client = pashudhan_ai.Client(api_key="pd_your_enterprise_key")

# Add your cooperative's formulated concentrate
# Values come from the feed bag or your lab analysis
ing = client.add_custom_ingredient(
    name             = "Amul Krishi Concentrate A",
    CP_pct           = 22.0,   # Crude Protein % (bag label)
    fat_pct          = 3.5,    # Crude Fat %
    fibre_pct        = 8.0,    # Crude Fibre %
    ash_pct          = 9.0,    # Total Ash %
    moisture_pct     = 11.0,   # Moisture %
    price_inr_per_kg = 26.0,   # Your cost price ₹/kg
    category         = "energy_concentrate",
    Ca_pct           = 0.8,    # Optional: Calcium if on bag
    P_pct            = 0.6,    # Optional: Phosphorus if on bag
    max_inclusion_pct= 35.0,   # Max % of DM ration
)
print(ing["id"])        # custom_abc123
print(ing["TDN_pct"])   # 82.24  ← auto-derived by server
print(ing["NEL_Mcal_kg_DM"])  # 1.74  ← auto-derived

# ── Now every formulation via your API key includes this ingredient ──
result = client.formulate(
    animal_type="cow", breed="HF_crossbred",
    body_weight_kg=500, milk_yield_kg_day=20.0, fat_pct=3.8,
    production_stage="mid_lactation",
    state="Gujarat", month=6,
)
# Amul Krishi Concentrate A appears in result if nutritionally beneficial

{
  "name": "Super Yield Pellet",
  "price_INR_kg_fresh": 22.50,
  "moisture_pct": 12.0,
  "CP_pct_DM": 20.0,
  "EE_pct_DM": 4.5,
  "crude_fibre_pct": 10.0,
  "ash_pct_DM": 8.0
}

import pashudhan_ai

client = pashudhan_ai.Client(api_key="pd_your_key_here")

# Register an animal
animal = client.register_animal(
    name             = "Rani",
    animal_type      = "buffalo",
    breed            = "Murrah_buffalo",
    current_stage    = "mid_lactation",
    parity           = 3,
    tag_id           = "MH-042",
)
print(animal.animal_id)   # e.g. "a3f9c1b2"

# List all animals
animals = client.list_animals()
for a in animals:
    lp = a.learned_profile
    print(a.name, f"avg_fat={lp.avg_fat_pct}% conf={lp.confidence_level}")

# Filter by dairy farm
farm_animals = client.list_animals(dairy_id="d4a2b7c8e1")

# Submit a milk-slip outcome
outcome = client.record_outcome(
    animal_id            = "a3f9c1b2",
    actual_milk_yield_kg = 19.5,
    actual_fat_pct       = 7.2,
    actual_snf_pct       = 8.9,
    health_events        = ["normal"],
)

# After 15+ outcomes, confidence = "high" — formulations
# automatically use the animal's learned profile
updated = client.get_animal("a3f9c1b2")
print(updated.learned_profile.confidence_level)   # "medium" / "high"
print(updated.learned_profile.avg_fat_pct)         # e.g. 7.1

# All animal registry methods
client.register_animal(name, animal_type, breed, ...)  # → AnimalProfile
client.list_animals(dairy_id=None)                     # → List[AnimalProfile]
client.get_animal(animal_id)                           # → AnimalProfile
client.delete_animal(animal_id)                        # → bool
client.record_outcome(animal_id, milk_kg, fat_pct, ...) # → AnimalOutcome

# AnimalProfile attributes
animal.animal_id          # "a3f9c1b2"
animal.name               # "Rani"
animal.breed              # "Murrah_buffalo"
animal.fat_trend          # "above_avg" / "average" / "below_avg" (property)
animal.learned_profile    # LearnedProfile object
  .avg_fat_pct            # 7.1
  .avg_milk_yield_kg      # 19.2
  .confidence_level       # "low" | "medium" | "high"
  .total_outcomes_recorded  # 18

# Create a dairy farm
farm = client.register_dairy(
    name     = "Singh Dairy — Ludhiana Unit 2",
    location = "Ludhiana, Punjab",
)
print(farm.dairy_id)   # e.g. "d4a2b7c8e1"

# Register animals under this farm
animal = client.register_animal(
    name        = "Rani",
    animal_type = "buffalo",
    breed       = "Murrah_buffalo",
    dairy_id    = farm.dairy_id,   # ← namespace to farm
)

# List all dairy farms
farms = client.list_dairies()
for farm in farms:
    print(farm.name, farm.location, farm.animal_count)

# Full per-farm workflow
farms = client.list_dairies()
for farm in farms:
    animals = client.list_animals(dairy_id=farm.dairy_id)
    print(f"{farm.name}: {len(animals)} animals")
    for a in animals:
        result = client.formulate(
            animal_type       = a.animal_type,
            breed             = a.breed,
            body_weight_kg    = 480,
            milk_yield_kg_day = a.learned_profile.avg_milk_yield_kg or 15,
            fat_pct           = a.learned_profile.avg_fat_pct or 6.5,
            production_stage  = a.current_stage,
            state             = "Punjab",
            month             = 7,
        )
        print(f"{a.name}: ₹{result.least_cost.total_cost_local_day:.0f}/day")

# Multi-dairy methods (enterprise only)
client.register_dairy(name, location="")   # → DairyFarm
client.list_dairies()                       # → List[DairyFarm]
client.delete_dairy(dairy_id)               # → bool (deletes all animals)

# DairyFarm attributes
farm.dairy_id      # "d4a2b7c8e1"
farm.name          # "Singh Dairy — Ludhiana Unit 2"
farm.location      # "Ludhiana, Punjab"
farm.animal_count  # 24
farm.created_at    # ISO timestamp

import pashudhan_ai
client = pashudhan_ai.Client(api_key="pd_your_enterprise_key")

# Get your coop_id and current plan status
status = client.status()
print(status.plan)         # ent_pro
print(status.calls_used)   # 247

billing = client.cooperative.get_billing()
print(billing)
# {"plan": "ent_pro", "monthly_limit": 1000, "requests_used": 247, ...}

# Your coop_id is visible in the billing keys list
keys = client.list_api_keys()
print(keys[0]["key_prefix"])   # pd_a1b2c3... (first 10 chars)

client.cooperative.set_branding(
    company_name    = "Amul Dairy Tech",
    tagline         = "Smart Nutrition for Every Farmer",
    logo_url        = "https://cdn.amul.com/logo.png",
    primary_color   = "#B71C1C",
    secondary_color = "#F57F17",
    contact_email   = "support@amuldairy.com",
    contact_phone   = "+91-2692-258506",
)

# 1. Save credentials (your Meta Cloud API token + Phone Number ID)
client.cooperative.set_whatsapp(
    phone_number_id = "123456789012345",
    access_token    = "EAABwzLixnjY...",
    verify_token    = "my_coop_verify_secret",  # you choose this
    display_name    = "Amul Krishi Sahayak",
)

# 2. In Meta Developer Console → Webhooks, register:
#    Webhook URL:  https://pashudhan-nutri-ai.web.app/api/whatsapp/coop/{coop_id}
#    Verify Token: my_coop_verify_secret
#    Fields:       messages
#
# That's it. Farmers now WhatsApp your number and get rations in your brand.

# Add your concentrate (values from feed bag or lab analysis)
client.add_custom_ingredient(
    name             = "Amul Krishi Concentrate A",
    CP_pct           = 22.0,
    fat_pct          = 3.5,
    fibre_pct        = 8.0,
    ash_pct          = 9.0,
    moisture_pct     = 11.0,
    price_inr_per_kg = 26.0,
    category         = "energy_concentrate",
)
# Server auto-derives TDN, NEL, NDF, ADF, ME, DE from these 5 inputs
# Stored at: enterprises/{coop_id}/custom_ingredients/
# Loaded automatically for every /api/formulate call with your API key

coop = client.cooperative

# 5a. Add product to catalog
prod = coop.add_product(
    name           = "MilkBoost Mineral Mix",
    sku            = "AMBMM-500",
    category       = "mineral_supplement",
    target_nutrient= "Ca_pct_DM",
    dose_g_per_day = 100,
    price_inr      = 85,
    product_link   = "https://shop.amul.com/milkboost",
)

# 5b. Create recommendation rule: Ca deficit > 10% → recommend MilkBoost
coop.add_rule(
    nutrient_key       = "Ca_pct_DM",
    trigger_condition  = "deficit_pct_above",
    threshold          = 10,
    recommendation_type= "product",
    product_id         = prod["id"],
    suggested_qty_g    = 100,
    message_template   = "Ca deficit {gap_pct}%! Add {qty}g of {source} daily to fix this.",
    priority           = 3,
)

# 5c. Absolute threshold: Zn below 40 mg/kg → recommend zinc sulfate
coop.add_rule(
    nutrient_key       = "Zn_mg_kg",
    trigger_condition  = "below_absolute",
    threshold          = 40,
    recommendation_type= "ingredient",
    ingredient_id      = "zinc_sulfate",
    ingredient_name    = "Zinc Sulfate",
    suggested_qty_g    = 5,
    priority           = 1,
)

# All events (ERP integration)
coop.add_webhook(
    url="https://api.amuldairy.com/events",
    events=["*"],
    description="Main ERP — all events",
)

# Deficiency alerts only (SMS gateway / field officer app)
coop.add_webhook(
    url="https://sms.amul.com/deficiency-alerts",
    events=["deficiency.detected"],
    description="SMS alerts to field officers",
)

# Test delivery to verify your endpoints are reachable
for wh in coop.list_webhooks():
    result = coop.test_webhook(wh["id"])
    print(f"{wh['url']}: {'✓' if result['success'] else '✗'} {result['status_code']} ({result['duration_ms']}ms)")

result = client.formulate(
    animal_type       = "cow",
    breed             = "Sahiwal",
    body_weight_kg    = 420,
    milk_yield_kg_day = 14.0,
    fat_pct           = 4.5,
    production_stage  = "mid_lactation",
    state             = "Gujarat",
    month             = 6,
)

# Standard formulation output
least_cost = result.formulations[0]
print(f"Cost: ₹{least_cost.total_cost_inr}/day")

# B2B-only: your rules' recommendations injected into response
recs = result.cooperative_recommendations if hasattr(result, 'cooperative_recommendations') else []
for rec in recs:
    print(f"  [{rec['nutrient']}] {rec['message']}")
    print(f"  → Buy: {rec['link']}")

# Dashboard stats
dash = coop.get_dashboard()
print(f"Farmers served: {dash['total_farmers']}")
print(f"API calls:      {dash['api_calls_used']}/{dash['api_calls_limit']}")

# Farmer analytics (build your own CRM)
farmers = coop.list_farmers()
from collections import Counter
breeds = Counter(f["breed"] for f in farmers)
print(dict(breeds.most_common(5)))

# Webhook delivery health
for wh in coop.list_webhooks():
    logs = coop.get_webhook_logs(wh["id"])
    failed = [l for l in logs if not l["success"]]
    print(f"{wh['url']}: {len(failed)}/{len(logs)} failed")

{
  "cooperative_id": "uid_abc123",
  "plan": "pro",
  "branding": {
    "company_name": "Amul Dairy Tech",
    "tagline":     "Smart Nutrition for Every Farmer",
    "logo_url":    "https://example.com/logo.png",
    "primary_color":   "#B71C1C",
    "secondary_color": "#F57F17",
    "contact_email":   "support@amuldairy.com"
  }
}

{
  "api_calls_used":  847,
  "api_calls_limit": 1000,
  "plan":            "pro",
  "total_farmers":   156,
  "total_rules":     12,
  "total_products":  8
}

{
  "farmers": [
    {
      "farmer_id":    "918001234567",
      "channel":      "whatsapp",
      "action":       "formulation",
      "animal_type":  "cow",
      "breed":        "Sahiwal",
      "timestamp":    "2026-09-04T12:00:00Z",
      "cooperative_id": "uid_abc123"
    }
  ],
  "total": 156
}

# Pull all farmer interactions for your CRM
farmers = client.cooperative.list_farmers()

# Count unique farmers
unique = {f["farmer_id"] for f in farmers}
print(f"Unique farmers: {len(unique)}")

# Group by breed for analytics
from collections import Counter
breed_counts = Counter(f["breed"] for f in farmers)
for breed, count in breed_counts.most_common():
    print(f"  {breed}: {count} formulations")

import hmac, hashlib

# ─────────────────────────────────────────────────────────────────────────
# YOUR pd_ API KEY IS YOUR WEBHOOK SIGNING SECRET
# The same key you use in x-api-key is also used by Pashudhan to sign
# every outgoing webhook payload with HMAC-SHA256.
# X-Pashudhan-Signature contains the raw hexdigest (no "sha256=" prefix).
# ─────────────────────────────────────────────────────────────────────────

def verify_pashudhan_webhook(
    raw_body_bytes: bytes,
    signature_header: str,
    pd_api_key: str
) -> bool:
    """
    Verify that a webhook POST came from Pashudhan and was not tampered with.

    Args:
        raw_body_bytes:    The raw request body as bytes (do NOT re-serialize).
        signature_header:  Value of the X-Pashudhan-Signature header.
        pd_api_key:        Your pd_ Enterprise API key (same as x-api-key).

    Returns:
        True if authentic, False if tampered or wrong key.
    """
    expected = hmac.new(
        pd_api_key.encode("utf-8"),
        raw_body_bytes,
        hashlib.sha256
    ).hexdigest()  # raw hex — no "sha256=" prefix
    return hmac.compare_digest(expected, signature_header)


# ── Flask / FastAPI example ──────────────────────────────────────────────
# from flask import Flask, request, abort
# app = Flask(__name__)
# PD_API_KEY = "pd_your_key_here"
#
# @app.route("/webhook", methods=["POST"])
# def webhook():
#     raw = request.get_data()  # IMPORTANT: raw bytes, before any parsing
#     sig = request.headers.get("X-Pashudhan-Signature", "")
#     if not verify_pashudhan_webhook(raw, sig, PD_API_KEY):
#         abort(401, "Invalid signature")
#     event = request.json
#     print(event["event"], event["data"])  # formulation.complete, {ration:...}
#     return {"ok": True}

{
  "event":          "formulation.complete",
  "timestamp":      "2026-09-04T12:00:00.123Z",
  "cooperative_id": "uid_abc123",
  "api_version":    "2026-09",
  "data": {
    "formulation": {
      "farmer_id":       "918001234567",
      "animal_type":     "cow",
      "breed":           "HF_crossbred",
      "ration_cost_inr": 128.40,
      "formulation_id":  "rpt_xyz789"
    },
    "recommendations": []
  }
}

{
  "event":          "deficiency.detected",
  "timestamp":      "2026-09-04T12:00:01.456Z",
  "cooperative_id": "uid_abc123",
  "api_version":    "2026-09",
  "data": {
    "deficiencies": {
      "Ca_pct_DM": {
        "provided": 0.45,
        "required": 0.55,
        "gap_pct":  18.2
      }
    },
    "count": 1
  }
}

{
  "event":          "recommendation.triggered",
  "timestamp":      "2026-09-04T12:00:01.789Z",
  "cooperative_id": "uid_abc123",
  "api_version":    "2026-09",
  "data": {
    "recommendations": [
      {
        "rule_id":         "rule_001",
        "nutrient":        "Calcium (Ca)",
        "nutrient_key":    "Ca_pct_DM",
        "gap_pct":         18.2,
        "type":            "product",
        "source_name":     "MilkBoost Mineral Mix",
        "suggested_qty_g": 100,
        "price_inr":       85,
        "link":            "https://example.com/milkboost",
        "message":         "Calcium deficit of 18.2%! Add 100g of MilkBoost daily.",
        "priority":        3,
        "standard":        "ICAR"
      }
    ],
    "count": 1
  }
}

{
  "event":          "farmer.registered",
  "timestamp":      "2026-09-04T12:00:00.000Z",
  "cooperative_id": "uid_abc123",
  "api_version":    "2026-09",
  "data": {
    "farmer_id":   "918001234567",
    "channel":     "whatsapp"
  }
}

{
  "keys": [
    {
      "key_id":        "key_abc123",
      "name":          "Production Key",
      "key_prefix":    "pd_a1b2c3...",  // first 10 chars only
      "plan":          "ent_pro",
      "monthly_limit": 1000,
      "requests_used": 247,
      "active":        true,
      "created_at":    "2026-08-01T00:00:00Z"
    }
  ],
  "total_keys": 1
}

{
  "key_id":   "key_abc123",
  "api_key":  "pd_a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4",  // full key — only shown once
  "name":     "Production Key",
  "plan":     "ent_free",
  "limit":    5
}

import pashudhan_ai

client = pashudhan_ai.Client(api_key="pd_your_admin_key")

# List all keys
keys = client.list_api_keys()
for k in keys:
    print(f"{k['name']:20} {k['plan']:12} {k['requests_used']}/{k['monthly_limit']} calls")

# Generate a new key (returns full key ONCE)
new_key = client.generate_api_key(name="Mobile App Key", plan="ent_pro")
print(f"Key: {new_key['api_key']}")   # store this now — never shown again
print(f"ID:  {new_key['key_id']}")

# Rename a key
client.rename_api_key(new_key["key_id"], name="Production Mobile")

# Revoke a key
client.revoke_api_key(new_key["key_id"])   # irreversible

{
  "plan":               "ent_pro",
  "monthly_limit":      1000,
  "requests_used":      247,
  "requests_remaining": 753,
  "reset_date":         "2026-10-01",
  "keys": [
    {
      "key_id":        "key_abc123",
      "name":          "Production Key",
      "key_prefix":    "pd_a1b2c3...",
      "requests_used": 247,
      "active":        true
    }
  ]
}

billing = client.cooperative.get_billing()
print(f"Plan:      {billing['plan']}")
print(f"Used:      {billing['requests_used']}/{billing['monthly_limit']}")
print(f"Remaining: {billing['requests_remaining']}")
print(f"Resets:    {billing['reset_date']}")

{
  "logs": [
    {
      "timestamp":   "2026-09-04T12:00:01Z",
      "event":       "formulation.complete",
      "status_code": 200,
      "duration_ms": 124,
      "attempt":     1,
      "success":     true
    },
    {
      "timestamp":   "2026-09-04T11:00:01Z",
      "event":       "deficiency.detected",
      "status_code": 503,
      "duration_ms": 10000,
      "attempt":     3,
      "success":     false
    }
  ]
}

{
  "status_code": 200,
  "duration_ms": 89,
  "success":     true
}

# List all webhooks
webhooks = client.cooperative.list_webhooks()
for wh in webhooks:
    print(f"{wh['url']} → events: {wh['events']}")

# Test a webhook (check reachability)
result = client.cooperative.test_webhook(webhooks[0]["id"])
print(f"Test: {result['status_code']} in {result['duration_ms']}ms")

# View delivery logs
logs = client.cooperative.get_webhook_logs(webhooks[0]["id"])
for log in logs:
    status = "✓" if log["success"] else "✗"
    print(f"  {status} {log['timestamp']} {log['event']} → {log['status_code']} ({log['duration_ms']}ms, attempt {log['attempt']})")

# Delete a webhook + all its logs (no orphaned data)
client.cooperative.delete_webhook(webhooks[0]["id"])

import pashudhan_ai

client = pashudhan_ai.Client(api_key="pd_your_enterprise_key")

# ── 1. Custom branding ──────────────────────────────────────────────
client.cooperative.set_branding(
    company_name   = "Amul Dairy Tech",
    tagline        = "Smart Nutrition for Every Farmer",
    logo_url       = "https://cdn.amul.com/logo.png",
    primary_color  = "#B71C1C",
    secondary_color= "#F57F17",
    contact_email  = "support@amuldairy.com",
    contact_phone  = "+91-2692-258506",
)

# ── 2. WhatsApp configuration ────────────────────────────────────────────
client.cooperative.set_whatsapp(
    phone_number_id = "123456789012345",
    access_token    = "EAABwzLixnjY...",  # Meta System User Token
    verify_token    = "my_custom_verify_secret",
    display_name    = "Amul Krishi Sahayak",
)

# ── 3. Add products to your catalog ─────────────────────────────────────
prod = client.cooperative.add_product(
    name           = "Amul MilkBoost Mineral Mix",
    sku            = "AMBMM-500",
    category       = "mineral_supplement",
    target_nutrient= "Ca_pct_DM",
    dose_g_per_day = 100,
    price_inr      = 85,
    product_link   = "https://shop.amul.com/milkboost",
    description    = "Premium Ca-P mix for dairy cows",
)
print(prod["id"])  # "prod_abc123"

# ── 4. Create recommendation rules ──────────────────────────────────────
client.cooperative.add_rule(
    nutrient_key       = "Ca_pct_DM",
    trigger_condition  = "deficit_pct_above",
    threshold          = 10,           # fires if Ca > 10% short
    recommendation_type= "product",
    product_id         = prod["id"],
    product_name       = "Amul MilkBoost Mineral Mix",
    product_link       = "https://shop.amul.com/milkboost",
    suggested_qty_g    = 100,
    message_template   = "Ca deficit {gap_pct}%! Add {qty}g of {source} daily.",
    priority           = 3,
)

# ── 5. Register an outgoing webhook ─────────────────────────────────────
client.cooperative.add_webhook(
    url         = "https://api.amuldairy.com/events",
    events      = ["*"],
    description = "Main ERP — all events",
)
client.cooperative.add_webhook(
    url         = "https://sms.amul.com/deficiency-alerts",
    events      = ["deficiency.detected"],
    description = "SMS alerts — deficiency only",
)

# ── 6. Retrieve analytics ────────────────────────────────────────────────
dashboard = client.cooperative.get_dashboard()
print(f"Farmers served: {dashboard['total_farmers']}")
print(f"API calls: {dashboard['api_calls_used']}/{dashboard['api_calls_limit']}")

# ── 7. View webhook delivery logs ────────────────────────────────────────
webhooks = client.cooperative.list_webhooks()
for wh in webhooks:
    logs = client.cooperative.get_webhook_logs(wh["id"])
    print(f"{wh['url']}: {len(logs)} deliveries")

# Using the SDK helper (recommended)
from pashudhan_ai import WebhookVerifier

verifier = WebhookVerifier(api_key="pd_your_enterprise_key")

# In your Flask/FastAPI/Django view:
def my_webhook_handler(request):
    raw_body = request.get_data()  # raw bytes — do NOT parse first
    signature = request.headers.get("X-Pashudhan-Signature", "")

    if not verifier.verify(raw_body, signature):
        return {"error": "Invalid signature"}, 401

    event = request.json  # now safe to parse
    if event["event"] == "recommendation.triggered":
        recs = event["data"]["recommendations"]
        for rec in recs:
            print(f"Push to farmer: {rec['message']} → {rec['link']}")
    return {"ok": True}

# Manual verification (without SDK):
import hmac, hashlib

def verify_pashudhan_webhook(raw_body_bytes, signature_header, pd_api_key):
    expected = hmac.new(
        pd_api_key.encode("utf-8"),
        raw_body_bytes,
        hashlib.sha256
    ).hexdigest()  # raw hex — NO "sha256=" prefix
    return hmac.compare_digest(expected, signature_header)

{
  "formulations": [...],  // same as standard API
  "cooperative_recommendations": [
    {
      "rule_id":         "rule_001",
      "nutrient":        "Calcium (Ca)",
      "gap_pct":         18.2,
      "type":            "product",
      "source_name":     "MilkBoost Mineral Mix",
      "suggested_qty_g": 100,
      "price_inr":       85,
      "link":            "https://shop.amul.com/milkboost",
      "message":         "Ca deficit 18.2%! Add 100g daily.",
      "priority":        3,
      "standard":        "ICAR"
    }
  ],
  "cooperative_id": "uid_abc123"
}