Spaces:

UcsTurkey
/

flare

Running

App Files Files Community

ciyidogan commited on May 23

Commit

e62a524

verified ·

1 Parent(s): f91eed4

Update inference_test.py

Browse files

Files changed (1) hide show

inference_test.py +15 -111

inference_test.py CHANGED Viewed

@@ -4,19 +4,23 @@ from fastapi.responses import HTMLResponse, JSONResponse
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import intent_test_runner
 from service_config import ServiceConfig
-import intent, llm_model
 from log import log
 s_config = ServiceConfig()
 s_config.setup_environment()
 # === FastAPI
 app = FastAPI()
 @app.get("/")
 def health():
     return {"status": "ok"}
 @app.post("/run_tests", status_code=202)
 def run_tests():
     log("🚦 /run_tests çağrıldı. Testler başlatılıyor...")
@@ -25,6 +29,7 @@ def run_tests():
 @app.get("/start", response_class=HTMLResponse)
 def root():
     session_id = str(uuid.uuid4())
     session_info = {
         "session_id": session_id,
@@ -33,10 +38,15 @@ def root():
         "last_intent": None,
         "awaiting_variable": None
     }
     if not hasattr(app.state, "session_store"):
         app.state.session_store = {}
     app.state.session_store[session_id] = session_info
     log(f"🌐 /start ile yeni session başlatıldı: {session_id}")
     return f"""
     <html><body>
         <h2>Turkcell LLM Chat</h2>
@@ -68,8 +78,10 @@ def root():
 def start_chat():
     if llm_model.model is None or llm_model.tokenizer is None:
         return {"error": "Model yüklenmedi."}
     if not hasattr(app.state, "session_store"):
         app.state.session_store = {}
     session_id = str(uuid.uuid4())
     session_info = {
         "session_id": session_id,
@@ -103,117 +115,9 @@ def load_intent_model():
 @app.post("/chat")
 async def chat(msg: llm_model.Message, request: Request):
-    user_input = msg.user_input.strip()
-    session_id = request.headers.get("X-Session-ID", "demo-session")
-    if not hasattr(app.state, "session_store"):
-        app.state.session_store = {}
-    session_store = getattr(app.state, "session_store", {})
-    session = session_store.get(session_id, {
-        "session_id": session_id,
-        "variables": {},
-        "auth_tokens": {},
-        "last_intent": None,
-        "awaiting_variable": None
-    })
-    try:
-        if llm_model.model is None or llm_model.tokenizer is None:
-            return {"error": "Model yüklenmedi."}
-        detected_intent, intent_conf = None, 0.0
-        if s_config.INTENT_MODEL:
-            detected_intent, intent_conf = await intent.detect_intent(user_input)
-            log(f"🎯 Intent tespit edildi: {detected_intent} (conf={intent_conf:.2f})")
-        current_intent = session.get("last_intent")
-        awaiting_variable = session.get("awaiting_variable")
-        if (
-            awaiting_variable and
-            detected_intent and
-            detected_intent != current_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD
-        ):
-            log(f"🧹 Yeni intent: {detected_intent}, önceki: {current_intent} — awaiting sıfırlanıyor.")
-            session["awaiting_variable"] = None
-            session["variables"] = {}
-            session["last_intent"] = detected_intent
-            current_intent = detected_intent
-        if (
-            detected_intent and
-            intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD and
-            detected_intent in s_config.INTENT_DEFINITIONS
-        ):
-            definition = s_config.INTENT_DEFINITIONS[detected_intent]
-            pattern_list = definition.get("variables", [])
-            data_formats = s_config.DATA_FORMATS
-            variable_format_map = definition.get("variable_formats", {})
-            if awaiting_variable:
-                extracted = intent.extract_parameters(pattern_list, user_input)
-                for p in extracted:
-                    if p["key"] == awaiting_variable:
-                        session["variables"][awaiting_variable] = p["value"]
-                        session["awaiting_variable"] = None
-                        log(f"✅ Awaiting parametre tamamlandı: {awaiting_variable} = {p['value']}")
-                        break
-            extracted = intent.extract_parameters(pattern_list, user_input)
-            variables = {p["key"]: p["value"] for p in extracted}
-            session.setdefault("variables", {}).update(variables)
-            is_valid, validation_errors = intent.validate_variable_formats(session["variables"], variable_format_map, data_formats)
-            if not is_valid:
-                session["awaiting_variable"] = list(validation_errors.keys())[0]
-                session_store[session_id] = session
-                app.state.session_store = session_store
-                return {"response": list(validation_errors.values())[0]}
-            expected_vars = list(variable_format_map.keys())
-            missing_vars = [v for v in expected_vars if v not in session["variables"]]
-            if missing_vars:
-                session["awaiting_variable"] = missing_vars[0]
-                session_store[session_id] = session
-                app.state.session_store = session_store
-                return {"response": f"Lütfen {missing_vars[0]} bilgisini belirtir misiniz?"}
-            result = intent.execute_intent(
-                detected_intent,
-                user_input,
-                session,
-                s_config.INTENT_DEFINITIONS,
-                s_config.DATA_FORMATS
-            )
-            if "reply" in result:
-                session_store[session_id] = result["session"]
-                app.state.session_store = session_store
-                return {"reply": result["reply"]}
-            elif "errors" in result:
-                session_store[session_id] = result["session"]
-                app.state.session_store = session_store
-                return {"response": list(result["errors"].values())[0]}
-            else:
-                return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
-        session["awaiting_variable"] = None
-        session["variables"] = {}
-        response, response_conf = await llm_model.generate_response(user_input, s_config)
-        if response_conf is not None and response_conf < s_config.LLM_CONFIDENCE_THRESHOLD:
-            return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
-        return {"response": response}
-    except Exception as e:
-        traceback.print_exc()
-        return JSONResponse(content={"error": str(e)}, status_code=500)
-# 🧠 Model setup ve sunucu
 threading.Thread(target=llm_model.setup_model, kwargs={"s_config": s_config}, daemon=True).start()
 threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=7860), daemon=True).start()
-# 🧘 Eğitim sonrası uygulama restart olmasın diye bekleme
-log("⏸️ Eğitim tamamlandı. Servis bekleme modunda...")
 while True:
-    time.sleep(60)

 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import intent_test_runner
 from service_config import ServiceConfig
+import intent, intent, llm_model
 from log import log
+from chat_handler import handle_chat
 s_config = ServiceConfig()
 s_config.setup_environment()
 # === FastAPI
 app = FastAPI()
+chat_history = []
 @app.get("/")
 def health():
     return {"status": "ok"}
+import uuid  # yukarıda zaten eklendiğini varsayıyoruz
 @app.post("/run_tests", status_code=202)
 def run_tests():
     log("🚦 /run_tests çağrıldı. Testler başlatılıyor...")
 @app.get("/start", response_class=HTMLResponse)
 def root():
+    # Yeni session ID üret
     session_id = str(uuid.uuid4())
     session_info = {
         "session_id": session_id,
         "last_intent": None,
         "awaiting_variable": None
     }
+    # Session store başlatıldıysa ekle
     if not hasattr(app.state, "session_store"):
         app.state.session_store = {}
     app.state.session_store[session_id] = session_info
     log(f"🌐 /start ile yeni session başlatıldı: {session_id}")
+    # HTML + session_id gömülü
     return f"""
     <html><body>
         <h2>Turkcell LLM Chat</h2>
 def start_chat():
     if llm_model.model is None or llm_model.tokenizer is None:
         return {"error": "Model yüklenmedi."}
     if not hasattr(app.state, "session_store"):
         app.state.session_store = {}
     session_id = str(uuid.uuid4())
     session_info = {
         "session_id": session_id,
 @app.post("/chat")
 async def chat(msg: llm_model.Message, request: Request):
+    return await handle_chat(msg, request, app, s_config)
 threading.Thread(target=llm_model.setup_model, kwargs={"s_config": s_config}, daemon=True).start()
 threading.Thread(target=lambda: uvicorn.run(app, host="0.0.0.0", port=7860), daemon=True).start()
 while True:
+    time.sleep(60)