Put the pieces together

vortexify create transform demand_model
vortexify create api predict_demand
vortexify create app planner

from io import StringIO

import pandas as pd
from vortexify import Input, vxfy_transform


SAMPLE_CSV = """spend,orders
0,30
100,44
200,58
300,69
400,86
500,97
600,113
700,123
"""


@vxfy_transform(inputs={"training_csv": Input(str, default=SAMPLE_CSV)})
def transform(training_csv: str) -> pd.DataFrame:
    data = pd.read_csv(StringIO(training_csv))
    x = data["spend"].astype(float)
    y = data["orders"].astype(float)
    if len(data) < 2 or not x.notna().all() or not y.notna().all():
        raise ValueError("Provide at least two complete observations")
    denominator = ((x - x.mean()) ** 2).sum()
    if denominator <= 0:
        raise ValueError("Training spend must vary")
    slope = ((x - x.mean()) * (y - y.mean())).sum() / denominator
    intercept = y.mean() - slope * x.mean()
    return pd.DataFrame([{
        "intercept": float(intercept),
        "slope": float(slope),
        "sample_count": len(data),
        "min_spend": float(x.min()),
        "max_spend": float(x.max()),
    }])

from vortexify.testing import vxfy_mocks, vxfy_test


@vxfy_mocks
def known_line():
    return {"training_csv": "spend,orders\n0,10\n100,30\n200,50\n"}


@vxfy_test(mocks=known_line)
def test_fitted_line(run):
    model = run().iloc[0]
    assert abs(model["intercept"] - 10.0) < 1e-8
    assert abs(model["slope"] - 0.2) < 1e-8

vortexify commit --type transform --resource demand_model
vortexify test transform demand_model --wait
vortexify run transform demand_model --wait

from math import isfinite

import pandas as pd
from vortexify import Input, TransformOutput, vxfy_api


@vxfy_api(
    "/predict-demand",
    inputs={
        "model": TransformOutput("demand_model"),
        "spend": Input(float, default=400.0),
    },
)
def api(model: pd.DataFrame, spend: float) -> dict:
    if not isfinite(spend) or spend < 0:
        raise ValueError("Spend must be a finite, nonnegative number")
    row = model.iloc[0]
    if not float(row["min_spend"]) <= spend <= float(row["max_spend"]):
        raise ValueError("Use spend within the sample range: 0 to 700")
    prediction = float(row["intercept"]) + float(row["slope"]) * spend
    return {
        "predicted_orders": round(max(0.0, prediction)),
        "sample_count": int(row["sample_count"]),
    }

import pandas as pd
from vortexify.testing import vxfy_mocks, vxfy_test


@vxfy_mocks
def simple_model():
    return {
        "model": pd.DataFrame([{
            "intercept": 10.0, "slope": 0.2, "sample_count": 3,
            "min_spend": 0.0, "max_spend": 700.0,
        }]),
        "spend": 100.0,
    }


@vxfy_test(mocks=simple_model)
def test_prediction(run):
    assert run() == {"predicted_orders": 30, "sample_count": 3}

vortexify commit --type api --resource predict_demand
vortexify test api predict_demand --wait
vortexify build api predict_demand --wait
vortexify run api predict_demand --wait

import { useState } from "react";
import type { FormEvent } from "react";
import { useVortexify } from "@vortexify/react";


type Prediction = { predicted_orders: number; sample_count: number };

export default function App() {
  const { client, ready } = useVortexify();
  const [spend, setSpend] = useState("400");
  const [result, setResult] = useState<Prediction | null>(null);
  const [pending, setPending] = useState(false);
  const [error, setError] = useState<string | null>(null);

  async function predict(event: FormEvent<HTMLFormElement>) {
    event.preventDefault();
    setPending(true);
    setError(null);
    setResult(null);
    try {
      const response = await client.runApi<Prediction>("predict_demand", {
        spend: Number(spend),
      });
      setResult(response);
    } catch (cause) {
      setError(cause instanceof Error ? cause.message : "Prediction failed");
    } finally {
      setPending(false);
    }
  }

  return (
    <main className="planner">
      <nav><span className="mark">v.</span><strong>Demand planner</strong>
        <span className="badge">SYNTHETIC DATA</span></nav>
      <header><p className="eyebrow">A SMALL WHAT-IF TOOL</p>
        <h1>Turn a question into<br />something you can use.</h1>
        <p>Try a weekly budget. See what a simple model estimates.</p></header>
      <div className="grid">
        <section className="card">
          <p className="eyebrow">01 / YOUR INPUT</p>
          <h2>Plan a week</h2><p>Change one number and explore the result.</p>
          <form onSubmit={predict}>
            <label htmlFor="spend">Weekly advertising budget</label>
            <div className="money"><span>$</span><input id="spend" type="number"
              min="0" max="700" step="any" required value={spend}
              disabled={pending}
              onChange={(event) => { setSpend(event.target.value); setResult(null); }} /></div>
            <small>Sample range: $0–$700 per week</small>
            <button disabled={!ready || pending}>
              {pending ? "Estimating…" : "Estimate orders →"}
            </button>
          </form>
          {error && <p className="error" role="alert">{error}</p>}
        </section>
        <section className="card result" aria-live="polite" aria-busy={pending}>
          <p className="eyebrow">02 / YOUR ESTIMATE</p>
          <div className="number">{result ? result.predicted_orders : "—"}</div>
          <h2>estimated orders / week</h2>
          <p>A prediction from the sample data, ready for your next decision.</p>
          <div className="facts"><div><strong>{result ? result.sample_count : "8"}</strong>
            <span>sample weeks</span></div><div><strong>Linear</strong><span>regression model</span></div></div>
        </section>
      </div>
      <footer>Small dataset. Python model. An API. Your interface.<br />
        Demonstration only · Synthetic data does not establish real-world accuracy.</footer>
    </main>
  );
}

cd apps/planner
npm install
vortexify dev

cd ../..
vortexify commit --type app --resource planner
vortexify deploy transform demand_model --wait

vortexify deploy api predict_demand --wait
vortexify deploy app planner --wait