base app

.gitignore

@@ -1,2 +1,8 @@
 venv/
-.env
+.env
+__pycache__/
+*.py[cod]
+*$py.class
+.session
+.sessions.json
+sessions.pkl

app.py

@@ -1,11 +1,32 @@
+# app.py
+
 import gradio as gr
+from pathlib import Path
+
+from components.login_page import LoginPage
+from components.dashboard_page import DashboardPage
+from config import conf
+
+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({})
+
+        gr.Markdown(f"### {conf.APP_TITLE}")
+
+        login_page = LoginPage()
+        dashboard_page = DashboardPage()
+
+        login_page.register_callbacks(dashboard_page, session)
+        dashboard_page.register_callbacks(login_page, session)
 
-from seed_db import seed
+        demo.queue(default_concurrency_limit=50)
 
+    return demo
 
-with gr.Blocks() as demo:
-    btn = gr.Button("Run!")
-    output = gr.Textbox(label="Output")
-    btn.click(fn=seed, outputs=output)
 
-demo.launch()
+if __name__ == "__main__":
+    build_app().launch()

assets/styles.css

@@ -0,0 +1,4 @@
+.header-row {
+  align-items: center;
+  padding: 12px 12px;
+}

components/dashboard_page.py

@@ -0,0 +1,30 @@
+# components/dashboard_page.py
+import gradio as gr
+from utils.auth import AuthService
+from components.header import Header
+
+
+class DashboardPage:
+    """UI elements + event wiring for the post-login dashboard."""
+
+    def __init__(self):
+        with gr.Column(visible=False) as self.container:
+            # ───── header (welcome + logout) ─────
+            self.header = Header()
+
+            # ─────────── main body ────────────
+            self.echo_box = gr.Textbox(label="Echo – whatever you type will be returned")
+            self.echo_btn = gr.Button("Echo")
+            self.echo_output = gr.Markdown()
+
+    # ─────────────────── event wiring ────────────────────
+    def register_callbacks(self, login_page, session_state):
+        # Echo button: prepend current username
+        self.echo_btn.click(
+            fn=AuthService.echo,
+            inputs=[self.echo_box, session_state],
+            outputs=self.echo_output,
+        )
+
+        # Header handles its own logout button
+        self.header.register_callbacks(login_page, self, session_state)

components/header.py

@@ -0,0 +1,23 @@
+# components/header.py
+import gradio as gr
+from utils.auth import AuthService
+
+
+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 ----------------
+    def register_callbacks(self, login_page, dashboard_page, session_state):
+        self.logout_btn.click(
+            fn=AuthService.logout,
+            inputs=session_state,
+            outputs=[
+                login_page.container,
+                dashboard_page.container,
+                login_page.message,
+            ],
+        )

components/login_page.py

@@ -0,0 +1,37 @@
+# components/login_page.py
+import gradio as gr
+from utils.auth import AuthService
+
+
+class LoginPage:
+    """UI elements + event wiring for the login screen (centered & narrow)."""
+
+    def __init__(self):
+        with gr.Row(visible=True) as self.container:
+            gr.Column(scale=1)          # left spacer
+
+            with gr.Column(scale=0) as self.form_col:
+                # components with min_width control overall width
+                self.username = gr.Text(label="Username", min_width=300)
+                self.password = gr.Text(label="Password", type="password", min_width=300)
+                self.login_btn = gr.Button("Log in", min_width=300)
+
+                # ↓ removed min_width (Markdown doesn't accept it)
+                self.message = gr.Markdown()
+
+            gr.Column(scale=1)          # right spacer
+
+    # event wiring unchanged …
+    def register_callbacks(self, dashboard_page, session_state):
+        header = dashboard_page.header
+
+        self.login_btn.click(
+            fn=AuthService.login,
+            inputs=[self.username, self.password, session_state],
+            outputs=[self.message, self.container, dashboard_page.container],
+            concurrency_limit=10,
+        ).then(
+            lambda s: f"### User: {s.get('user', '')}",
+            inputs=session_state,
+            outputs=header.welcome,
+        )

config.py

@@ -1,13 +1,27 @@
+# config.py
+
 import os
+from pydantic_settings import BaseSettings
+
+
+class Config(BaseSettings):
+    DB_USER: str = os.getenv("DB_USER")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD")
+    DB_HOST: str = os.getenv("DB_HOST", "localhost")
+    DB_PORT: str = os.getenv("DB_PORT", "3306")
+    DB_NAME: str = os.getenv("DB_NAME", "defaultdb")
+    HF_TOKEN: str = os.environ.get("HF_TOKEN")
+    HF_TTS_DS_REPO: str = os.environ.get("HF_TTS_DS_REPO")
+
+    APP_TITLE: str = "Gooya TTS Annotation Tools"
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
 
+    @property
+    def db_url(self) -> str:
+        return f"mysql+pymysql://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
 
-db_config = {
-    'user': os.environ.get('DB_USER'),
-    'password': os.environ.get('DB_PASSWORD'),
-    'host': os.environ.get('DB_HOST'),
-    'port': os.environ.get('DB_PORT'),
-    'database': os.environ.get('DB_NAME')
-}
 
-hf_token = os.environ.get('HF_TOKEN')
-hf_tts_ds_repo = os.environ.get('HF_TTS_DS_REPO')
+conf = Config()

models.py → data/models.py

@@ -1,89 +1,76 @@
 from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime, ForeignKey
 from sqlalchemy.orm import relationship, declarative_base
-from pydantic import BaseModel, ConfigDict, StringConstraints
-from typing import Annotated
-from typing import List
-from datetime import datetime
 
 Base = declarative_base()
 
 
+class TTSData(Base):
+    __tablename__ = "tts_data"
+
+    id = Column(Integer, primary_key=True)
+    filename = Column(String, nullable=False, unique=True)
+    sentence = Column(String, nullable=False)
+
 
-class TTSDataOut(BaseModel):
-    id: int
-    filename: Annotated[str, StringConstraints(max_length=255)]
-    sentence: str
-    
 class Annotator(Base):
-    __tablename__ = 'annotators'
+    __tablename__ = "annotators"
 
     id = Column(Integer, primary_key=True)
     name = Column(String, nullable=False, unique=True)
     password = Column(String, 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') 
+    annotations = relationship("Annotation", backref="annotator")
+    validators = relationship("Validator", backref="annotator")
+    annotation_intervals = relationship("AnnotationInterval", backref="annotator")
 
 
 class Validator(Base):
-    __tablename__ = 'validators'
+    __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"))
+    validator_id = Column(Integer, ForeignKey("annotators.id"))
 
 
 class AnnotationInterval(Base):
-    __tablename__ = 'annotation_intervals'
+    __tablename__ = "annotation_intervals"
 
     id = Column(Integer, primary_key=True)
-    annotator_id = Column(Integer, ForeignKey('annotators.id'))
+    annotator_id = Column(Integer, ForeignKey("annotators.id"))
     start_index = Column(Integer, nullable=True)
     end_index = Column(Integer, nullable=True)
 
 
+class Annotation(Base):
+    __tablename__ = "annotations"
+
+    id = Column(Integer, primary_key=True)
+    annotated_sentence = Column(String, 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")
+    validations = relationship(
+        "Validation", cascade="all, delete", backref="annotation"
+    )
+
+
 class AudioTrim(Base):
-    __tablename__ = 'audio_trims'
+    __tablename__ = "audio_trims"
 
     id = Column(Integer, primary_key=True)
     start = Column(Float, nullable=False)
     end = Column(Float, nullable=False)
-    annotation_id = Column(Integer, ForeignKey('annotations.id'))
+    annotation_id = Column(Integer, ForeignKey("annotations.id"))
 
-class Annotation(Base):
-    __tablename__ = 'annotations'
+
+class Validation(Base):
+    __tablename__ = "validations"
 
     id = Column(Integer, primary_key=True)
-    annotated_subtitle = Column(String, nullable=False)
+    annotation_id = Column(Integer, ForeignKey("annotations.id"))
+    validator_id = Column(Integer, ForeignKey("validators.id"))
     validated = Column(Boolean, nullable=False)
-    create_at = Column(DateTime, nullable=False)
-    update_at = Column(DateTime, nullable=False)
-    audio_trims = relationship('AudioTrim', cascade='all, delete', backref='annotation')
-    json_data_id = Column(Integer, ForeignKey('json_data.id'))
-    annotator_id = Column(Integer, ForeignKey('annotators.id'))
-
-
-class AudioTrimModel(BaseModel):
-    start: float
-    end: float
-    model_config = ConfigDict(from_attributes=True)
-
-class AnnotationModel(BaseModel):
-    annotator: str
-    annotated_subtitle: str
-    is_first_phase_accepted: bool
-    create_at: datetime
-    update_at: datetime
-    audio_trims: List[AudioTrimModel]
-    model_config = ConfigDict(from_attributes=True)
-
-class JsonDataModel(BaseModel):
-    id: int
-    voice_name: str
-    original_subtitle: str
-    ignore_it: bool
-    is_approved_in_second_phase: bool
-    annotations: List[AnnotationModel]
-    model_config = ConfigDict(from_attributes=True)
+    description = Column(String, nullable=True)
+    validated_at = Column(DateTime, nullable=False)

database.py

@@ -1,152 +0,0 @@
-from sqlalchemy import create_engine, Column, Integer, String, Float, Boolean, DateTime, ForeignKey
-from sqlalchemy.orm import sessionmaker, relationship, declarative_base
-from pydantic import BaseModel, ConfigDict
-from typing import List
-from datetime import datetime
-
-# ایجاد مدل‌های SQLAlchemy
-Base = declarative_base()
-
-class Annotator(Base):
-    __tablename__ = 'annotators'
-
-    id = Column(Integer, primary_key=True)
-    name = Column(String, nullable=False, unique=True)
-    password = Column(String, nullable=False)
-    last_login = Column(DateTime)
-    is_active = Column(Boolean, default=True)
-    annotations = relationship('Annotation', backref='annotator')
-
-class AudioTrim(Base):
-    __tablename__ = 'audio_trims'
-
-    id = Column(Integer, primary_key=True)
-    start = Column(Float, nullable=False)
-    end = Column(Float, nullable=False)
-    annotation_id = Column(Integer, ForeignKey('annotations.id'))
-
-class Annotation(Base):
-    __tablename__ = 'annotations'
-
-    id = Column(Integer, primary_key=True)
-    annotated_subtitle = Column(String, nullable=False)
-    is_first_phase_accepted = Column(Boolean, nullable=False)
-    create_at = Column(DateTime, nullable=False)
-    update_at = Column(DateTime, nullable=False)
-    audio_trims = relationship('AudioTrim', cascade='all, delete', backref='annotation')
-    json_data_id = Column(Integer, ForeignKey('json_data.id'))
-    annotator_id = Column(Integer, ForeignKey('annotators.id'))
-
-class JsonData(Base):
-    __tablename__ = 'json_data'
-
-    id = Column(Integer, primary_key=True)
-    voice_name = Column(String, nullable=False)
-    original_subtitle = Column(String, nullable=False)
-    ignore_it = Column(Boolean, nullable=False)
-    is_approved_in_second_phase = Column(Boolean, nullable=False)
-    annotations = relationship('Annotation', cascade='all, delete', backref='json_data')
-
-# ایجاد مدل‌های Pydantic
-class AudioTrimModel(BaseModel):
-    start: float
-    end: float
-    model_config = ConfigDict(from_attributes=True)
-
-class AnnotationModel(BaseModel):
-    annotator: str
-    annotated_subtitle: str
-    is_first_phase_accepted: bool
-    create_at: datetime
-    update_at: datetime
-    audio_trims: List[AudioTrimModel]
-    model_config = ConfigDict(from_attributes=True)
-
-class JsonDataModel(BaseModel):
-    id: int
-    voice_name: str
-    original_subtitle: str
-    ignore_it: bool
-    is_approved_in_second_phase: bool
-    annotations: List[AnnotationModel]
-    model_config = ConfigDict(from_attributes=True)
-
-# ایجاد جلسه
-DB_URL = "mysql+pymysql://user:password@localhost/testdb"  # اطلاعات کاربری و دیتابیس را ویرایش کنید
-engine = create_engine(DB_URL)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-def initialize_database():
-    Base.metadata.create_all(bind=engine)
-
-# تابع ذخیره داده‌ها در دیتابیس
-def save_json_data(json_data_dict):
-    db = SessionLocal()
-    try:
-        # استفاده از Pydantic برای اعتبارسنجی داده‌ها
-        json_data = JsonDataModel(**json_data_dict)
-
-        for annotation in json_data.annotations:
-            # تامین موجودیت annotator
-            db_annotator = db.query(Annotator).filter_by(name=annotation.annotator).first()
-            if not db_annotator:
-                db_annotator = Annotator(name=annotation.annotator, password="default_password")
-                db.add(db_annotator)
-                db.commit()  # اضافه کنید تا id اختصاص داده شود
-
-            # تبدیل مدل Pydantic به مدل SQLAlchemy
-            db_annotation = Annotation(
-                annotated_subtitle=annotation.annotated_subtitle,
-                is_first_phase_accepted=annotation.is_first_phase_accepted,
-                create_at=annotation.create_at,
-                update_at=annotation.update_at,
-                audio_trims=[
-                    AudioTrim(start=trim.start, end=trim.end) for trim in annotation.audio_trims
-                ],
-                annotator=db_annotator
-            )
-
-            db_json_data = JsonData(
-                id=json_data.id,
-                voice_name=json_data.voice_name,
-                original_subtitle=json_data.original_subtitle,
-                ignore_it=json_data.ignore_it,
-                is_approved_in_second_phase=json_data.is_approved_in_second_phase,
-                annotations=[db_annotation]
-            )
-
-            db.add(db_json_data)
-            db.commit()
-
-    except Exception as e:
-        db.rollback()
-        print(e)
-    finally:
-        db.close()
-
-# فراخوانی تابع ایجاد جدول‌ها و افزودن داده
-initialize_database()
-
-# داده‌ی نمونه برای افزودن
-json_data = {
-    "id": 16562,
-    "voice_name": "voice1.wav",
-    "original_subtitle": "خلاصه با دلی ناراحت این کار رو کرد کاری رو که به نظرم میاد کار عقلانی بوده و رفتن رسیدن همون جایی که خاطره خداحافظی ۶ سال پیش رو واسه شکلتون زنده کرد اون بار به عنوان invalid اون بار به عنوان ادمی که از پس کار برنیومده",
-    "ignore_it": False,
-    "annotations": [
-        {
-            "annotator": "amin76",
-            "annotated_subtitle": "خلاصه با دلی ناراحت این کار رو کرد کاری رو که به نظرم میاد کار عقلانی بوده و رفتن رسیدن همون جایی که خاطره خداحافظی شش سال پیش رو واسه شکلتون زنده کرد اون بار به عنوان اينوليد اون بار به عنوان آدمی که از پس کار برنیومده",
-            "audio_trims": [
-                {"start": 14.5, "end": 15.0},
-                {"start": 14.3, "end": 15.0}
-            ],
-            "is_first_phase_accepted": False,
-            "create_at": "2025-05-20T16:05:53.138811",
-            "update_at": "2025-05-20T16:06:28.525393"
-        }
-    ],
-    "is_approved_in_second_phase": False
-}
-
-save_json_data(json_data)

requirements.txt

@@ -3,4 +3,5 @@ sqlalchemy
 pydantic
 mysql-connector-python
 soundfile
-librosa
+librosa
+pydantic-settings

seed_db.py

@@ -1,52 +0,0 @@
-import mysql.connector
-from datasets import load_dataset
-from huggingface_hub import login
-import config
-
-
-def seed():
-    login(token=config.hf_token)
-    dataset = load_dataset(config.hf_tts_ds_repo, split="train", trust_remote_code=True)
-
-    print(dataset.column_names)
-    print(dataset[0])
-
-    conn = mysql.connector.connect(**config.db_config)
-    cursor = conn.cursor()
-
-    cursor.execute(
-        """
-    CREATE TABLE IF NOT EXISTS tts_data (
-        id INT AUTO_INCREMENT PRIMARY KEY,
-        filename VARCHAR(200) UNIQUE,
-        sentence TEXT
-    )
-    """
-    )
-
-    batch_size = 1000
-    batch = []
-
-    for i, item in enumerate(dataset):
-        filename = item["audio"]["path"]
-        sentence = item["sentence"] 
-        batch.append((filename, sentence))
-
-        if len(batch) == batch_size:
-            cursor.executemany(
-                "INSERT INTO tts_data (filename, sentence) VALUES (%s, %s)", batch
-            )
-            conn.commit()
-            print(f"✅ {i + 1} records saved!")
-            batch = []
-
-    if batch:
-        cursor.executemany(
-            "INSERT INTO tts_data (filename, sentence) VALUES (%s, %s)", batch
-        )
-        conn.commit()
-        print(f"✅ last {len(batch)} records saved.")
-
-    cursor.close()
-    conn.close()
-    return "done!"

db_test.py → test/db_test.py

@@ -2,16 +2,18 @@ import mysql.connector
 from mysql.connector import Error
 import config 
 
-
 try:
     conn = mysql.connector.connect(**config.db_config)
     if conn.is_connected():
         print("✅OK!")
 
         cursor = conn.cursor()
-        cursor.execute("DROP TABLE IF EXISTS tts_data")
-        version = cursor.fetchone()
-        print("🟢Done")
+        cursor.execute("SELECT id, filename, sentence FROM tts_data ORDER BY id DESC LIMIT 5")
+        records = cursor.fetchall()
+
+        print("🟢Last 5 records:")
+        for record in records:
+            print(record)
 
 except Error as e:
     print("❌ error:", e)
@@ -21,4 +23,4 @@ finally:
         cursor.close()
     if 'conn' in locals() and conn.is_connected():
         conn.close()
-        print("⛔️Closed.")
+        print("⛔️Closed.")

test/test.py

@@ -0,0 +1,96 @@
+import gradio as gr
+
+USERS = {"u1": "123", "u2": "234"}
+
+
+def local_login(username: str, password: str, session: dict):
+    """Authenticate against the in-memory USERS dict."""
+    if USERS.get(username) != password:
+        return (
+            "❌ Wrong username or password!",
+            gr.update(),  # keep login form unchanged
+            gr.update(visible=False),  # hide dashboard
+        )
+
+    # Successful login
+    session["user"] = username
+    return (
+        f"✅ Hello *{username}*",
+        gr.update(visible=False),  # hide login form
+        gr.update(visible=True),  # show dashboard
+    )
+
+
+# --- 1.  Update the logout function -----------------------------------------
+def local_logout(session: dict):
+    """Clear the session, show the login form, hide the dashboard,
+    and clear any previous login message."""
+    session.clear()
+    return (
+        gr.update(visible=True),  # show login_form
+        gr.update(visible=False),  # hide dashboard
+        gr.update(value=""),  # clear login_msg
+    )
+
+
+def echo_with_user(text: str, session: dict):
+    """Return 'username: text'."""
+    user = session.get("user", "(none)")
+    return f"{user}: {text}"
+
+
+def oauth_welcome(profile: gr.OAuthProfile, session: dict):
+    """Executed after a successful OAuth login."""
+    if profile is None:
+        return gr.update(visible=False)
+
+    session["user"] = profile.username
+    return gr.update(value=f"✅ Welcome {profile.username}", visible=True)
+
+
+with gr.Blocks(title="Multi-user Login Demo") as demo:
+    # Session state is kept per browser tab
+    session = gr.State({})
+
+    # -------------------- Login form --------------------
+    with gr.Column(visible=True) as login_form:
+        username = gr.Text(label="Username")
+        password = gr.Text(label="Password", type="password")
+        login_btn = gr.Button("Log in")
+        login_msg = gr.Markdown()
+
+    # -------------------- Dashboard --------------------
+    with gr.Column(visible=False) as dashboard:
+        welcome = gr.Markdown()
+        echo_box = gr.Textbox(label="Echo – whatever you type will be returned")
+        echo_btn = gr.Button("Echo")  # renamed button
+        echo_output = gr.Markdown()  # where result is shown
+        logout_btn = gr.Button("Log out")
+
+    # -------------- Callbacks (local DB version) --------
+    login_btn.click(
+        fn=local_login,
+        inputs=[username, password, session],
+        outputs=[login_msg, login_form, dashboard],
+        concurrency_limit=10,
+    ).then(
+        lambda s: f"👋 Active user: {s.get('user', '')}",
+        inputs=session,
+        outputs=welcome,
+    )
+
+    logout_btn.click(
+        fn=local_logout,
+        inputs=session,
+        outputs=[login_form, dashboard, login_msg],  # ← added login_msg
+    )
+    
+    echo_btn.click(
+        fn=echo_with_user,
+        inputs=[echo_box, session],
+        outputs=echo_output,
+    )
+
+
+demo.queue(default_concurrency_limit=50)
+demo.launch()

utils/auth.py

@@ -0,0 +1,42 @@
+# utils/auth.py
+import gradio as gr
+
+
+class AuthService:
+    """
+    Authentication / business-logic layer.
+    Replace with real DB + hashed passwords in production.
+    """
+    _USERS = {"u1": "123", "u2": "234"}
+
+    # ─────────────────── core actions ────────────────────
+    @staticmethod
+    def login(username: str, password: str, session: dict):
+        if AuthService._USERS.get(username) != password:
+            return (
+                "❌ Wrong username or password!",
+                gr.update(),               # keep login form visible
+                gr.update(visible=False),  # hide dashboard
+            )
+
+        # success
+        session["user"] = username
+        return (
+            f"✅ Hello *{username}*",
+            gr.update(visible=False),      # hide login form
+            gr.update(visible=True),       # show dashboard
+        )
+
+    @staticmethod
+    def logout(session: dict):
+        session.clear()
+        return (
+            gr.update(visible=True),    # show login page
+            gr.update(visible=False),   # hide dashboard
+            gr.update(value="")         # clear old messages
+        )
+
+    @staticmethod
+    def echo(text: str, session: dict):
+        user = session.get("user", "(none)")
+        return f"{user}: {text}"

utils/database.py

@@ -0,0 +1,53 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from contextlib import contextmanager
+from config import conf
+from utils.logger import Logger
+
+log = Logger.get_logger()
+
+
+def get_db_engine():
+    """Create DB engine with error handling for HF Spaces"""
+    try:
+        engine = create_engine(
+            conf.db_url,
+            pool_pre_ping=True,
+            pool_size=5,
+            max_overflow=10,
+            connect_args={"connect_timeout": 10},
+        )
+        log.info("Database engine created successfully")
+        return engine
+    except Exception as e:
+        log.error(f"Failed to create database engine: {e}")
+
+
+engine = get_db_engine()
+SessionLocal = sessionmaker(bind=engine)
+
+
+@contextmanager
+def get_db():
+    """Session manager for HF Spaces"""
+    db = SessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        log.error(f"Database error: {e}")
+        raise
+    finally:
+        db.close()
+
+
+def initialize_database():
+    """Initialize tables with HF Spaces compatibility"""
+    try:
+        from data.models import Base
+
+        Base.metadata.create_all(bind=engine)
+        log.info("Tables created successfully")
+    except Exception as e:
+        log.error(f"Table creation failed: {e}")

utils/logger.py

@@ -0,0 +1,39 @@
+import logging
+import sys
+from typing import Optional
+
+
+class Logger:
+    _initialized = False
+
+    @classmethod
+    def initialize(cls, level: str = "INFO", name: Optional[str] = None):
+        if cls._initialized:
+            return
+
+        logger = logging.getLogger(name or __name__)
+        logger.setLevel(level)
+
+        # Create console handler
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(level)
+
+        # Simple formatter
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        handler.setFormatter(formatter)
+
+        # Add handler and prevent duplication
+        if not logger.handlers:
+            logger.addHandler(handler)
+
+        cls._initialized = True
+        return logger
+
+    @classmethod
+    def get_logger(cls, name: Optional[str] = None) -> logging.Logger:
+        if not cls._initialized:
+            cls.initialize()
+        return logging.getLogger(name or __name__)