load annotation data done

app.py

@@ -1,4 +1,3 @@
-# app.py
 import gradio as gr
 from pathlib import Path
 
@@ -10,30 +9,40 @@ from config import conf
 
 log = Logger()
 initialize_database()
+
 CSS_FILE = Path(__file__).parent / "assets" / "styles.css"
 custom_css = CSS_FILE.read_text(encoding="utf-8")
 
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(title=conf.APP_TITLE, css=custom_css) as demo:
-        session = gr.State({})
+    """
+    می‌سازد و wiring کل اپلیکیشن را انجام می‌دهد.
+    """
+    demo = gr.Blocks(title=conf.APP_TITLE, css=custom_css)
+
+    with demo:
+        # حالت سراسری برنامه به‌صورت gr.State
+        session_state = gr.State({})
 
         gr.Markdown(f"### {conf.APP_TITLE}")
 
-        login_page = LoginPage()
+        # صفحات
+        login_page     = LoginPage()
         dashboard_page = DashboardPage()
 
-        login_page.register_callbacks(dashboard_page, session)
-        dashboard_page.register_callbacks(login_page, session)
+        # اتصال رویدادها
+        login_page.register_callbacks(dashboard_page, session_state)
+        dashboard_page.register_callbacks(login_page, session_state, demo)
 
-        demo.queue(default_concurrency_limit=50)
-        log.info("App Started.")
+    # صف پردازش گرادیو
+    demo.queue(default_concurrency_limit=50)
+    log.info("App Started.")
     return demo
 
 
 if __name__ == "__main__":
-    try:
-        log.info("Initial App ...")
-        build_app().launch()
-    except Exception as err:
-        log.error(err)
+    # try:
+    log.info("Launching App ...")
+    build_app().launch()
+    # except Exception as err:
+    #     log.error(err)

components/dashboard_page.py

@@ -1,5 +1,4 @@
 # components/dashboard_page.py
-
 import gradio as gr
 from components.header import Header
 
@@ -7,15 +6,145 @@ from components.header import Header
 class DashboardPage:
     """UI elements + event wiring for the post-login dashboard."""
 
-    def __init__(self):
+    # ───────── ساخت UI ───────── #
+    def __init__(self) -> None:
         with gr.Column(visible=False) as self.container:
-            # ───── header (welcome + logout) ─────
+            # هدر بالا (نام کاربر + خروج)
             self.header = Header()
 
-            # ─────────── main body ────────────
+            # اطلاعات فایل صوتی و انوتیشن
+            with gr.Row():
+                with gr.Column():
+                    self.tts_id = gr.Textbox(
+                        label="tts_data.id", interactive=False
+                    )
+                    self.filename = gr.Textbox(
+                        label="tts_data.filename", interactive=False
+                    )
+                    self.sentence = gr.Textbox(
+                        label="tts_data.sentence", interactive=False
+                    )
+                    self.ann_sentence = gr.Textbox(
+                        label="annotations.annotated_sentence",
+                        interactive=False,
+                    )
+                    self.ann_at = gr.Textbox(
+                        label="annotations.annotated_at",
+                        interactive=False,
+                    )
+                    self.validated = gr.Checkbox(
+                        label="annotations.validated",
+                        interactive=False,
+                    )
+
+            # دکمه‌های پیمایش
+            with gr.Row():
+                self.btn_prev = gr.Button("⬅️ Previous")
+                self.btn_next = gr.Button("Next ➡️")
+
+            # stateهای مخفی
+            self.items_state = gr.State([])   # list[dict]
+            self.idx_state   = gr.State(0)    # اندیس فعلی
+
 
-    # ─────────────────── event wiring ────────────────────
-    def register_callbacks(self, login_page, session_state):
 
-        # Header handles its own logout button
+    # ───────── wiring رویدادها ───────── #
+    def register_callbacks(
+        self,
+        login_page,               # برای اجازه‌ی logout در Header
+        session_state: gr.State,  # gr.State شامل دیکشنری نشست
+        root_blocks: gr.Blocks    # بلوک ریشه‌ی برنامه
+    ) -> None:
+
+        # ۱) رویداد خروج (در Header)
         self.header.register_callbacks(login_page, self, session_state)
+
+        # ---------- توابع کمکی ---------- #
+        def show_current(items: list, idx: int):
+            """رکورد idx را روی فیلدها می‌ریزد؛ در صورت خالی بودن لیست مقادیر تهی."""
+            if not items:
+                return ["", "", "", "", "", False]
+
+            data = items[idx]
+            return [
+                data["id"],
+                data["filename"],
+                data["sentence"],
+                data.get("annotated_sentence", ""),
+                data.get("annotated_at", ""),
+                bool(data.get("validated", False)),
+            ]
+
+        def next_idx(items: list, idx: int):
+            return min(idx + 1, max(len(items) - 1, 0))
+
+        def prev_idx(items: list, idx: int):
+            return max(idx - 1, 0)
+
+        # ---------- بارگذاری اولیه (یک بار در شروع) ---------- #
+        def load_items(sess: dict):
+            items = sess.get("dashboard_items", [])
+            return (
+                items,                   # → items_state
+                0,                       # → idx_state
+                *show_current(items, 0), # → شش فیلد
+            )
+
+        root_blocks.load(
+            fn=load_items,
+            inputs=[session_state],
+            outputs=[
+                self.items_state,
+                self.idx_state,
+                self.tts_id,
+                self.filename,
+                self.sentence,
+                self.ann_sentence,
+                self.ann_at,
+                self.validated,
+            ],
+        )
+
+        # ---------- دکمه «قبلی» ----------
+        (
+            self.btn_prev
+            .click(
+                fn=prev_idx,
+                inputs=[self.items_state, self.idx_state],
+                outputs=self.idx_state,
+            )
+            .then(
+                fn=show_current,
+                inputs=[self.items_state, self.idx_state],
+                outputs=[
+                    self.tts_id,
+                    self.filename,
+                    self.sentence,
+                    self.ann_sentence,
+                    self.ann_at,
+                    self.validated,
+                ],
+            )
+        )
+
+        # ---------- دکمه «بعدی» ----------
+        (
+            self.btn_next
+            .click(
+                fn=next_idx,
+                inputs=[self.items_state, self.idx_state],
+                outputs=self.idx_state,
+            )
+            .then(
+                fn=show_current,
+                inputs=[self.items_state, self.idx_state],
+                outputs=[
+                    self.tts_id,
+                    self.filename,
+                    self.sentence,
+                    self.ann_sentence,
+                    self.ann_at,
+                    self.validated,
+                ],
+            )
+        )

components/login_page.py

@@ -42,8 +42,15 @@ class LoginPage:
                     self.container,
                     dashboard_page.container,
                     header.welcome,
+                    dashboard_page.items_state,
+                    dashboard_page.idx_state,
+                    dashboard_page.tts_id,
+                    dashboard_page.filename,
+                    dashboard_page.sentence,
+                    dashboard_page.ann_sentence,
+                    dashboard_page.ann_at,
+                    dashboard_page.validated,
                 ],
-                concurrency_limit=10,
             )
             .then(
                 fn=lambda: gr.update(value="Login", interactive=True),

data/models.py

@@ -22,6 +22,11 @@ class TTSData(Base):
     filename = Column(String(255), nullable=False, unique=True)
     sentence = Column(Text, nullable=False)
 
+    annotations = relationship(
+        "Annotation",
+        back_populates="tts_data",
+        cascade="all, delete-orphan",
+    )
 
 # --------------------------------------------------------------------------- #
 #                                  Annotator                                  #
@@ -35,14 +40,12 @@ class Annotator(Base):
     last_login = Column(DateTime)
     is_active = Column(Boolean, default=True)
 
-    # رابطه با Annotation
     annotations = relationship(
         "Annotation",
         back_populates="annotator",
         cascade="all, delete-orphan",
     )
 
-    # رابطه با Validator ـ نقش «کسی که کارش ارزیابی می‌شود»
     validation_records = relationship(
         "Validator",
         back_populates="annotated_annotator",
@@ -50,7 +53,6 @@ class Annotator(Base):
         cascade="all, delete-orphan",
     )
 
-    # رابطه با Validator ـ نقش «کسی که اعتبارسنجی می‌کند»
     validations_done = relationship(
         "Validator",
         back_populates="validator_user",
@@ -58,7 +60,6 @@ class Annotator(Base):
         cascade="all, delete-orphan",
     )
 
-    # بازه‌های واگذاری کار
     annotation_intervals = relationship(
         "AnnotationInterval",
         back_populates="annotator",
@@ -73,12 +74,9 @@ class Validator(Base):
     __tablename__ = "validators"
 
     id = Column(Integer, primary_key=True)
-    # کسی که جمله را حاشیه‌نویسی کرده
     annotator_id = Column(Integer, ForeignKey("annotators.id"), nullable=False)
-    # کسی که آن را اعتبارسنجی کرده
     validator_id = Column(Integer, ForeignKey("annotators.id"), nullable=False)
 
-    # رابطه‌ها
     annotated_annotator = relationship(
         "Annotator",
         foreign_keys=[annotator_id],
@@ -116,8 +114,12 @@ class Annotation(Base):
     validated = Column(Boolean, nullable=False)
     annotated_at = Column(DateTime, nullable=False)
     annotator_id = Column(Integer, ForeignKey("annotators.id"))
+    tts_data_id = Column(Integer, ForeignKey("tts_data.id"))
+    
 
     annotator = relationship("Annotator", back_populates="annotations")
+    tts_data = relationship("TTSData", back_populates="annotations") 
+
     audio_trims = relationship(
         "AudioTrim", cascade="all, delete-orphan", back_populates="annotation"
     )

data/repository/annotation_interval_repo.py

@@ -0,0 +1,88 @@
+from typing import List, Optional
+from sqlalchemy.orm import Session
+
+from data.models import AnnotationInterval
+from utils.logger import Logger
+
+log = Logger()
+
+
+class AnnotationIntervalRepo:
+    """
+    Data-access layer for `annotation_intervals` table.
+    """
+
+    def __init__(self, db: Session) -> None:
+        self.db = db
+
+    # ------------------------------------------------------------------ #
+    # CREATE
+    # ------------------------------------------------------------------ #
+    def assign_interval_to_annotator(
+        self,
+        annotator_id: int,
+        start_idx: int,
+        end_idx: int,
+        allow_overlap: bool = False,
+    ) -> AnnotationInterval:
+        """
+        Create a new interval [start_idx, end_idx] for the given annotator.
+
+        Raises:
+            ValueError:  • start >= end
+                         • overlap detected (when allow_overlap=False)
+        """
+        if start_idx >= end_idx:
+            raise ValueError("start_idx must be < end_idx")
+
+        if not allow_overlap:
+            overlap = (
+                self.db.query(AnnotationInterval)
+                .filter(AnnotationInterval.annotator_id == annotator_id)
+                .filter(
+                    AnnotationInterval.start_index <= end_idx,
+                    AnnotationInterval.end_index >= start_idx,
+                )
+                .first()
+            )
+            if overlap:
+                raise ValueError(
+                    f"Overlap with existing interval "
+                    f"[{overlap.start_index}, {overlap.end_index}]"
+                )
+
+        interval = AnnotationInterval(
+            annotator_id=annotator_id,
+            start_index=start_idx,
+            end_index=end_idx,
+        )
+        self.db.add(interval)
+        self.db.flush()
+        self.db.refresh(interval)
+        log.info(
+            f"Interval [{start_idx}, {end_idx}] assigned to annotator_id={annotator_id}"
+        )
+        return interval
+
+    # ------------------------------------------------------------------ #
+    # READ
+    # ------------------------------------------------------------------ #
+    def get_intervals_by_annotator(self, annotator_id: int) -> List[AnnotationInterval]:
+        return (
+            self.db.query(AnnotationInterval)
+            .filter(AnnotationInterval.annotator_id == annotator_id)
+            .all()
+        )
+
+    def get_interval(
+        self, annotator_id: int, start_idx: int, end_idx: int
+    ) -> Optional[AnnotationInterval]:
+        return (
+            self.db.query(AnnotationInterval)
+            .filter(
+                AnnotationInterval.annotator_id == annotator_id,
+                AnnotationInterval.start_index == start_idx,
+                AnnotationInterval.end_index == end_idx,
+            )
+            .first()
+        )

data/repository/annotator_repo.py

@@ -19,18 +19,18 @@ class AnnotatorRepo:
     # ------------------------------------------------------------------ #
     # READ METHODS
     # ------------------------------------------------------------------ #
-    def get_user_by_username(self, username: str) -> Optional[Annotator]:
+    def get_annotator_by_name(self, name: str) -> Optional[Annotator]:
         try:
             return (
                 self.db.query(Annotator)
-                .filter(Annotator.name == username)
+                .filter(Annotator.name == name)
                 .first()
             )
         except Exception as exc:
-            log.error(f"Unable to fetch user <username={username}> : {exc}")
+            log.error(f"Unable to fetch annotator <name={name}> : {exc}")
             raise
 
-    def get_user_by_id(self, user_id: int) -> Optional[Annotator]:
+    def get_annotator_by_id(self, user_id: int) -> Optional[Annotator]:
         try:
             return (
                 self.db.query(Annotator)
@@ -38,15 +38,15 @@ class AnnotatorRepo:
                 .first()
             )
         except Exception as exc:
-            log.error(f"Unable to fetch user <id={user_id}> : {exc}")
+            log.error(f"Unable to fetch annotator <id={user_id}> : {exc}")
             raise
 
     # ------------------------------------------------------------------ #
     # WRITE METHODS
     # ------------------------------------------------------------------ #
-    def add_new_user(
+    def add_new_annotator(
         self,
-        username: str,
+        name: str,
         password: str,
         *,
         is_active: bool = True,
@@ -54,27 +54,27 @@ class AnnotatorRepo:
         """
         Create a new Annotator with a hashed password.
         Raises:
-            ValueError: if username already exists.
+            ValueError: if name already exists.
         """
         try:
-            if self.get_user_by_username(username):
-                raise ValueError(f"Username `{username}` already exists.")
+            if self.get_annotator_by_name(name):
+                raise ValueError(f"name `{name}` already exists.")
 
             # ------------------ HASH PASSWORD ------------------ #
             hashed_pass = hash_password(password)
 
-            user = Annotator(
-                name=username,
+            annotator = Annotator(
+                name=name,
                 password=hashed_pass,
                 is_active=is_active,
             )
-            self.db.add(user)
+            self.db.add(annotator)
             self.db.flush()    # Ensure PK generated
-            self.db.refresh(user)
+            self.db.refresh(annotator)
 
-            log.info(f"New user created <id={user.id} username={username}>")
-            return user
+            log.info(f"New annotator created <id={annotator.id} name={name}>")
+            return annotator
         except Exception as exc:
             self.db.rollback()
-            log.error(f"Unable to create user `{username}` : {exc}")
+            log.error(f"Unable to create annotator `{name}` : {exc}")
             raise

data/repository/annotator_workload_repo.py

@@ -0,0 +1,58 @@
+from typing import List, Dict, Optional, Any
+
+from sqlalchemy import and_
+from sqlalchemy.orm import Session
+
+from data.models import TTSData, Annotation, AnnotationInterval
+from data.repository.annotator_repo import AnnotatorRepo
+from utils.logger import Logger
+
+log = Logger()
+
+
+class AnnotatorWorkloadRepo:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+        self.annotator_repo = AnnotatorRepo(db)
+
+    def get_tts_data_with_annotations(
+        self, annotator_name: str
+    ) -> List[Dict[str, Optional[Any]]]:
+        """
+        output:  [
+                  {"tts_data": <TTSData>, "annotation": <Annotation or None>},
+                  ...
+                ]
+        """
+
+        annotator = self.annotator_repo.get_annotator_by_name(annotator_name)
+        if annotator is None:
+            raise ValueError(f"Annotator '{annotator_name}' not found")
+
+        query = (
+            self.db.query(
+                TTSData,
+                Annotation,
+            )
+            .join(
+                AnnotationInterval,
+                and_(
+                    AnnotationInterval.annotator_id == annotator.id,
+                    TTSData.id >= AnnotationInterval.start_index,
+                    TTSData.id <= AnnotationInterval.end_index,
+                ),
+            )
+            .outerjoin(
+                Annotation,
+                and_(
+                    Annotation.tts_data_id == TTSData.id,
+                    Annotation.annotator_id == annotator.id,
+                ),
+            )
+            .order_by(TTSData.id)
+        ).distinct(TTSData.id)
+
+        rows = [{"tts_data": tts, "annotation": ann} for tts, ann in query.all()]
+
+        log.info(f"{len(rows)} TTS rows fetched for annotator '{annotator_name}'.")
+        return rows

data/repository/tts_data_repo.py

@@ -0,0 +1,19 @@
+from typing import List
+from sqlalchemy.orm import Session
+
+from data.models import TTSData
+from utils.logger import Logger
+
+log = Logger()
+
+
+class TTSDataRepo:
+    def __init__(self, db: Session) -> None:
+        self.db = db
+
+    def get_range(self, start_id: int, end_id: int) -> List[TTSData]:
+        return (
+            self.db.query(TTSData)
+            .filter(TTSData.id >= start_id, TTSData.id <= end_id)
+            .all()
+        )

scripts/assign_interval_to_annotator.py

@@ -0,0 +1,33 @@
+# scripts/assign_interval_to_annotator.py
+
+from utils.database import get_db
+from data.repository.annotator_repo import AnnotatorRepo
+from data.repository.annotation_interval_repo import AnnotationIntervalRepo
+from utils.logger import Logger
+
+log = Logger()
+
+START_IDX = 1
+END_IDX = 100
+ANNOTATOR_NAME = "navid"
+
+with get_db() as db:
+    annot_repo = AnnotatorRepo(db)
+    interval_repo = AnnotationIntervalRepo(db)
+
+    annotator = annot_repo.get_annotator_by_name(ANNOTATOR_NAME)
+    if not annotator:
+        log.info(f"Annotator '{annotator}' not found;")
+
+    try:
+        interval = interval_repo.assign_interval_to_annotator(
+            annotator_id=annotator.id,
+            start_idx=START_IDX,
+            end_idx=END_IDX,
+        )
+        log.info(
+            f"Interval [{interval.start_index}, {interval.end_index}] "
+            f"successfully assigned to '{annotator.name}' (id={annotator.id})"
+        )
+    except ValueError as err:
+        log.error(f"Could not assign interval: {err}")

create_new_user.py → scripts/create_new_annotator.py

@@ -8,15 +8,9 @@ try:
     with get_db() as session:
         repo = AnnotatorRepo(session)
 
-        # ---------------------- Add new user ---------------------- #
-        new_user = repo.add_new_user("navid", "123")
+        new_user = repo.add_new_annotator("user", "pass")
         log.info(
-            f"User created successfully (id={new_user.id}, username='{new_user.name}')"
-        )
-
-        new_user = repo.add_new_user("vargha", "111")
-        log.info(
-            f"User created successfully (id={new_user.id}, username='{new_user.name}')"
+            f"User created successfully (id={new_user.id}, name='{new_user.name}')"
         )
 
 except Exception as exc:

utils/auth.py

@@ -2,6 +2,7 @@ import gradio as gr
 from utils.logger import Logger
 from utils.database import get_db
 from data.repository.annotator_repo import AnnotatorRepo
+from data.repository.annotator_workload_repo import AnnotatorWorkloadRepo
 from utils.security import verify_password
 
 log = Logger()
@@ -12,54 +13,140 @@ class AuthService:
     Authenticate users against DB and drive Gradio UI states.
     """
 
-    # --------------- LOGIN --------------- #
+    # ───────────── LOGIN ───────────── #
     @staticmethod
     def login(username: str, password: str, session: dict):
+        """
+        خروجی‌ها (به همین ترتیب در LoginPage ثبت شده است):
+        0) message              (Markdown داخل فرم لاگین)
+        1) login_container      (پنهان/نمایان شدن فرم لاگین)
+        2) dashboard_container  (نمایش داشبورد)
+        3) header_welcome       (پیام خوش‌آمد در هدر)
+        4) items_state          (لیست رکوردها)
+        5) idx_state            (اندیس فعلی)
+        6-11) شش فیلد نمایشی    (id, filename, sentence, ann_sentence, ann_at, validated)
+        """
+
+        # ---------- اعتبارسنجی ---------- #
         log.info(f"Login attempt: username={username}")
 
         with get_db() as db:
             repo = AnnotatorRepo(db)
-            user = repo.get_user_by_username(username)
+            annotator = repo.get_annotator_by_name(username)
 
-            if user is None or not user.is_active:
-                log.warning(
-                    f"Failed login for username='{username}' (not found / inactive)."
+            # ⬇️ توابع کمکی برای تولید خروجی خالی (درصورت خطا)
+            def empty_dashboard_outputs():
+                return (
+                    [],  # items_state
+                    0,  # idx_state
+                    "",
+                    "",
+                    "",
+                    "",
+                    "",
+                    False,  # شش فیلد
                 )
+
+            # --- کاربر موجود نیست / غیر فعال
+            if annotator is None or not annotator.is_active:
+                log.warning("Failed login (not found / inactive)")
                 return (
                     "❌ Wrong username or password!",
                     gr.update(),
                     gr.update(visible=False),
                     gr.update(value=""),
+                    *empty_dashboard_outputs(),
                 )
 
-            if not verify_password(password, user.password):
-                log.warning(f"Failed login; bad password for '{username}'.")
+            # --- رمز عبور اشتباه
+            if not verify_password(password, annotator.password):
+                log.warning("Failed login (bad password)")
                 return (
                     "❌ Wrong username or password!",
                     gr.update(),
                     gr.update(visible=False),
                     gr.update(value=""),
+                    *empty_dashboard_outputs(),
+                )
+
+            # ---------- ورود موفق ---------- #
+            session["user_id"] = annotator.id
+            session["username"] = annotator.name
+
+            # بارگذاری داده‌های داشبورد
+            workload_repo = AnnotatorWorkloadRepo(db)
+            raw_items = workload_repo.get_tts_data_with_annotations(username)
+
+            dashboard_items = [
+                {
+                    "id": row["tts_data"].id,
+                    "filename": row["tts_data"].filename,
+                    "sentence": row["tts_data"].sentence,
+                    "annotated_sentence": (
+                        row["annotation"].annotated_sentence
+                        if row["annotation"]
+                        else ""
+                    ),
+                    "annotated_at": (
+                        row["annotation"].annotated_at.isoformat()
+                        if row["annotation"] and row["annotation"].annotated_at
+                        else ""
+                    ),
+                    "validated": (
+                        row["annotation"].validated
+                        if row["annotation"] is not None
+                        else False
+                    ),
+                }
+                for row in raw_items
+            ]
+
+            session["dashboard_items"] = dashboard_items
+
+            # مقداردهی فیلدهای رکورد اول (یا مقادیر تهی)
+            if dashboard_items:
+                first = dashboard_items[0]
+                first_vals = (
+                    first["id"],
+                    first["filename"],
+                    first["sentence"],
+                    first["annotated_sentence"],
+                    first["annotated_at"],
+                    first["validated"],
                 )
+            else:
+                first_vals = ("", "", "", "", "", False)
 
-            session["user_id"] = user.id
-            session["username"] = user.name
             log.info(f"User '{username}' logged in successfully.")
+
+            # ---------- خروجی نهایی برای Gradio ---------- #
             return (
-                None,
-                gr.update(visible=False),
-                gr.update(visible=True),
-                gr.update(value=f"👋 Welcome, {user.name}!"),
+                None,  # 0: پیام خطا وجود ندارد
+                gr.update(visible=False),  # 1: فرم لاگین را مخفی کن
+                gr.update(visible=True),  # 2: داشبورد را نشان بده
+                gr.update(value=f"👋 Welcome, {annotator.name}!"),  # 3
+                dashboard_items,  # 4: items_state
+                0,  # 5: idx_state
+                *first_vals,  # 6-11: شش فیلد نخست
             )
 
-    # --------------- LOGOUT --------------- #
+    # ───────────── LOGOUT ───────────── #
     @staticmethod
     def logout(session: dict):
         username = session.get("username", "unknown")
         session.clear()
         log.info(f"User '{username}' logged out.")
         return (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(value=""),
-            gr.update(value=""),
+            gr.update(visible=True),  # لاگین فرم را دوباره نشان بده
+            gr.update(visible=False),  # داشبورد را پنهان کن
+            gr.update(value=""),  # پیام‌ها را پاک کن
+            gr.update(value=""),  # متن خوش‌آمد را پاک کن
+            [],
+            0,
+            "",
+            "",
+            "",
+            "",
+            "",
+            False,  # خروجی‌های داشبورد را ریست
         )