base app

app.py

@@ -5,9 +5,11 @@ from pathlib import Path
 from utils.logger import Logger
 from components.login_page import LoginPage
 from components.dashboard_page import DashboardPage
+from utils.database import initialize_database
 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")
 

components/header.py

@@ -8,7 +8,6 @@ class Header:
     def __init__(self):
         with gr.Row(variant="panel", elem_classes="header-row") as self.container:
             self.welcome = gr.Markdown()
-
             self.logout_btn = gr.Button("Log out", scale=0, min_width=90)
 
     # ---------------- wiring ----------------
@@ -19,6 +18,7 @@ class Header:
             outputs=[
                 login_page.container,
                 dashboard_page.container,
+                self.welcome,
                 login_page.message,
             ],
         )

components/login_page.py

@@ -31,10 +31,11 @@ class LoginPage:
         self.login_btn.click(
             fn=AuthService.login,
             inputs=[self.username, self.password, session_state],
-            outputs=[self.message, self.container, dashboard_page.container],
+            outputs=[
+                self.message,            # پیام خطا یا None
+                self.container,          # فرم لاگین (hide/show)
+                dashboard_page.container,# داشبورد (show/hide)
+                header.welcome,          # متن هدر ← NEW
+            ],
             concurrency_limit=10,
-        ).then(
-            lambda s: f"### User: {s.get('user', '')}",
-            inputs=session_state,
-            outputs=header.welcome,
-        )
+        )

create_new_user.py

@@ -0,0 +1,23 @@
+from utils.database import get_db
+from data.repository.annotator_repo import AnnotatorRepo
+from utils.logger import Logger
+
+log = Logger()
+
+try:
+    with get_db() as session:
+        repo = AnnotatorRepo(session)
+
+        # ---------------------- Add new user ---------------------- #
+        new_user = repo.add_new_user("navid", "123")
+        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}')"
+        )
+
+except Exception as exc:
+    log.error(f"An error occurred in user operations: {exc}")

data/models.py

@@ -1,38 +1,99 @@
-from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime, ForeignKey
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Float,
+    Boolean,
+    DateTime,
+    ForeignKey,
+    Text,
+)
 from sqlalchemy.orm import relationship, declarative_base
 
 Base = declarative_base()
 
-
+# --------------------------------------------------------------------------- #
+#                                   TTSData                                   #
+# --------------------------------------------------------------------------- #
 class TTSData(Base):
     __tablename__ = "tts_data"
 
     id = Column(Integer, primary_key=True)
-    filename = Column(String, nullable=False, unique=True)
-    sentence = Column(String, nullable=False)
+    filename = Column(String(255), nullable=False, unique=True)
+    sentence = Column(Text, nullable=False)
 
 
+# --------------------------------------------------------------------------- #
+#                                  Annotator                                  #
+# --------------------------------------------------------------------------- #
 class Annotator(Base):
     __tablename__ = "annotators"
 
     id = Column(Integer, primary_key=True)
-    name = Column(String, nullable=False, unique=True)
-    password = Column(String, nullable=False)
+    name = Column(String(100), nullable=False, unique=True)
+    password = Column(String(255), nullable=False)
     last_login = Column(DateTime)
     is_active = Column(Boolean, default=True)
-    annotations = relationship("Annotation", backref="annotator")
-    validators = relationship("Validator", backref="annotator")
-    annotation_intervals = relationship("AnnotationInterval", backref="annotator")
+
+    # رابطه با Annotation
+    annotations = relationship(
+        "Annotation",
+        back_populates="annotator",
+        cascade="all, delete-orphan",
+    )
+
+    # رابطه با Validator ـ نقش «کسی که کارش ارزیابی می‌شود»
+    validation_records = relationship(
+        "Validator",
+        back_populates="annotated_annotator",
+        foreign_keys="Validator.annotator_id",
+        cascade="all, delete-orphan",
+    )
+
+    # رابطه با Validator ـ نقش «کسی که اعتبارسنجی می‌کند»
+    validations_done = relationship(
+        "Validator",
+        back_populates="validator_user",
+        foreign_keys="Validator.validator_id",
+        cascade="all, delete-orphan",
+    )
+
+    # بازه‌های واگذاری کار
+    annotation_intervals = relationship(
+        "AnnotationInterval",
+        back_populates="annotator",
+        cascade="all, delete-orphan",
+    )
 
 
+# --------------------------------------------------------------------------- #
+#                                   Validator                                 #
+# --------------------------------------------------------------------------- #
 class Validator(Base):
     __tablename__ = "validators"
 
     id = Column(Integer, primary_key=True)
-    annotator_id = Column(Integer, ForeignKey("annotators.id"))
-    validator_id = Column(Integer, ForeignKey("annotators.id"))
+    # کسی که جمله را حاشیه‌نویسی کرده
+    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],
+        back_populates="validation_records",
+    )
+    validator_user = relationship(
+        "Annotator",
+        foreign_keys=[validator_id],
+        back_populates="validations_done",
+    )
 
 
+# --------------------------------------------------------------------------- #
+#                              AnnotationInterval                             #
+# --------------------------------------------------------------------------- #
 class AnnotationInterval(Base):
     __tablename__ = "annotation_intervals"
 
@@ -41,21 +102,33 @@ class AnnotationInterval(Base):
     start_index = Column(Integer, nullable=True)
     end_index = Column(Integer, nullable=True)
 
+    annotator = relationship("Annotator", back_populates="annotation_intervals")
+
 
+# --------------------------------------------------------------------------- #
+#                                  Annotation                                 #
+# --------------------------------------------------------------------------- #
 class Annotation(Base):
     __tablename__ = "annotations"
 
     id = Column(Integer, primary_key=True)
-    annotated_sentence = Column(String, nullable=False)
+    annotated_sentence = Column(Text, nullable=False)
     validated = Column(Boolean, nullable=False)
     annotated_at = Column(DateTime, nullable=False)
     annotator_id = Column(Integer, ForeignKey("annotators.id"))
-    audio_trims = relationship("AudioTrim", cascade="all, delete", backref="annotation")
+
+    annotator = relationship("Annotator", back_populates="annotations")
+    audio_trims = relationship(
+        "AudioTrim", cascade="all, delete-orphan", back_populates="annotation"
+    )
     validations = relationship(
-        "Validation", cascade="all, delete", backref="annotation"
+        "Validation", cascade="all, delete-orphan", back_populates="annotation"
     )
 
 
+# --------------------------------------------------------------------------- #
+#                                  AudioTrim                                  #
+# --------------------------------------------------------------------------- #
 class AudioTrim(Base):
     __tablename__ = "audio_trims"
 
@@ -64,7 +137,12 @@ class AudioTrim(Base):
     end = Column(Float, nullable=False)
     annotation_id = Column(Integer, ForeignKey("annotations.id"))
 
+    annotation = relationship("Annotation", back_populates="audio_trims")
 
+
+# --------------------------------------------------------------------------- #
+#                                  Validation                                 #
+# --------------------------------------------------------------------------- #
 class Validation(Base):
     __tablename__ = "validations"
 
@@ -72,5 +150,8 @@ class Validation(Base):
     annotation_id = Column(Integer, ForeignKey("annotations.id"))
     validator_id = Column(Integer, ForeignKey("validators.id"))
     validated = Column(Boolean, nullable=False)
-    description = Column(String, nullable=True)
+    description = Column(Text, nullable=True)
     validated_at = Column(DateTime, nullable=False)
+
+    annotation = relationship("Annotation", back_populates="validations")
+    validator = relationship("Validator")

data/repository/annotator_repo.py

@@ -0,0 +1,80 @@
+from typing import Optional
+from sqlalchemy.orm import Session
+
+from data.models import Annotator
+from utils.logger import Logger
+from utils.security import hash_password
+
+log = Logger()
+
+
+class AnnotatorRepo:
+    """
+    Data-Access-Layer for Annotator table.
+    """
+
+    def __init__(self, db: Session) -> None:
+        self.db = db
+
+    # ------------------------------------------------------------------ #
+    # READ METHODS
+    # ------------------------------------------------------------------ #
+    def get_user_by_username(self, username: str) -> Optional[Annotator]:
+        try:
+            return (
+                self.db.query(Annotator)
+                .filter(Annotator.name == username)
+                .first()
+            )
+        except Exception as exc:
+            log.error(f"Unable to fetch user <username={username}> : {exc}")
+            raise
+
+    def get_user_by_id(self, user_id: int) -> Optional[Annotator]:
+        try:
+            return (
+                self.db.query(Annotator)
+                .filter(Annotator.id == user_id)
+                .first()
+            )
+        except Exception as exc:
+            log.error(f"Unable to fetch user <id={user_id}> : {exc}")
+            raise
+
+    # ------------------------------------------------------------------ #
+    # WRITE METHODS
+    # ------------------------------------------------------------------ #
+    def add_new_user(
+        self,
+        username: str,
+        password: str,
+        *,
+        is_active: bool = True,
+    ) -> Annotator:
+        """
+        Create a new Annotator with a hashed password.
+        Raises:
+            ValueError: if username already exists.
+        """
+        try:
+            if self.get_user_by_username(username):
+                raise ValueError(f"Username `{username}` already exists.")
+
+            # ------------------ HASH PASSWORD ------------------ #
+            hashed_pass = hash_password(password)
+
+            user = Annotator(
+                name=username,
+                password=hashed_pass,
+                is_active=is_active,
+            )
+            self.db.add(user)
+            self.db.flush()    # Ensure PK generated
+            self.db.refresh(user)
+
+            log.info(f"New user created <id={user.id} username={username}>")
+            return user
+        except Exception as exc:
+            self.db.rollback()
+            log.error(f"Unable to create user `{username}` : {exc}")
+            raise

requirements.txt

@@ -4,4 +4,6 @@ pydantic
 mysql-connector-python
 soundfile
 librosa
-pydantic-settings
+pydantic-settings
+pymysql
+bcrypt

utils/auth.py

@@ -1,42 +1,65 @@
-# utils/auth.py
-
 import gradio as gr
 from utils.logger import Logger
+from utils.database import get_db
+from data.repository.annotator_repo import AnnotatorRepo
+from utils.security import verify_password
 
 log = Logger()
 
 
 class AuthService:
-    _USERS = {"u1": "123", "u2": "234"}
+    """
+    Authenticate users against DB and drive Gradio UI states.
+    """
 
-    # ─────────────────── core actions ────────────────────
+    # --------------- LOGIN --------------- #
     @staticmethod
     def login(username: str, password: str, session: dict):
         log.info(f"Login attempt: username={username}")
-        if AuthService._USERS.get(username) != password:
-            log.warning(f"Failed login for username={username}")
+
+        with get_db() as db:
+            repo = AnnotatorRepo(db)
+            user = repo.get_user_by_username(username)
+
+            if user is None or not user.is_active:
+                log.warning(
+                    f"Failed login for username='{username}' (not found / inactive)."
+                )
+                return (
+                    "❌ Wrong username or password!",
+                    gr.update(),
+                    gr.update(visible=False),
+                    gr.update(value=""),
+                )
+
+            if not verify_password(password, user.password):
+                log.warning(f"Failed login; bad password for '{username}'.")
+                return (
+                    "❌ Wrong username or password!",
+                    gr.update(),
+                    gr.update(visible=False),
+                    gr.update(value=""),
+                )
+
+            session["user_id"] = user.id
+            session["username"] = user.name
+            log.info(f"User '{username}' logged in successfully.")
             return (
-                "❌ Wrong username or password!",
-                gr.update(),  # keep login form visible
-                gr.update(visible=False),  # hide dashboard
+                None,
+                gr.update(visible=False),
+                gr.update(visible=True),
+                gr.update(value=f"👋 Welcome, {user.name}!"),
             )
 
-        # success
-        session["user"] = username
-        log.info(f"User '{username}' logged in successfully.")
-        return (
-            None,
-            gr.update(visible=False),  # hide login form
-            gr.update(visible=True),  # show dashboard
-        )
-
+    # --------------- LOGOUT --------------- #
     @staticmethod
     def logout(session: dict):
-        username = session.get("user", "unknown")
+        username = session.get("username", "unknown")
         session.clear()
         log.info(f"User '{username}' logged out.")
         return (
-            gr.update(visible=True),  # show login page
-            gr.update(visible=False),  # hide dashboard
-            gr.update(value=""),  # clear old messages
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(value=""),
+            gr.update(value=""),
         )

utils/database.py

@@ -1,3 +1,5 @@
+# utils/database.py
+
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from contextlib import contextmanager

utils/security.py

@@ -0,0 +1,29 @@
+import bcrypt
+from utils.logger import Logger
+
+log = Logger()
+
+
+def hash_password(plain_password: str) -> str:
+    """
+    Hash a plaintext password using bcrypt.
+    """
+    try:
+        hashed = bcrypt.hashpw(plain_password.encode("utf-8"), bcrypt.gensalt())
+        return hashed.decode("utf-8")
+    except Exception as exc:
+        log.error(f"Password hashing failed: {exc}")
+        raise
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """
+    Verify a plaintext password against its bcrypt hash.
+    """
+    try:
+        return bcrypt.checkpw(
+            plain_password.encode("utf-8"), hashed_password.encode("utf-8")
+        )
+    except Exception as exc:
+        log.error(f"Password verification failed: {exc}")
+        return False