Update inference_test.py

inference_test.py

@@ -3,11 +3,11 @@ from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import intent_test_runner
-from app_config import AppConfig
+from service_config import ServiceConfig
 import intent, log, intent, llm_model
 
-app_config = AppConfig()
-app_config.setup_environment()
+s_config = ServiceConfig()
+s_config.setup_environment()
 
 # === FastAPI
 app = FastAPI()
@@ -95,15 +95,15 @@ def train_intents(train_input: intent.TrainInput):
     log("📥 POST /train_intents çağrıldı.")
     intents = train_input.intents
     intent.INTENT_DEFINITIONS = {intent["name"]: intent for intent in intents}
-    threading.Thread(target=lambda: intent.background_training(intents, app_config), daemon=True).start()
+    threading.Thread(target=lambda: intent.background_training(intents, s_config), daemon=True).start()
     return {"status": "accepted", "message": "Intent eğitimi arka planda başlatıldı."}
 
 @app.post("/load_intent_model")
 def load_intent_model():
     try:
-        intent.INTENT_TOKENIZER = AutoTokenizer.from_pretrained(app_config.INTENT_MODEL_PATH)
-        intent.INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(app_config.INTENT_MODEL_PATH)
-        with open(os.path.join(app_config.INTENT_MODEL_PATH, "label2id.json")) as f:
+        intent.INTENT_TOKENIZER = AutoTokenizer.from_pretrained(s_config.INTENT_MODEL_PATH)
+        intent.INTENT_MODEL = AutoModelForSequenceClassification.from_pretrained(s_config.INTENT_MODEL_PATH)
+        with open(os.path.join(s_config.INTENT_MODEL_PATH, "label2id.json")) as f:
             intent.LABEL2ID = json.load(f)
         return {"status": "ok", "message": "Intent modeli yüklendi."}
     except Exception as e:
@@ -129,12 +129,12 @@ async def chat(msg: llm_model.Message, request: Request):
         if llm_model.model is None or llm_model.tokenizer is None:
             return {"error": "Model yüklenmedi."}
 
-        if app_config.INTENT_MODEL:
+        if s_config.INTENT_MODEL:
             intent_task = asyncio.create_task(intent.detect_intent(user_input))
-            response_task = asyncio.create_task(llm_model.generate_response(user_input, app_config))
+            response_task = asyncio.create_task(llm_model.generate_response(user_input, s_config))
             intent, intent_conf = await intent_task
             log(f"🎯 Intent: {intent} (conf={intent_conf:.2f})")
-            if intent_conf > app_config.INTENT_CONFIDENCE_THRESHOLD and intent in app_config.INTENT_DEFINITIONS:
+            if intent_conf > s_config.INTENT_CONFIDENCE_THRESHOLD and intent in s_config.INTENT_DEFINITIONS:
                 result = intent.execute_intent(intent, user_input, session)
                 if "reply" in result:
                     session_store[session_id] = result["session"]
@@ -145,22 +145,22 @@ async def chat(msg: llm_model.Message, request: Request):
                     app.state.session_store = session_store
                     return {"response": list(result["errors"].values())[0]}
                 else:
-                    return {"response": random.choice(app_config.FALLBACK_ANSWERS)}
+                    return {"response": random.choice(s_config.FALLBACK_ANSWERS)}
             else:
                 response, response_conf = await response_task
-                if response_conf is not None and response_conf < app_config.LLM_CONFIDENCE_THRESHOLD:
-                    return {"response": random.choice(app_config.FALLBACK_ANSWERS)}
+                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}
         else:
-            response, response_conf = await llm_model.generate_response(user_input, app_config)
-            if response_conf is not None and response_conf < app_config.LLM_CONFIDENCE_THRESHOLD:
-                return {"response": random.choice(app_config.FALLBACK_ANSWERS)}
+            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)
 
-threading.Thread(target=llm_model.setup_model, kwargs={"app_config": app_config}, daemon=True).start()
+threading.Thread(target=llm_model.setup_model, kwargs={"service_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)