| """Jevásio on Hugging Face Spaces (Gradio, ZeroGPU). |
| |
| A state and a set of typed questions in, a probability per option out, in one forward pass. The model is loaded through |
| Kev's own loader (kev.checkpoint), the same path `python -m kev.serve --run TigreGotico/jevasio-0.8b` takes, and |
| requests go through kev.api and kev.model.admit exactly as /v1/systemone does. Both sizes load in bf16 at start-up, and |
| each forward pass runs inside @spaces.GPU, so a request holds a GPU only for that pass. |
| """ |
| import html |
| import json |
| import os |
| import time |
| from dataclasses import replace |
|
|
| import gradio as gr |
| import spaces |
| import torch |
| from pydantic import ValidationError |
|
|
| from kev.api import SystemOneRequest, output_tokens, render, to_answers, to_record |
| from kev.checkpoint import Checkpoint, LoadOptions |
| from kev.model import admit |
|
|
| MODELS = {"Jevásio-4B-V2": "TigreGotico/jevasio-4b-v2", "Jevásio-0.8B-V2": "TigreGotico/jevasio-0.8b-v2", |
| "Jevásio-4B": "TigreGotico/jevasio-4b", "Jevásio-0.8B": "TigreGotico/jevasio-0.8b"} |
| |
| if os.environ.get("JEVASIO_MODELS"): |
| MODELS = {name: MODELS[name] for name in os.environ["JEVASIO_MODELS"].split(",")} |
| DEFAULT = "Jevásio-4B-V2" |
| LINK_08B = "https://huggingface.co/TigreGotico/jevasio-0.8b" |
| LINK_4B = "https://huggingface.co/TigreGotico/jevasio-4b" |
| LINK_08B_V2 = "https://huggingface.co/TigreGotico/jevasio-0.8b-v2" |
| LINK_4B_V2 = "https://huggingface.co/TigreGotico/jevasio-4b-v2" |
| LINK_DATA_V2 = "https://huggingface.co/datasets/TigreGotico/jevasio-decisions-v2" |
| LINK_DATA = "https://huggingface.co/datasets/TigreGotico/jevasio-decisions" |
|
|
| LOADED = {} |
| for name, repo in MODELS.items(): |
| t0 = time.perf_counter() |
| checkpoint = Checkpoint(repo) |
| opts = LoadOptions.from_env() |
| if opts.dtype is None: |
| opts = replace(opts, dtype=torch.bfloat16) |
| |
| |
| |
| key = name.split("-", 1)[1].replace(".", "").replace("-", "_").upper() |
| device = "cuda" if os.environ.get("SPACES_ZERO_GPU") else os.environ.get( |
| f"JEVASIO_DEVICE_{key}", "cuda" if torch.cuda.is_available() else "cpu") |
| tok, model = checkpoint.load("cpu", opts) |
| model.to(device) |
| model.device = torch.device(device) |
| LOADED[name] = tok, model |
| print(f"[jevasio] {repo}: base={checkpoint.meta.base}@{checkpoint.meta.base_revision} dtype={model.dtype} " |
| f"temperature={model.head.temperature:.2f} loaded in {time.perf_counter() - t0:.0f} s", flush=True) |
|
|
|
|
| @spaces.GPU(duration=30) |
| def forward(name, enc): |
| return [p.float().cpu() for p in LOADED[name][1].probs(enc)] |
|
|
|
|
| class RequestError(ValueError): |
| """A request the model cannot answer: bad JSON, a bad question, or a state that is too long.""" |
|
|
|
|
| def parse_request(payload): |
| try: |
| return SystemOneRequest.model_validate(payload) |
| except ValidationError as e: |
| first = e.errors()[0] |
| where = ".".join(str(x) for x in first.get("loc", ())) |
| raise RequestError(f"Pedido inválido em `{where}`: {first.get('msg')}") from None |
|
|
|
|
| def systemone(req, name=DEFAULT): |
| """The /v1/systemone response body kev.serve returns for this request, plus the latency of the forward pass.""" |
| if name not in LOADED: |
| raise RequestError(f"Modelo desconhecido: {name}. Opções: {', '.join(MODELS)}.") |
| tokenizer, model = LOADED[name] |
| rec, meta = to_record(req) |
| try: |
| enc = admit(model, tokenizer, rec) |
| except ValueError as e: |
| raise RequestError(str(e)) from None |
| start = time.perf_counter() |
| probs = forward(name, enc) |
| ms = (time.perf_counter() - start) * 1000 |
| answers = to_answers([p.tolist() for p in probs], meta) |
| return {"model": MODELS[name], "answers": answers, |
| "usage": {"input_tokens": len(enc["ids"]), "output_tokens": output_tokens(tokenizer, answers)}, |
| "latency_ms": round(ms, 1)} |
|
|
|
|
| |
|
|
| CARD = ("border:1px solid var(--border-color-primary);border-radius:10px;padding:12px 14px;margin-bottom:10px;" |
| "background:var(--background-fill-secondary);") |
| TRACK = "position:relative;display:block;height:8px;border-radius:999px;background:var(--border-color-primary);overflow:hidden;" |
| TYPE_LABEL = {"choice": "escolha", "noul": "sim/não", "score": "escala"} |
|
|
|
|
| def bar(label, p, top): |
| fill = "var(--color-accent)" if top else "var(--body-text-color-subdued)" |
| weight = "600" if top else "400" |
| width = max(0.0, min(1.0, p)) * 100 |
| return ('<div style="display:grid;grid-template-columns:minmax(0,12rem) minmax(0,1fr) 3.2rem;align-items:center;' |
| 'gap:0 12px;font-size:13px;line-height:24px">' |
| f'<span style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-weight:{weight}" ' |
| f'title="{html.escape(label)}">{html.escape(label)}</span>' |
| f'<span style="{TRACK}"><span style="position:absolute;top:0;bottom:0;left:0;border-radius:999px;' |
| f'background:{fill};width:{width:.1f}%"></span></span>' |
| f'<span style="text-align:right;font-variant-numeric:tabular-nums;font-weight:{weight}">{p:.2f}</span></div>') |
|
|
|
|
| def render_answers(req, resp): |
| usage = resp["usage"] |
| parts = ['<div style="font-size:12px;color:var(--body-text-color-subdued);margin:6px 0 10px">' |
| f'{len(resp["answers"])} pergunta(s) · {usage["input_tokens"]} tokens de entrada · ' |
| f'{resp["model"].split("/")[1]} · {resp["latency_ms"]:.0f} ms · nenhum texto gerado</div>'] |
| for qid, a in resp["answers"].items(): |
| instructions = render(req.questions[qid].instructions) |
| if a["type"] == "noul": |
| p = a["noul"] |
| headline, detail = ("sim" if p >= 0.5 else "não"), f"p(sim) {p:.2f}" |
| rows = bar("sim", p, p >= 0.5) + bar("não", 1 - p, p < 0.5) |
| elif a["type"] == "choice": |
| headline, detail = a["choice"], f"confiança {a['confidence']:.2f}" |
| ranked = sorted(a["probabilities"].items(), key=lambda kv: -kv[1]) |
| rows = "".join(bar(k, v, k == a["choice"]) for k, v in ranked) |
| else: |
| legend, dist = a["legend"], a["probabilities"] |
| top = max(dist, key=dist.get) |
| headline = f"{a['score']:.2f} de {len(legend) - 1}" |
| detail = f"confiança {a['confidence']:.2f}" |
| rows = "".join(bar(f"{i}. {legend[str(i)]}", dist[str(i)], str(i) == top) for i in range(len(legend))) |
| parts.append(f'<div style="{CARD}"><div style="display:flex;align-items:baseline;gap:8px;flex-wrap:wrap">' |
| f'<span style="font-family:var(--font-mono);font-size:13px;font-weight:600">{html.escape(qid)}</span>' |
| f'<span style="font-size:11px;color:var(--body-text-color-subdued)">· {TYPE_LABEL[a["type"]]}</span></div>' |
| f'<div style="font-size:13px;margin:2px 0 6px">{html.escape(instructions)}</div>' |
| '<div style="display:flex;align-items:baseline;gap:10px;margin-bottom:8px">' |
| f'<span style="font-size:17px;font-weight:600">{html.escape(str(headline))}</span>' |
| f'<span style="font-size:12px;color:var(--body-text-color-subdued)">{detail}</span></div>{rows}</div>') |
| return "".join(parts) |
|
|
|
|
| def error_html(message): |
| return (f'<div style="{CARD}border-color:var(--error-border-color, #d33);">' |
| f'<b>Erro:</b> {html.escape(message)}</div>') |
|
|
|
|
| |
|
|
| def parse_state(text): |
| """Plain text, or a JSON object or array.""" |
| t = (text or "").strip() |
| if t[:1] in "{[": |
| try: |
| return json.loads(t) |
| except json.JSONDecodeError: |
| pass |
| return t |
|
|
|
|
| def parse_options(text): |
| """One option per line, `name: description` or just `name`.""" |
| criteria = {} |
| for line in (text or "").splitlines(): |
| name, _, desc = line.partition(":") |
| name, desc = name.strip(), desc.strip() |
| if name: |
| criteria[name] = desc or None |
| return criteria |
|
|
|
|
| def build_request(state, choice_id, choice_instr, choice_opts, noul_id, noul_instr, score_id, score_instr, score_levels): |
| """The System One request the builder describes. A question with an empty id is left out.""" |
| ids = [i.strip() for i in (choice_id, noul_id, score_id) if i and i.strip()] |
| if len(ids) != len(set(ids)): |
| raise RequestError("Cada pergunta precisa de um id diferente.") |
| questions = {} |
| if choice_id.strip(): |
| questions[choice_id.strip()] = {"type": "choice", "instructions": choice_instr, "criteria": parse_options(choice_opts)} |
| if noul_id.strip(): |
| questions[noul_id.strip()] = {"type": "noul", "instructions": noul_instr} |
| if score_id.strip(): |
| levels = [line.strip() for line in (score_levels or "").splitlines() if line.strip()] |
| questions[score_id.strip()] = {"type": "score", "instructions": score_instr, "criteria": levels} |
| if not (state or "").strip(): |
| raise RequestError("Escreva um estado: o texto ou o objeto JSON que o modelo lê.") |
| if not questions: |
| raise RequestError("Defina pelo menos uma pergunta (um id não vazio).") |
| return {"state": parse_state(state), "model": "kev-latest", "questions": questions} |
|
|
|
|
| def decide(name, state, choice_id, choice_instr, choice_opts, noul_id, noul_instr, score_id, score_instr, score_levels): |
| """Answer the builder's questions about the state. Returns the rendered answers, the request and the response.""" |
| try: |
| payload = build_request(state, choice_id, choice_instr, choice_opts, noul_id, noul_instr, score_id, score_instr, score_levels) |
| req = parse_request(payload) |
| resp = systemone(req, name) |
| except RequestError as e: |
| return error_html(str(e)), {}, {"error": str(e)} |
| return render_answers(req, resp), payload, resp |
|
|
|
|
| def decide_raw(name, request_json): |
| """Answer a raw System One request (JSON text). Returns a status line and the response or an error object.""" |
| try: |
| payload = json.loads(request_json or "") |
| except json.JSONDecodeError as e: |
| message = f"JSON inválido: {e}" |
| return f"**Erro:** {message}", {"error": message} |
| if not isinstance(payload, dict): |
| message = 'O pedido tem de ser um objeto JSON com "state" e "questions".' |
| return f"**Erro:** {message}", {"error": message} |
| try: |
| resp = systemone(parse_request(payload), name) |
| except RequestError as e: |
| return f"**Erro:** {e}", {"error": str(e)} |
| return f"Respondido em {resp['latency_ms']:.0f} ms.", resp |
|
|
|
|
| |
|
|
| EXAMPLES = [ |
| { |
| "name": "Apoio ao cliente", |
| "state": "Bom dia. Fui cobrado duas vezes pela encomenda 1182 e o dinheiro já saiu da minha conta. " |
| "Preciso que devolvam uma das cobranças ainda hoje, porque tenho a renda para pagar amanhã.", |
| "choice": ("team", "Que equipa deve tratar deste pedido?", |
| "billing: Cobranças, faturas e reembolsos\nshipping: Entregas e atrasos\n" |
| "returns: Trocas e devoluções de artigos\ntechnical: Problemas no site ou na aplicação"), |
| "noul": ("urgent", "Este pedido precisa de resposta hoje?"), |
| "score": ("frustration", "Quão frustrado está o cliente?", "Calmo\nIncomodado\nMuito zangado"), |
| }, |
| { |
| "name": "Sentimento", |
| "state": "Fomos jantar ao restaurante novo da Baixa. A comida chegou fria, o empregado esqueceu-se das bebidas " |
| "e no fim ainda nos cobraram o couvert que não pedimos. Não voltamos.", |
| "choice": ("sentiment", "Qual é o sentimento geral do comentário?", |
| "positive: Positivo\nneutral: Neutro ou misto\nnegative: Negativo"), |
| "noul": ("recommends", "O autor recomenda o restaurante?"), |
| "score": ("intensity", "Com que intensidade o autor exprime a opinião?", "Fraca\nModerada\nForte"), |
| }, |
| { |
| "name": "Variedade do português", |
| "state": "Estou a escrever-te do autocarro porque o meu telemóvel ficou sem rede no comboio. " |
| "Logo à noite passo aí para irmos tomar um pequeno-almoço tardio, está bem?", |
| "choice": ("variety", "Em que variedade do português está escrito este texto?", |
| "pt_pt: Português europeu\npt_br: Português do Brasil"), |
| "noul": ("informal", "O texto usa um tom informal?"), |
| "score": ("register", "Qual é o registo do texto?", "Muito informal\nInformal\nNeutro\nFormal\nMuito formal"), |
| }, |
| { |
| "name": "Registo", |
| "state": "Exmo. Senhor Diretor, venho por este meio solicitar a V. Ex.ª a marcação de uma reunião, " |
| "com a maior brevidade possível, para tratar da renovação do contrato de prestação de serviços.", |
| "choice": ("text_type", "Que tipo de texto é este?", |
| "letter: Carta ou correio formal\nchat: Mensagem entre amigos\nnews: Notícia\nreview: Crítica ou opinião"), |
| "noul": ("asks_action", "O texto pede ao destinatário que faça alguma coisa?"), |
| "score": ("register", "Qual é o registo do texto?", "Muito informal\nInformal\nNeutro\nFormal\nMuito formal"), |
| }, |
| { |
| "name": "Mensagem a um serviço (V2)", |
| "state": '{"message": "Boa tarde. Recebi a fatura de março com um valor de 89 euros, quando o meu plano é de 35. ' |
| 'Já liguei duas vezes e ninguém resolve. Se não corrigirem até amanhã, cancelo o contrato."}', |
| "choice": ("department", "Que departamento deve tratar desta mensagem?", |
| "delivery: Entregas e envios\ncancellation: Cancelamentos e rescisões\nsales: Vendas e novos serviços\n" |
| "technical: Assistência técnica\ncomplaints: Reclamações\nbilling: Faturação e pagamentos"), |
| "noul": ("", ""), |
| "score": ("urgency", "Quão urgente é esta mensagem?", |
| "Pode esperar dias\nResponder nos próximos dias\nResponder hoje\nImediato: há risco ou dano"), |
| }, |
| { |
| "name": "Comando de voz (V2)", |
| "state": '{"request": "acorda-me amanhã às sete e meia que tenho de apanhar o comboio"}', |
| "choice": ("scenario", "A que domínio pertence este comando?", |
| "alarm: Alarmes\ncalendar: Agenda\ntransport: Transportes\nweather: Meteorologia\n" |
| "music: Preferências de música\niot: Casa inteligente"), |
| "noul": ("", ""), |
| "score": ("", "", ""), |
| }, |
| { |
| "name": "Secção do jornal (V2)", |
| "state": '{"title": "Câmara do Porto aprova novas regras para o alojamento local na Baixa", ' |
| '"text": "A Câmara Municipal do Porto aprovou esta terça-feira um regulamento que suspende novos registos de ' |
| 'alojamento local em seis freguesias do centro histórico durante dois anos."}', |
| "choice": ("section", "Em que secção do jornal saiu este artigo?", |
| "sports: Desporto\nlocal: Notícias locais\ntechnology: Tecnologia\neconomy: Economia\n" |
| "culture: Cultura\npolitics: Política nacional\ntravel: Viagens e lazer\nsociety: Sociedade"), |
| "noul": ("", ""), |
| "score": ("", "", ""), |
| }, |
| { |
| "name": "Área do direito (V2)", |
| "state": '{"text": "Acordam no Supremo Tribunal de Justiça: a autora pede a condenação da ré no pagamento das ' |
| 'retribuições em dívida e da indemnização pelo despedimento, que considera ilícito por falta de processo ' |
| 'disciplinar."}', |
| "choice": ("legal_area", "Em que área do direito se insere este acórdão?", |
| "labour: Direito do trabalho\ndisputes: Contencioso\ncivil: Direito civil\ncriminal: Direito penal"), |
| "noul": ("", ""), |
| "score": ("", "", ""), |
| }, |
| { |
| "name": "Relação entre frases (V2)", |
| "state": '{"premise": "O concerto da banda no Coliseu de Lisboa esgotou em menos de uma hora.", ' |
| '"hypothesis": "Os bilhetes para o concerto no Coliseu acabaram muito depressa."}', |
| "choice": ("relation", "Que relação há entre as duas frases?", |
| "entailment: A primeira implica a segunda\nnone: Nenhuma: a segunda não decorre da primeira\n" |
| "paraphrase: As duas dizem o mesmo"), |
| "noul": ("", ""), |
| "score": ("similarity", "Quão parecido é o sentido das duas frases?", |
| "sem relação\npouca relação\nalguma relação\nmuito parecidas\npraticamente iguais"), |
| }, |
| { |
| "name": "Tradução com um facto trocado (V2)", |
| "state": '{"original": "The museum opens at 9 a.m. on weekdays and is closed on Mondays.", ' |
| '"translation": "O museu abre às 10 horas nos dias úteis e está fechado às segundas-feiras."}', |
| "choice": ("", "", ""), |
| "noul": ("faithful", "As duas versões dizem o mesmo?"), |
| "score": ("", "", ""), |
| }, |
| { |
| "name": "Linguagem ofensiva (V2)", |
| "state": "Este árbitro é um palhaço, devia ter vergonha de aparecer em campo. Corja de incompetentes!", |
| "choice": ("", "", ""), |
| "noul": ("offensive", "A mensagem contém insultos ou linguagem ofensiva?"), |
| "score": ("", "", ""), |
| }, |
| { |
| "name": "Trocadilho (V2)", |
| "state": "Qual é o animal que anda com uma pata? O pato.", |
| "choice": ("", "", ""), |
| "noul": ("pun", "A piada joga com um duplo sentido ou com o som das palavras?"), |
| "score": ("", "", ""), |
| }, |
| ] |
|
|
|
|
| def example_row(ex): |
| return [ex["state"], *ex["choice"], *ex["noul"], *ex["score"]] |
|
|
|
|
| RAW_EXAMPLE = json.dumps({ |
| "state": {"request": "A encomenda 4471 chegou com o ecrã partido. Quero trocar o artigo, não quero o dinheiro de volta.", |
| "channel": "email"}, |
| "model": "kev-latest", |
| "questions": { |
| "team": {"type": "choice", "instructions": "Que equipa deve tratar deste pedido?", |
| "criteria": {"billing": "Cobranças e reembolsos", "shipping": "Entregas", "returns": "Trocas"}}, |
| "refund_requested": {"type": "noul", "instructions": "O cliente pede o reembolso do dinheiro?"}, |
| "frustration": {"type": "score", "instructions": "Quão frustrado está o cliente?", |
| "criteria": ["Calmo", "Incomodado", "Muito zangado"]}, |
| }, |
| }, ensure_ascii=False, indent=2) |
|
|
|
|
| |
|
|
| INTRO = f"""# Jevásio |
| |
| Modelo de decisão para português europeu. Recebe um **estado** (um texto ou um objeto JSON) e perguntas tipadas, e |
| devolve uma probabilidade para cada opção de cada pergunta, numa só passagem pelo modelo. Não gera texto. |
| |
| Escolha o modelo: os 4B são mais exatos, os 0.8B são mais pequenos e rápidos. O [Jevásio-4B-V2]({LINK_4B_V2}) e o |
| [Jevásio-0.8B-V2]({LINK_08B_V2}) são o [Jevásio-4B]({LINK_4B}) e o [Jevásio-0.8B]({LINK_08B}) treinados com mais tarefas: |
| variedade do português por domínio, comandos de voz, secções de jornal, áreas do direito, relação entre frases, |
| linguagem ofensiva, trocadilhos e traduções ou resumos com um facto trocado. Os exemplos marcados com (V2) são dessas |
| tarefas. |
| """ |
|
|
| TEMPERATURES = ", ".join(f"T = {m.head.temperature:.2f} no {n}" for n, (_, m) in LOADED.items()) |
|
|
| ABOUT = f"""Há três tipos de pergunta: `choice` (escolher uma opção com nome), `noul` (sim ou não) e `score` (um nível numa |
| escala ordenada). Os nomes das chaves (campos do estado, ids das perguntas, nomes das opções) estão em inglês e os |
| valores em português, como nos dados de treino. |
| |
| O Jevásio é o [Kev](https://github.com/jaredpalmer/kev) afinado com o conjunto |
| [TigreGotico/jevasio-decisions]({LINK_DATA}), e o V2 com [TigreGotico/jevasio-decisions-v2]({LINK_DATA_V2}). A |
| probabilidade usa a temperatura de calibração guardada no modelo ({TEMPERATURES}). |
| Antes de definir um limiar, meça o modelo com os seus próprios dados. |
| |
| Licença CC BY-NC-SA 4.0: só para investigação não comercial. Não use o modelo em decisões com consequências legais, |
| médicas, financeiras ou laborais sem revisão humana. |
| """ |
|
|
| PLACEHOLDER = ('<div style="border:1px dashed var(--border-color-primary);border-radius:10px;padding:28px 16px;' |
| 'text-align:center;color:var(--body-text-color-subdued);font-size:13px">' |
| 'As respostas aparecem aqui: um cartão por pergunta, com uma barra por opção.</div>') |
|
|
| CSS = """ |
| #col-container { max-width: 1180px; margin: 0 auto; } |
| #decide-btn { min-height: 44px; } |
| """ |
|
|
| first = EXAMPLES[0] |
|
|
| with gr.Blocks(title="Jevásio") as demo: |
| with gr.Column(elem_id="col-container"): |
| gr.Markdown(INTRO) |
| model_choice = gr.Radio(list(MODELS), value=DEFAULT, label="Modelo") |
| with gr.Tabs(): |
| with gr.Tab("Perguntas"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| state_box = gr.Textbox(label="Estado (o texto que o modelo lê)", lines=5, max_lines=14, |
| value=first["state"], |
| placeholder="Uma mensagem, uma crítica, um artigo ou um objeto JSON.") |
| with gr.Group(): |
| gr.Markdown("**Pergunta de escolha** (`choice`)") |
| with gr.Row(): |
| choice_id = gr.Textbox(label="Id", value=first["choice"][0], scale=1) |
| choice_instr = gr.Textbox(label="Instrução", value=first["choice"][1], scale=3) |
| choice_opts = gr.Textbox(label="Opções (uma por linha, nome: descrição)", lines=4, |
| value=first["choice"][2]) |
| with gr.Group(): |
| gr.Markdown("**Pergunta de sim/não** (`noul`)") |
| with gr.Row(): |
| noul_id = gr.Textbox(label="Id", value=first["noul"][0], scale=1) |
| noul_instr = gr.Textbox(label="Instrução", value=first["noul"][1], scale=3) |
| with gr.Group(): |
| gr.Markdown("**Pergunta de escala** (`score`)") |
| with gr.Row(): |
| score_id = gr.Textbox(label="Id", value=first["score"][0], scale=1) |
| score_instr = gr.Textbox(label="Instrução", value=first["score"][1], scale=3) |
| score_levels = gr.Textbox(label="Níveis, do mais baixo ao mais alto (um por linha)", lines=3, |
| value=first["score"][2]) |
| gr.Markdown("Deixe o id vazio para omitir uma pergunta.") |
| run_btn = gr.Button("Decidir", variant="primary", elem_id="decide-btn") |
| with gr.Column(scale=1): |
| answers_html = gr.HTML(value=PLACEHOLDER) |
| with gr.Accordion("Pedido enviado (formato System One)", open=False): |
| request_json = gr.JSON() |
| with gr.Accordion("Resposta em bruto", open=False): |
| response_json = gr.JSON() |
| inputs = [state_box, choice_id, choice_instr, choice_opts, noul_id, noul_instr, score_id, score_instr, score_levels] |
| gr.Examples(examples=[example_row(ex) for ex in EXAMPLES], example_labels=[ex["name"] for ex in EXAMPLES], |
| inputs=inputs, label="Exemplos") |
| run_btn.click(fn=decide, inputs=[model_choice, *inputs], outputs=[answers_html, request_json, response_json], api_name="decide") |
|
|
| with gr.Tab("Avançado"): |
| gr.Markdown("Cole um pedido em JSON no formato System One (`POST /v1/systemone`) e veja a resposta em JSON.") |
| with gr.Row(): |
| with gr.Column(scale=1): |
| raw_in = gr.Code(label="Pedido (JSON)", language="json", lines=18, value=RAW_EXAMPLE) |
| raw_btn = gr.Button("Enviar", variant="primary") |
| with gr.Column(scale=1): |
| raw_status = gr.Markdown() |
| raw_out = gr.JSON(label="Resposta (JSON)") |
| raw_btn.click(fn=decide_raw, inputs=[model_choice, raw_in], outputs=[raw_status, raw_out], api_name="systemone") |
|
|
| with gr.Tab("Sobre"): |
| gr.Markdown(ABOUT) |
|
|
| if __name__ == "__main__": |
| demo.queue(default_concurrency_limit=1).launch(css=CSS) |
|
|
