logger and main classes for fe and be

app.py

@@ -0,0 +1,72 @@
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from src.models.hf_download import download_all
+from src.pipelines.predict_pipeline import PredictPipeline
+from src.pipelines.predict_all_pipeline import PredictAllPipeline
+from src.pipelines.fasttext_pipeline import FastTextPipeline
+from src.api.health import router as health_router
+from src.api.predict import router as predict_router
+from src.api.predict_all import router as predict_all_router
+
+
+load_dotenv()
+log = logging.getLogger(__name__)
+
+MODELS_ROOT = Path("models")
+VALID_MODES = ("marker", "qa_m", "qa_b")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    downloaded = download_all()
+
+    all_pipeline = PredictAllPipeline()
+
+    for mode in VALID_MODES:
+        local_dir = downloaded.get(mode)
+        if local_dir is None:
+            local_dir = MODELS_ROOT / mode
+
+        onnx_path = local_dir / "model.onnx"
+        if not onnx_path.exists():
+            log.warning(f"{mode} not available — skipping")
+            continue
+
+        log.info(f"Loading PredictPipeline ({mode})")
+        app.state.__dict__[f"pipeline_{mode}"] = PredictPipeline(
+            onnx_path=onnx_path,
+            mode=mode,
+            model_name=mode,
+        )
+
+        all_pipeline.add_model(mode, onnx_path, mode)
+
+    fasttext_path = MODELS_ROOT / "fasttext" / "model.bin"
+    if fasttext_path.exists():
+        log.info("Loading FastTextPipeline")
+        app.state.pipeline_fasttext = FastTextPipeline(fasttext_path, "fasttext")
+        all_pipeline.add_fasttext("fasttext", fasttext_path)
+    else:
+        log.warning("fastText model not available — skipping")
+
+    app.state.all_models_pipeline = all_pipeline
+    available = list(all_pipeline.models.keys()) + list(all_pipeline.fasttext_models.keys())
+    log.info(f"Available models: {available}")
+
+    yield
+
+
+app = FastAPI(
+    title="Entity Sentiment Classification API",
+    description="Classify sentiment (positive, neutral, negative) for entities in text.",
+    version="1.0.0",
+    lifespan=lifespan,
+    root_path="/api",
+)
+
+app.include_router(health_router)
+app.include_router(predict_router)
+app.include_router(predict_all_router)

main.py

@@ -0,0 +1,23 @@
+import streamlit as st
+
+st.set_page_config(
+    page_title="Entity Sentiment Classification",
+    layout="centered",
+    initial_sidebar_state="collapsed",
+)
+
+st.markdown(
+    """
+    <style>
+        [data-testid="collapsedControl"] { display: none; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+home = st.Page("pages/welcome.py", title="Welcome", default=True)
+config = st.Page("pages/config.py", title="Configuration")
+result = st.Page("pages/result.py", title="Results")
+
+pg = st.navigation([home, config, result], position="hidden")
+pg.run()

src/fe_handler.py

@@ -0,0 +1,25 @@
+import os
+
+import requests
+
+API_BASE_URL = os.environ.get("API_BASE_URL", "http://localhost:8000")
+
+
+def call_predict(samples: list[dict]) -> list[dict]:
+    response = requests.post(f"{API_BASE_URL}/predict", json=samples)
+    response.raise_for_status()
+    return response.json()
+
+
+def call_predict_all(samples: list[dict]) -> dict[str, list[dict]]:
+    response = requests.post(f"{API_BASE_URL}/predict-all-models", json=samples)
+    response.raise_for_status()
+    return response.json()
+
+
+def check_health() -> bool:
+    try:
+        response = requests.get(f"{API_BASE_URL}/health", timeout=3)
+        return response.status_code == 200
+    except requests.ConnectionError:
+        return False

src/logger.py

@@ -0,0 +1,46 @@
+import os
+import time
+from datetime import datetime, timezone
+import requests
+
+
+BETTERSTACK_URL = "https://s2383648.eu-fsn-3.betterstackdata.com"
+
+
+def log_to_betterstack(
+    endpoint_name: str,
+    original_text: str,
+    formatted_text: str | dict,
+    model_name: str,
+    time_elapsed: float,
+) -> None:
+    token = os.environ.get("BETTERSTACK_SOURCE_TOKEN")
+    if not token:
+        return
+
+    payload = {
+        "dt": datetime.now(timezone.utc).isoformat(),
+        "message": f"Endpoint called: {endpoint_name}",
+        "endpoint_name": endpoint_name,
+        "model_name": model_name,
+        "request": original_text,
+        "response": formatted_text,
+        "time_elapsed": round(time_elapsed, 4),
+        "request_date": datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
+        "level": "info"
+    }
+
+    try:
+        resp = requests.post(
+            BETTERSTACK_URL,
+            json=payload,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            },
+            timeout=5,
+        )
+        if resp.status_code >= 300:
+            print(f"[betterstack] {resp.status_code}: {resp.text}")
+    except Exception as e:
+        print(f"[betterstack] exception: {e}")