base app

app.py

@@ -1,12 +1,13 @@
 # app.py
-
 import gradio as gr
 from pathlib import Path
 
+from utils.logger import Logger
 from components.login_page import LoginPage
 from components.dashboard_page import DashboardPage
 from config import conf
 
+log = Logger()
 CSS_FILE = Path(__file__).parent / "assets" / "styles.css"
 custom_css = CSS_FILE.read_text(encoding="utf-8")
 
@@ -24,9 +25,13 @@ def build_app() -> gr.Blocks:
         dashboard_page.register_callbacks(login_page, session)
 
         demo.queue(default_concurrency_limit=50)
-
+        log.info("App Started.")
     return demo
 
 
 if __name__ == "__main__":
-    build_app().launch()
+    try:
+        log.info("Initial App ...")
+        build_app().launch()
+    except Exception as err:
+        log.error(err)

components/dashboard_page.py

@@ -1,6 +1,6 @@
 # components/dashboard_page.py
+
 import gradio as gr
-from utils.auth import AuthService
 from components.header import Header
 
 
@@ -13,18 +13,9 @@ class DashboardPage:
             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)
+        self.header.register_callbacks(login_page, self, session_state)

components/header.py

@@ -1,4 +1,5 @@
 # components/header.py
+
 import gradio as gr
 from utils.auth import AuthService
 

components/login_page.py

@@ -1,4 +1,5 @@
 # components/login_page.py
+
 import gradio as gr
 from utils.auth import AuthService
 
@@ -8,18 +9,20 @@ class LoginPage:
 
     def __init__(self):
         with gr.Row(visible=True) as self.container:
-            gr.Column(scale=1)          # left spacer
+            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.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
+            gr.Column(scale=1)  # right spacer
 
     # event wiring unchanged …
     def register_callbacks(self, dashboard_page, session_state):
@@ -34,4 +37,4 @@ class LoginPage:
             lambda s: f"### User: {s.get('user', '')}",
             inputs=session_state,
             outputs=header.welcome,
-        )
+        )

test/test.py

@@ -1,96 +0,0 @@
-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

@@ -1,42 +1,42 @@
 # utils/auth.py
+
 import gradio as gr
+from utils.logger import Logger
+
+log = Logger()
 
 
 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):
+        log.info(f"Login attempt: username={username}")
         if AuthService._USERS.get(username) != password:
+            log.warning(f"Failed login for username={username}")
             return (
                 "❌ Wrong username or password!",
-                gr.update(),               # keep login form visible
+                gr.update(),  # keep login form visible
                 gr.update(visible=False),  # hide dashboard
             )
 
         # success
         session["user"] = username
+        log.info(f"User '{username}' logged in successfully.")
         return (
-            f"✅ Hello *{username}*",
-            gr.update(visible=False),      # hide login form
-            gr.update(visible=True),       # show dashboard
+            None,
+            gr.update(visible=False),  # hide login form
+            gr.update(visible=True),  # show dashboard
         )
 
     @staticmethod
     def logout(session: dict):
+        username = session.get("user", "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),  # 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

@@ -4,7 +4,7 @@ from contextlib import contextmanager
 from config import conf
 from utils.logger import Logger
 
-log = Logger.get_logger()
+log = Logger()
 
 
 def get_db_engine():

utils/logger.py

@@ -1,39 +1,15 @@
-import logging
-import sys
-from typing import Optional
-
+from datetime import datetime
 
 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)
+    def _log(self, level, message):
+        now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        print(f"[{now}] [{level.upper()}] {message}")
 
-        # Add handler and prevent duplication
-        if not logger.handlers:
-            logger.addHandler(handler)
+    def info(self, message):
+        self._log('info', message)
 
-        cls._initialized = True
-        return logger
+    def warning(self, message):
+        self._log('warning', message)
 
-    @classmethod
-    def get_logger(cls, name: Optional[str] = None) -> logging.Logger:
-        if not cls._initialized:
-            cls.initialize()
-        return logging.getLogger(name or __name__)
+    def error(self, message):
+        self._log('error', message)