testing payslip

.github/workflows/notify.yml

@@ -0,0 +1,44 @@
+name: Daily Emotion Check-In Notifications
+
+on:
+  schedule:
+    - cron: "30 3 * * *"   # 9 AM IST
+    - cron: "15 11 * * *"  # 4:45 PM IST
+  workflow_dispatch: {}
+
+jobs:
+  morning_notify:
+    if: github.event.schedule == '30 3 * * *'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send morning notification
+        run: |
+          curl -X POST "https://yuvabe-ai-yuvabe-app-backend.hf.space/home/notify/all" \
+            -H "accept: application/json" \
+            -H "Content-Type: application/json" \
+            -d '{
+              "title": "Good Morning!",
+              "body": "How are you feeling today?",
+              "data": {
+                "type": "home_alert",
+                "message": "Good morning! Would you like to share how you feel today?"
+              }
+            }'
+
+  evening_notify:
+    if: github.event.schedule == '15 11 * * *'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send evening notification
+        run: |
+          curl -X POST "https://yuvabe-ai-yuvabe-app-backend.hf.space/home/notify/all" \
+            -H "accept: application/json" \
+            -H "Content-Type: application/json" \
+            -d '{
+              "title": "Good Evening!",
+              "body": "Take a moment to reflect on your day.",
+              "data": {
+                "type": "home_alert",
+                "message": "Evening check-in — How was your day?"
+              }
+            }'

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+venv/
+.env
+.idea/

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "7860"]

alembic.ini

@@ -0,0 +1,147 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the tzdata library which can be installed by adding
+# `alembic[tz]` to the pip requirements.
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,78 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config, pool
+from sqlmodel import SQLModel
+
+from alembic import context
+from src.core import *
+from src.core.config import settings
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+config.set_main_option(name="sqlalchemy.url", value=settings.DATABASE_URL)
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = SQLModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,29 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

alembic/versions/1cbb7317540a_fix_water_log_id_uuid.py

@@ -0,0 +1,32 @@
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import uuid
+
+# revision identifiers, used by Alembic.
+revision: str = '1cbb7317540a'
+down_revision: Union[str, Sequence[str], None] = '9176b44b89ba'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # Drop the old id column (this will remove the INTEGER id column)
+    op.drop_column('water_logs', 'id')
+    
+    # Add the new UUID id column
+    op.add_column('water_logs', sa.Column('id', sa.UUID(), nullable=False, primary_key=True, default=uuid.uuid4))
+    
+    # Optional: If you had any foreign key constraints or other indexes on the old id, you might need to add them back.
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # Drop the UUID id column
+    op.drop_column('water_logs', 'id')
+    
+    # Add the original INTEGER id column back
+    op.add_column('water_logs', sa.Column('id', sa.Integer(), nullable=False, primary_key=True))
+    
+    # Optional: Restore any other changes you might have made during the downgrade

alembic/versions/1eacc17f4c52_add_leaves_table_and_device_tokens_array.py

@@ -0,0 +1,33 @@
+"""add leaves table and device_tokens array
+
+Revision ID: 1eacc17f4c52
+Revises: dd61202db14f
+Create Date: 2025-11-18 22:14:31.077909
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '1eacc17f4c52'
+down_revision: Union[str, Sequence[str], None] = 'dd61202db14f'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('users', sa.Column('device_tokens', postgresql.ARRAY(sa.String()), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'device_tokens')
+    # ### end Alembic commands ###

alembic/versions/217db60578fa_added_journal_table.py

@@ -0,0 +1,44 @@
+"""added journal table
+
+Revision ID: 217db60578fa
+Revises: d9b4df655a55
+Create Date: 2025-12-05 14:19:31.722971
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '217db60578fa'
+down_revision: Union[str, Sequence[str], None] = 'd9b4df655a55'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('journal_entries',
+    sa.Column('id', sa.Uuid(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('title', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+    sa.Column('content', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+    sa.Column('journal_date', sa.Date(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), nullable=False),
+    sa.Column('updated_at', sa.DateTime(), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('user_id', 'journal_date', name='unique_user_date_journal')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('journal_entries')
+    # ### end Alembic commands ###

alembic/versions/52828bff621c_updated_leave_status_enum_cancelled.py

@@ -0,0 +1,31 @@
+"""updated leave_status enum CANCELLED
+
+Revision ID: 52828bff621c
+Revises: d9bb355538fd
+Create Date: 2025-11-25 20:04:09.823594
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '52828bff621c'
+down_revision: Union[str, Sequence[str], None] = 'd9bb355538fd'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    pass
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

alembic/versions/584a5111e60f_initial_migration.py

@@ -0,0 +1,33 @@
+"""initial migration
+
+Revision ID: 584a5111e60f
+Revises: 
+Create Date: 2025-11-10 23:50:23.367946
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '584a5111e60f'
+down_revision: Union[str, Sequence[str], None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

alembic/versions/5b5a3c7a6255_update_cascade_deletion.py

@@ -0,0 +1,99 @@
+"""update: cascade deletion
+
+Revision ID: 5b5a3c7a6255
+Revises: 52828bff621c
+Create Date: 2025-11-28 11:27:38.960269
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '5b5a3c7a6255'
+down_revision: Union[str, Sequence[str], None] = '52828bff621c'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(op.f('assets_user_id_fkey'), 'assets', type_='foreignkey')
+    op.create_foreign_key(None, 'assets', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.drop_constraint(op.f('comments_user_id_fkey'), 'comments', type_='foreignkey')
+    op.drop_constraint(op.f('comments_post_id_fkey'), 'comments', type_='foreignkey')
+    op.create_foreign_key(None, 'comments', 'posts', ['post_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'comments', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.drop_constraint(op.f('emotion_logs_user_id_fkey'), 'emotion_logs', type_='foreignkey')
+    op.create_foreign_key(None, 'emotion_logs', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.drop_constraint(op.f('knowledge_chunk_kb_id_fkey'), 'knowledge_chunk', type_='foreignkey')
+    op.create_foreign_key(None, 'knowledge_chunk', 'knowledge_base', ['kb_id'], ['id'], ondelete='CASCADE')
+    op.alter_column('leave', 'mentor_id',
+               existing_type=sa.UUID(),
+               nullable=True)
+    op.alter_column('leave', 'lead_id',
+               existing_type=sa.UUID(),
+               nullable=True)
+    op.drop_constraint(op.f('leave_lead_id_fkey'), 'leave', type_='foreignkey')
+    op.drop_constraint(op.f('leave_user_id_fkey'), 'leave', type_='foreignkey')
+    op.drop_constraint(op.f('leave_mentor_id_fkey'), 'leave', type_='foreignkey')
+    op.create_foreign_key(None, 'leave', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'leave', 'users', ['mentor_id'], ['id'], ondelete='SET NULL')
+    op.create_foreign_key(None, 'leave', 'users', ['lead_id'], ['id'], ondelete='SET NULL')
+    op.drop_constraint(op.f('likes_user_id_fkey'), 'likes', type_='foreignkey')
+    op.drop_constraint(op.f('likes_post_id_fkey'), 'likes', type_='foreignkey')
+    op.create_foreign_key(None, 'likes', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'likes', 'posts', ['post_id'], ['id'], ondelete='CASCADE')
+    op.drop_constraint(op.f('user_devices_user_id_fkey'), 'user_devices', type_='foreignkey')
+    op.create_foreign_key(None, 'user_devices', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.drop_constraint(op.f('user_teams_role_team_id_fkey'), 'user_teams_role', type_='foreignkey')
+    op.drop_constraint(op.f('user_teams_role_role_id_fkey'), 'user_teams_role', type_='foreignkey')
+    op.drop_constraint(op.f('user_teams_role_user_id_fkey'), 'user_teams_role', type_='foreignkey')
+    op.create_foreign_key(None, 'user_teams_role', 'teams', ['team_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'user_teams_role', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'user_teams_role', 'roles', ['role_id'], ['id'], ondelete='CASCADE')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(None, 'user_teams_role', type_='foreignkey')
+    op.drop_constraint(None, 'user_teams_role', type_='foreignkey')
+    op.drop_constraint(None, 'user_teams_role', type_='foreignkey')
+    op.create_foreign_key(op.f('user_teams_role_user_id_fkey'), 'user_teams_role', 'users', ['user_id'], ['id'])
+    op.create_foreign_key(op.f('user_teams_role_role_id_fkey'), 'user_teams_role', 'roles', ['role_id'], ['id'])
+    op.create_foreign_key(op.f('user_teams_role_team_id_fkey'), 'user_teams_role', 'teams', ['team_id'], ['id'])
+    op.drop_constraint(None, 'user_devices', type_='foreignkey')
+    op.create_foreign_key(op.f('user_devices_user_id_fkey'), 'user_devices', 'users', ['user_id'], ['id'])
+    op.drop_constraint(None, 'likes', type_='foreignkey')
+    op.drop_constraint(None, 'likes', type_='foreignkey')
+    op.create_foreign_key(op.f('likes_post_id_fkey'), 'likes', 'posts', ['post_id'], ['id'])
+    op.create_foreign_key(op.f('likes_user_id_fkey'), 'likes', 'users', ['user_id'], ['id'])
+    op.drop_constraint(None, 'leave', type_='foreignkey')
+    op.drop_constraint(None, 'leave', type_='foreignkey')
+    op.drop_constraint(None, 'leave', type_='foreignkey')
+    op.create_foreign_key(op.f('leave_mentor_id_fkey'), 'leave', 'users', ['mentor_id'], ['id'])
+    op.create_foreign_key(op.f('leave_user_id_fkey'), 'leave', 'users', ['user_id'], ['id'])
+    op.create_foreign_key(op.f('leave_lead_id_fkey'), 'leave', 'users', ['lead_id'], ['id'])
+    op.alter_column('leave', 'lead_id',
+               existing_type=sa.UUID(),
+               nullable=False)
+    op.alter_column('leave', 'mentor_id',
+               existing_type=sa.UUID(),
+               nullable=False)
+    op.drop_constraint(None, 'knowledge_chunk', type_='foreignkey')
+    op.create_foreign_key(op.f('knowledge_chunk_kb_id_fkey'), 'knowledge_chunk', 'knowledge_base', ['kb_id'], ['id'])
+    op.drop_constraint(None, 'emotion_logs', type_='foreignkey')
+    op.create_foreign_key(op.f('emotion_logs_user_id_fkey'), 'emotion_logs', 'users', ['user_id'], ['id'])
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.create_foreign_key(op.f('comments_post_id_fkey'), 'comments', 'posts', ['post_id'], ['id'])
+    op.create_foreign_key(op.f('comments_user_id_fkey'), 'comments', 'users', ['user_id'], ['id'])
+    op.drop_constraint(None, 'assets', type_='foreignkey')
+    op.create_foreign_key(op.f('assets_user_id_fkey'), 'assets', 'users', ['user_id'], ['id'])
+    # ### end Alembic commands ###

alembic/versions/9176b44b89ba_added_water_logs_table.py

@@ -0,0 +1,42 @@
+"""added: water_logs table
+
+Revision ID: 9176b44b89ba
+Revises: e96769f268bc
+Create Date: 2025-11-29 21:28:42.789611
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '9176b44b89ba'
+down_revision: Union[str, Sequence[str], None] = 'e96769f268bc'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('water_logs',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('amount_ml', sa.Integer(), nullable=False),
+    sa.Column('logged_at', sa.DateTime(), nullable=False),
+    sa.Column('goal_ml', sa.Integer(), nullable=True),
+    sa.Column('recommended_ml', sa.Integer(), nullable=True),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('water_logs')
+    # ### end Alembic commands ###

alembic/versions/a3c79664f866_sync_models.py

@@ -0,0 +1,33 @@
+"""sync models
+
+Revision ID: a3c79664f866
+Revises: 1eacc17f4c52
+Create Date: 2025-11-18 22:23:01.757260
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = 'a3c79664f866'
+down_revision: Union[str, Sequence[str], None] = '1eacc17f4c52'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('users', sa.Column('device_tokens', postgresql.ARRAY(sa.String()), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'device_tokens')
+    # ### end Alembic commands ###

alembic/versions/b33e3b5b7af9_added_roles.py

@@ -0,0 +1,33 @@
+"""Added roles
+
+Revision ID: b33e3b5b7af9
+Revises: e8066533b622
+Create Date: 2025-11-16 21:10:02.038255
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'b33e3b5b7af9'
+down_revision: Union[str, Sequence[str], None] = 'e8066533b622'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

alembic/versions/d9b4df655a55_updated_emotion_tag.py

@@ -0,0 +1,45 @@
+"""updated emotion tag
+
+Revision ID: d9b4df655a55
+Revises: fec3872d7eba
+Create Date: 2025-12-04 14:34:22.373838
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'd9b4df655a55'
+down_revision: Union[str, Sequence[str], None] = 'fec3872d7eba'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    emotion_enum = sa.Enum(
+        'JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED',
+        name='emotion_enum'
+    )
+    emotion_enum.create(op.get_bind(), checkfirst=True)
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('emotion_logs', sa.Column('morning_emotion', sa.Enum('JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED', name='emotion_enum'), nullable=True))
+    op.add_column('emotion_logs', sa.Column('evening_emotion', sa.Enum('JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED', name='emotion_enum'), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('emotion_logs', 'evening_emotion')
+    op.drop_column('emotion_logs', 'morning_emotion')
+    emotion_enum = sa.Enum(
+        'JOYFUL', 'HAPPY', 'CALM', 'NEUTRAL', 'ANXIOUS', 'SAD', 'FRUSTRATED',
+        name='emotion_enum'
+    )
+    emotion_enum.drop(op.get_bind(), checkfirst=True)
+    # ### end Alembic commands ###

alembic/versions/d9bb355538fd_add_is_read_to_leave_table.py

@@ -0,0 +1,34 @@
+"""add is_read to leave table
+
+Revision ID: d9bb355538fd
+Revises: e95f62f91348
+Create Date: 2025-11-25 16:43:45.584602
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'd9bb355538fd'
+down_revision: Union[str, Sequence[str], None] = 'e95f62f91348'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    op.add_column(
+        "leave",
+        sa.Column(
+            "is_read",
+            sa.Boolean(),
+            nullable=False,
+            server_default=sa.false()
+        )
+    )
+
+def downgrade():
+    op.drop_column("leave", "is_read")

alembic/versions/dd61202db14f_add_knowledgebase_chunk.py

@@ -0,0 +1,33 @@
+"""add: knowledgebase,chunk
+
+Revision ID: dd61202db14f
+Revises: b33e3b5b7af9
+Create Date: 2025-11-17 23:28:11.537932
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'dd61202db14f'
+down_revision: Union[str, Sequence[str], None] = 'b33e3b5b7af9'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

alembic/versions/e8066533b622_delete_user_verification_cols.py

@@ -0,0 +1,49 @@
+"""delete:user/verification cols
+
+Revision ID: e8066533b622
+Revises: 584a5111e60f
+Create Date: 2025-11-11 10:47:38.171691
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "e8066533b622"
+down_revision: Union[str, Sequence[str], None] = "584a5111e60f"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("users", "verification_token")
+    op.drop_column("users", "verification_expires_at")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "users",
+        sa.Column(
+            "verification_expires_at",
+            postgresql.TIMESTAMP(),
+            autoincrement=False,
+            nullable=True,
+        ),
+    )
+    op.add_column(
+        "users",
+        sa.Column(
+            "verification_token", sa.VARCHAR(), autoincrement=False, nullable=True
+        ),
+    )
+    # ### end Alembic commands ###

alembic/versions/e95f62f91348_added_leave_and_userdevice_table.py

@@ -0,0 +1,33 @@
+"""added: leave and userdevice table
+
+Revision ID: e95f62f91348
+Revises: a3c79664f866
+Create Date: 2025-11-22 15:42:12.098237
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = 'e95f62f91348'
+down_revision: Union[str, Sequence[str], None] = 'a3c79664f866'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'device_tokens')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('users', sa.Column('device_tokens', postgresql.ARRAY(sa.VARCHAR()), autoincrement=False, nullable=True))
+    # ### end Alembic commands ###

alembic/versions/e96769f268bc_fix_post_s_user_cascade.py

@@ -0,0 +1,41 @@
+"""fix: post's user cascade
+
+Revision ID: e96769f268bc
+Revises: 5b5a3c7a6255
+Create Date: 2025-11-28 11:58:45.282329
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'e96769f268bc'
+down_revision: Union[str, Sequence[str], None] = '5b5a3c7a6255'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('posts', 'user_id',
+               existing_type=sa.UUID(),
+               nullable=True)
+    op.drop_constraint(op.f('posts_user_id_fkey'), 'posts', type_='foreignkey')
+    op.create_foreign_key(None, 'posts', 'users', ['user_id'], ['id'], ondelete='SET NULL')
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(None, 'posts', type_='foreignkey')
+    op.create_foreign_key(op.f('posts_user_id_fkey'), 'posts', 'users', ['user_id'], ['id'])
+    op.alter_column('posts', 'user_id',
+               existing_type=sa.UUID(),
+               nullable=False)
+    # ### end Alembic commands ###

alembic/versions/f6a1d6fc82d0_add_image_url_column_to_kb.py

@@ -0,0 +1,33 @@
+"""add: image url column to kb
+
+Revision ID: f6a1d6fc82d0
+Revises: 1cbb7317540a
+Create Date: 2025-12-01 16:55:06.113217
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'f6a1d6fc82d0'
+down_revision: Union[str, Sequence[str], None] = '1cbb7317540a'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('knowledge_chunk', sa.Column('image_url', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('knowledge_chunk', 'image_url')
+    # ### end Alembic commands ###

alembic/versions/fec3872d7eba_add_payslip_table.py

@@ -0,0 +1,41 @@
+"""add:payslip table
+
+Revision ID: fec3872d7eba
+Revises: f6a1d6fc82d0
+Create Date: 2025-12-04 10:58:25.795533
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'fec3872d7eba'
+down_revision: Union[str, Sequence[str], None] = 'f6a1d6fc82d0'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(op.f('comments_post_id_fkey'), 'comments', type_='foreignkey')
+    op.drop_constraint(op.f('comments_user_id_fkey'), 'comments', type_='foreignkey')
+    op.create_foreign_key(None, 'comments', 'posts', ['post_id'], ['id'], ondelete='CASCADE')
+    op.create_foreign_key(None, 'comments', 'users', ['user_id'], ['id'], ondelete='CASCADE')
+    op.add_column('users', sa.Column('join_date', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'join_date')
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.drop_constraint(None, 'comments', type_='foreignkey')
+    op.create_foreign_key(op.f('comments_user_id_fkey'), 'comments', 'users', ['user_id'], ['id'])
+    op.create_foreign_key(op.f('comments_post_id_fkey'), 'comments', 'posts', ['post_id'], ['id'])
+    # ### end Alembic commands ###

requirements.txt

@@ -0,0 +1,80 @@
+aiosmtplib==5.0.0
+alembic==1.17.1
+annotated-doc==0.0.3
+annotated-types==0.7.0
+anyio==4.11.0
+asyncpg==0.30.0
+bcrypt==3.2.2
+cachetools==6.2.2
+certifi==2025.11.12
+cffi==2.0.0
+charset-normalizer==3.4.4
+click==8.3.0
+coloredlogs==15.0.1
+cryptography==46.0.3
+dnspython==2.8.0
+ecdsa==0.19.1
+email-validator==2.3.0
+fastapi==0.121.0
+filelock==3.20.0
+flatbuffers==25.9.23
+fsspec==2025.10.0
+google-api-core==2.28.1
+google-api-python-client==2.187.0
+google-auth==2.41.1
+google-auth-httplib2==0.2.1
+google-auth-oauthlib==1.2.3
+googleapis-common-protos==1.72.0
+greenlet==3.2.4
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httplib2==0.31.0
+httpx==0.28.1
+huggingface-hub==0.36.0
+humanfriendly==10.0
+idna==3.11
+Mako==1.3.10
+MarkupSafe==3.0.3
+mpmath==1.3.0
+numpy==2.2.6
+oauthlib==3.3.1
+onnxruntime==1.23.2
+packaging==25.0
+passlib==1.7.4
+pgvector==0.4.1
+proto-plus==1.26.1
+protobuf==6.33.1
+psycopg2-binary==2.9.11
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pycparser==2.23
+pydantic==2.12.4
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+pyparsing==3.2.5
+PyPDF2==3.0.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-jose==3.5.0
+python-multipart==0.0.20
+PyYAML==6.0.3
+regex==2025.11.3
+requests==2.32.5
+requests-oauthlib==2.0.0
+rsa==4.9.1
+safetensors==0.6.2
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.44
+sqlmodel==0.0.27
+starlette==0.49.3
+sympy==1.14.0
+tokenizers==0.22.1
+tqdm==4.67.1
+transformers==4.57.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+uritemplate==4.2.0
+urllib3==2.5.0
+uvicorn==0.38.0

src/auth/config.py

@@ -0,0 +1,17 @@
+import os
+from pydantic import BaseSettings
+from dotenv import load_dotenv
+
+
+class HomeSettings(BaseSettings):
+    FEATURE_ENABLED: bool = True
+
+
+home_settings = HomeSettings()
+
+
+load_dotenv()
+SECRET_KEY = os.getenv("SECRET_KEY")
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60

src/auth/constants.py

@@ -0,0 +1,2 @@
+WELCOME_MESSAGE = "Welcome to Yuvabe's Home Screen"
+EXIT_MESSAGE = "Thank You have a wonderful day"

src/auth/feed_db_script.py

@@ -0,0 +1,132 @@
+from src.auth.utils import hash_password
+from datetime import date
+from sqlmodel import Session
+
+from src.core.database import engine
+from src.core.models import Users, Teams, Roles, UserTeamsRole
+
+
+# ------------------------
+# 1. Seed Users
+# ------------------------
+def seed_users(session: Session):
+    users = [
+        Users(
+            email_id="[email protected]",
+            password=hash_password("Yuvabe"),
+            user_name="ragul",
+            dob=date(2001, 5, 21),
+            address="Chennai",
+            profile_picture="ragul.png",
+        ),
+        Users(
+            email_id="[email protected]",
+            password=hash_password("Yuvabe"),
+            user_name="Shri",
+            dob=date(1999, 3, 14),
+            address="Chennai",
+            profile_picture="shri.png",
+        ),
+        Users(
+            email_id="[email protected]",
+            password=hash_password("Yuvabe"),
+            user_name="Sathish",
+            dob=date(1998, 7, 10),
+            address="Chennai",
+            profile_picture="Sathish.png",
+        ),
+        Users(
+            email_id="[email protected]",
+            password=hash_password("Yuvabe"),
+            user_name="Deepika",
+            dob=date(1997, 2, 5),
+            address="Chennai",
+            profile_picture="deepika.png",
+        ),
+    ]
+
+    session.add_all(users)
+    session.commit()
+    print("Users added.")
+    return users
+
+
+# ------------------------
+# 2. Seed Teams
+# ------------------------
+def seed_teams(session: Session):
+    teams = [
+        Teams(name="Tech Team"),
+        Teams(name="HR Team"),
+    ]
+    session.add_all(teams)
+    session.commit()
+    print("Teams added.")
+    return teams
+
+
+# ------------------------
+# 3. Seed Roles
+# ------------------------
+def seed_roles(session: Session):
+    roles = [
+        Roles(name="Developer"),
+        Roles(name="Team Lead"),
+        Roles(name="HR Manager"),
+    ]
+    session.add_all(roles)
+    session.commit()
+    print("Roles added.")
+    return roles
+
+
+# ------------------------
+# 4. Map Users → Teams → Roles
+# ------------------------
+def seed_user_teams_roles(session: Session, users, teams, roles):
+    mappings = [
+        # Hari → Tech Team → Developer
+        UserTeamsRole(
+            user_id=users[0].id,  # Hari
+            team_id=teams[0].id,  # Tech Team
+            role_id=roles[0].id,  # Developer
+        ),
+        # Shri → Tech Team → Team Lead
+        UserTeamsRole(
+            user_id=users[1].id,  # Shri
+            team_id=teams[0].id,  # Tech Team
+            role_id=roles[1].id,  # Team Lead
+        ),
+        # HR Keerthana
+        UserTeamsRole(
+            user_id=users[2].id,  # Keerthana
+            team_id=teams[1].id,  # HR Team
+            role_id=roles[2].id,  # HR Manager
+        ),
+        # HR Deepika
+        UserTeamsRole(
+            user_id=users[3].id,  # Deepika
+            team_id=teams[1].id,  # HR Team
+            role_id=roles[2].id,  # HR Manager
+        ),
+    ]
+
+    session.add_all(mappings)
+    session.commit()
+    print("User-Team-Role mappings added.")
+
+
+# ------------------------
+# 5. Master Runner
+# ------------------------
+def run_all_seeds():
+    with Session(engine) as session:
+        users = seed_users(session)
+        teams = seed_teams(session)
+        roles = seed_roles(session)
+        seed_user_teams_roles(session, users, teams, roles)
+        print("All data seeded successfully!")
+
+
+if __name__ == "__main__":
+    run_all_seeds()

src/auth/models.py

@@ -0,0 +1,2 @@
+import uuid
+import sqlmodel

src/auth/router.py

@@ -0,0 +1,149 @@
+import uuid
+from src.core.database import get_async_session
+from fastapi import APIRouter, Depends, HTTPException, status
+from jose import jwt, JWTError
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import Session
+from sqlmodel.ext.asyncio.session import AsyncSession
+from src.auth.service import (
+    create_user,
+    verify_email,
+    login_user,
+)
+from src.auth.utils import get_current_user
+from src.core.models import Users, Roles, UserTeamsRole
+from sqlmodel import select
+from src.core.config import settings
+from fastapi.responses import RedirectResponse
+from .schemas import SignUpRequest, LoginRequest, BaseResponse, SendVerificationRequest
+from fastapi.security import OAuth2PasswordRequestForm
+from src.auth.utils import create_access_token
+from jose import jwt, JWTError
+
+
+router = APIRouter(prefix="/auth", tags=["Auth"])
+
+
+@router.post("/signup", response_model=BaseResponse)
+async def signup(
+    payload: SignUpRequest, session: AsyncSession = Depends(get_async_session)
+):
+    try:
+        response = await create_user(
+            session, payload.name, payload.email, payload.password
+        )
+        return {"code": 200, "data": response}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# @router.post("/send-verification", response_model=BaseResponse)
+# async def send_verification(
+#     payload: SendVerificationRequest, session: AsyncSession = Depends(get_async_session)
+# ):
+#     if not payload.email:
+#         raise HTTPException(status_code=400, detail="Email is required")
+
+#     response = await send_verification_link(session, payload.email)
+#     return {"code": 200, "data": response}
+
+
+# @router.get("/verify-email", response_model=BaseResponse)
+# async def verify_email_route(
+#     token: str, session: AsyncSession = Depends(get_async_session)
+# ):
+#     response = await verify_email(session, token)
+#     access_token = response["access_token"]
+#     redirect_url = f"yuvabe://verified?token={access_token}"
+
+#     return RedirectResponse(url=redirect_url)
+
+
+@router.post("/login", response_model=BaseResponse)
+async def login(
+    payload: LoginRequest, session: AsyncSession = Depends(get_async_session)
+):
+    response = await login_user(session, payload.email, payload.password)
+
+    user_id = response["user"]["id"]
+
+    # 🔥 Fetch User Role
+    result = await session.exec(
+        select(Roles)
+        .join(UserTeamsRole, UserTeamsRole.role_id == Roles.id)
+        .where(UserTeamsRole.user_id == uuid.UUID(user_id))
+    )
+
+    role_obj = result.first()
+    role_name = role_obj.name if role_obj else "Member"
+
+    response["user"]["role"] = (role_name or "member").lower()
+
+    return {"code": 200, "data": response}
+
+
+@router.post("/refresh", response_model=BaseResponse)
+async def refresh_token(request: dict):
+    """Generate new access token using refresh token"""
+    refresh_token = request.get("refresh_token")
+    if not refresh_token:
+        raise HTTPException(status_code=400, detail="Refresh token is required")
+
+    try:
+        payload = jwt.decode(
+            refresh_token, settings.SECRET_KEY, algorithms=[settings.JWT_ALGORITHM]
+        )
+        if payload.get("type") != "refresh":
+            raise HTTPException(status_code=400, detail="Invalid refresh token")
+
+        user_data = {
+            "sub": payload["sub"],
+            "name": payload.get("name"),
+            "email": payload.get("email"),
+        }
+        new_access_token = create_access_token(data=user_data)
+        return {"code": 200, "data": {"access_token": new_access_token}}
+
+    except JWTError:
+        raise HTTPException(status_code=401, detail="Invalid or expired refresh token")
+
+
+@router.get("/home", response_model=BaseResponse)
+async def get_home(
+    user_id: str = Depends(get_current_user),
+    session: AsyncSession = Depends(get_async_session),
+):
+    """
+    Protected home endpoint. Requires a valid access token (Bearer).
+    """
+    user = await session.get(Users, uuid.UUID(user_id))
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    role_join = await session.exec(
+        select(Roles.name)
+        .join(UserTeamsRole, UserTeamsRole.role_id == Roles.id)
+        .where(UserTeamsRole.user_id == uuid.UUID(user_id))
+    )
+    user_role = role_join.first() or "Member"
+
+    # Example payload — replace with your real app data
+    return {
+        "code": 200,
+        "data": {
+            "message": f"Welcome to Home, {user.user_name}!",
+            "user": {
+                "id": str(user.id),
+                "name": user.user_name,
+                "email": user.email_id,
+                "is_verified": user.is_verified,
+                "dob": user.dob.isoformat() if user.dob else None,
+                "profile_picture": user.profile_picture,
+                "role": user_role.lower(),
+            },
+            "home_data": {
+                "announcements": ["Welcome!", "New protocol released"],
+                "timestamp": user.created_at.isoformat() if user.created_at else None,
+            },
+        },
+    }

src/auth/schemas.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel ,EmailStr
+from typing import Optional, Union, Dict
+
+
+class SignUpRequest(BaseModel):
+    name: str
+    email: str
+    password: str
+
+
+class VerifyOtpRequest(BaseModel):
+    email: str
+    otp: str
+
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+class SendVerificationRequest(BaseModel):
+    email: EmailStr
+
+
+class UserResponse(BaseModel):
+    id: str
+    name: str
+    email: str
+
+
+class LoginResponseData(BaseModel):
+    access_token: str
+    token_type: str
+    user: UserResponse
+
+
+class BaseResponse(BaseModel):
+    code: int
+    data: Optional[Union[Dict, str, None]] = None

src/auth/service.py

@@ -0,0 +1,156 @@
+import uuid
+from src.auth.utils import (
+    # send_otp_email,
+    verify_password,
+    create_refresh_token,
+    verify_verification_token,
+    create_access_token,
+    hash_password,
+    create_verification_token,
+)
+from src.core.models import Users
+from sqlmodel import Session, select
+from fastapi import HTTPException
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+async def create_user(session: AsyncSession, name: str, email: str, password: str):
+    """Create user without sending email"""
+
+    if not email.lower().endswith("@yuvabe.com"):
+        raise HTTPException(status_code=400, detail="Enter you're Yuvabe email ID")
+
+    user = await session.exec(select(Users).where(Users.email_id == email))
+    existing_user = user.first()
+    if existing_user:
+        raise ValueError("User already exists")
+
+    new_user = Users(
+        user_name=name,
+        email_id=email,
+        password=hash_password(password),
+        is_verified=True,
+    )
+
+    session.add(new_user)
+    await session.commit()
+    await session.refresh(new_user)
+
+    access_token = create_access_token(
+        data={
+            "sub": str(new_user.id),
+            "name": new_user.user_name,
+            "email": new_user.email_id,
+        }
+    )
+
+    refresh_token = create_refresh_token(
+        data={
+            "sub": str(new_user.id),
+            "name": new_user.user_name,
+            "email": new_user.email_id,
+        }
+    )
+
+    return {
+        "message": "User created successfully",
+        "user_id": str(new_user.id),
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+    }
+
+
+# async def send_verification_link(session: Session, email: str):
+#     """Send verification email for an existing user."""
+#     result = await session.exec(select(Users).where(Users.email_id == email))
+#     user = result.first()
+
+#     if not user:
+#         raise HTTPException(status_code=404, detail="User not found")
+
+#     if user.is_verified:
+#         raise HTTPException(status_code=400, detail="User is already verified")
+
+#     # Create a token using existing user ID (opaque token)
+#     token = create_verification_token(str(user.id))
+
+#     try:
+#         send_verification_email(email, token)
+#     except Exception as e:
+#         raise HTTPException(
+#             status_code=500, detail=f"Failed to send verification email: {str(e)}"
+#         )
+
+#     return {
+#         "message": "Verification link sent successfully",
+#         "user_id": str(user.id),
+#         "email": user.email_id,
+#     }
+
+
+async def verify_email(session: Session, token: str):
+    try:
+        user_id = await verify_verification_token(token)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+    user = await session.get(Users, uuid.UUID(user_id))
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    if not user.is_verified:
+        user.is_verified = True
+        await session.commit()
+
+    access_token = create_access_token(
+        data={"sub": str(user.id), "name": user.user_name, "email": user.email_id}
+    )
+
+    refresh_token = create_refresh_token(
+        data={"sub": str(user.id), "name": user.user_name, "email": user.email_id}
+    )
+
+    return {
+        "message": "Email verified successfully!",
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "token_type": "bearer",
+    }
+
+
+async def login_user(session: Session, email: str, password: str):
+
+    if not email.lower().endswith("@yuvabe.com"):
+        raise HTTPException(status_code=400, detail="Enter you're Yuvabe email ID")
+
+    users = await session.exec(select(Users).where(Users.email_id == email))
+    user = users.first()
+
+    if not user:
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+
+    if not verify_password(password, user.password):
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+
+    if not user.is_verified:
+        raise HTTPException(status_code=400, detail="Verify email to login")
+
+    access_token = create_access_token(
+        data={"sub": str(user.id), "name": user.user_name, "email": user.email_id}
+    )
+
+    refresh_token = create_refresh_token(
+        data={"sub": str(user.id), "name": user.user_name, "email": user.email_id}
+    )
+
+    return {
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "token_type": "bearer",
+        "user": {
+            "id": str(user.id),
+            "name": user.user_name,
+            "email": user.email_id,
+            "is_verified": user.is_verified,
+        },
+    }

src/auth/utils.py

@@ -0,0 +1,206 @@
+import json
+import smtplib
+import os
+import uuid
+from email.mime.text import MIMEText
+import logging
+import traceback
+from passlib.context import CryptContext
+from src.core.database import get_async_session
+from sqlmodel.ext.asyncio.session import AsyncSession
+from jose import jwt, JWTError
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from datetime import datetime, timedelta
+from cryptography.fernet import Fernet, InvalidToken
+from fastapi import Depends, HTTPException, status
+from src.core.models import Users
+from src.core.config import settings
+
+
+SECRET_KEY = settings.SECRET_KEY
+ALGORITHM = settings.JWT_ALGORITHM
+ACCESS_TOKEN_EXPIRE_MINUTES = settings.JWT_EXPIRE
+logger = logging.getLogger(__name__)
+
+SMTP_SERVER = settings.EMAIL_SERVER
+SMTP_PORT = settings.EMAIL_PORT
+SMTP_EMAIL = settings.EMAIL_USERNAME
+SMTP_PASSWORD = settings.EMAIL_PASSWORD
+
+FERNET_KEY = settings.FERNET_KEY
+VERIFICATION_BASE_URL = settings.VERIFICATION_BASE_URL
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def hash_password(password: str) -> str:
+    """Encrypt plain password into hashed password"""
+    return pwd_context.hash(password)
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Compare plain password with stored hash"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def create_access_token(data: dict):
+    """Create JWT token with expiry"""
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+# def send_verification_email(to_email: str, token: str):
+#     """Send verification email using smtplib with detailed debug logs."""
+#     subject = f"Verify your {settings.APP_NAME} Account"
+#     verification_link = f"{VERIFICATION_BASE_URL}/auth/verify-email?token={token}"
+
+#     body = f"""
+#     Hi,
+
+#     Please verify your {settings.APP_NAME} account by clicking the link below:
+#     {verification_link}
+
+#     This link will expire in 24 hours.
+
+#     Regards,
+#     {settings.APP_NAME} Team
+#     """
+
+#     msg = MIMEText(body)
+#     msg["Subject"] = subject
+#     msg["From"] = SMTP_EMAIL
+#     msg["To"] = to_email
+
+#     logger.info("🟢 Starting send_verification_email()")
+#     logger.info(f"📨 To: {to_email}")
+#     logger.info(f"📤 SMTP Server: {SMTP_SERVER}:{SMTP_PORT}")
+
+#     try:
+#         logger.info("🔌 Connecting to SMTP server...")
+#         with smtplib.SMTP(SMTP_SERVER, SMTP_PORT, timeout=30) as server:
+#             logger.info("✅ Connected successfully.")
+
+#             logger.info("🔒 Starting TLS...")
+#             server.starttls()
+#             logger.info("✅ TLS secured.")
+
+#             logger.info("🔑 Logging in to SMTP server...")
+#             server.login(SMTP_EMAIL, SMTP_PASSWORD)
+#             logger.info("✅ Logged in successfully.")
+
+#             # Send email
+#             logger.info("📧 Sending email message...")
+#             server.send_message(msg)
+#             logger.info(f"✅ Email successfully sent to {to_email}")
+
+#     except smtplib.SMTPAuthenticationError as e:
+#         logger.error("❌ Authentication failed — check email or app password.")
+#         logger.error(f"Error details: {e}")
+#         logger.error(traceback.format_exc())
+#         raise
+#     except smtplib.SMTPConnectError as e:
+#         logger.error("❌ Could not connect to SMTP server.")
+#         logger.error(f"Error details: {e}")
+#         logger.error(traceback.format_exc())
+#         raise
+#     except smtplib.SMTPRecipientsRefused as e:
+#         logger.error("❌ Recipient address refused.")
+#         logger.error(f"Error details: {e}")
+#         logger.error(traceback.format_exc())
+#         raise
+#     except smtplib.SMTPException as e:
+#         logger.error("❌ General SMTP error occurred.")
+#         logger.error(f"Error details: {e}")
+#         logger.error(traceback.format_exc())
+#         raise
+#     except Exception as e:
+#         logger.error("❌ Unknown error occurred while sending verification email.")
+#         logger.error(f"Error details: {e}")
+#         logger.error(traceback.format_exc())
+#         raise
+
+
+fernet = Fernet(FERNET_KEY.encode())
+
+
+def create_verification_token(user_id: str, expires_in_hours: int = 24) -> str:
+    """Create encrypted token with expiry"""
+    payload = {
+        "sub": user_id,
+        "exp": (datetime.utcnow() + timedelta(hours=expires_in_hours)).timestamp(),
+    }
+    token = fernet.encrypt(json.dumps(payload).encode()).decode()
+    return token
+
+
+async def verify_verification_token(token: str) -> str:
+    """Verify encrypted token and extract user_id"""
+    try:
+        decrypted = fernet.decrypt(token.encode())
+        data = json.loads(decrypted.decode())
+
+        exp = datetime.fromtimestamp(data["exp"])
+        if datetime.utcnow() > exp:
+            raise ValueError("Verification link expired")
+
+        return data["sub"]
+
+    except InvalidToken:
+        raise ValueError("Invalid verification link")
+
+
+bearer_scheme = HTTPBearer()
+
+
+def  get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(bearer_scheme),
+):
+    """Decode JWT token and extract current user ID"""
+    token = credentials.credentials
+
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+
+        if user_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token: Missing user id",
+            )
+        return user_id
+
+    except JWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token",
+        )
+
+
+async def get_current_active_user(
+    session: AsyncSession = Depends(get_async_session),
+    user_id: str = Depends(get_current_user),
+) -> Users:
+    """Return the full user model for the currently authenticated user."""
+    user = await session.get(Users, uuid.UUID(user_id))
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="User not found"
+        )
+    if not user.is_verified:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="User not verified"
+        )
+    return user
+
+
+def create_refresh_token(data: dict, expires_days: int = 7):
+    """Create a long-lived JWT refresh token"""
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(days=expires_days)
+    to_encode.update({"exp": expire, "type": "refresh"})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt

src/chatbot/config.py

@@ -0,0 +1,6 @@
+from pydantic import BaseSettings
+
+class HomeSettings(BaseSettings):
+    FEATURE_ENABLED: bool = True
+
+home_settings = HomeSettings()

src/chatbot/constants.py

@@ -0,0 +1,2 @@
+WELCOME_MESSAGE = "Welcome to Yuvabe's Home Screen"
+EXIT_MESSAGE = "Thank You have a wonderful day"

src/chatbot/embedding.py

@@ -0,0 +1,71 @@
+import os
+import numpy as np
+from typing import List
+import onnxruntime as ort
+from transformers import AutoTokenizer
+from huggingface_hub import hf_hub_download
+
+MODEL_ID = "onnx-community/embeddinggemma-300m-ONNX"
+
+class EmbeddingModel:
+    def __init__(self):
+        print("Loading tokenizer…")
+        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+
+        print("Downloading ONNX model files…")
+
+        self.model_path = hf_hub_download(
+            repo_id=MODEL_ID,
+            filename="onnx/model.onnx"
+        )
+        self.data_path = hf_hub_download(
+            repo_id=MODEL_ID,
+            filename="onnx/model.onnx_data"
+        )
+
+        model_dir = os.path.dirname(self.model_path)
+
+        print("Creating inference session…")
+        self.session = ort.InferenceSession(
+            self.model_path,
+            providers=["CPUExecutionProvider"],
+        )
+
+        self.input_names = [i.name for i in self.session.get_inputs()]
+        self.output_names = [o.name for o in self.session.get_outputs()]
+
+    async def embed_text(self, text: str, max_length=512) -> List[float]:
+
+        encoded = self.tokenizer(
+            text,
+            truncation=True,
+            padding=True,
+            max_length=max_length,
+            return_tensors="np",
+        )
+
+        input_ids = encoded["input_ids"].astype(np.int64)
+        attention_mask = encoded["attention_mask"].astype(np.int64)
+
+        outputs = self.session.run(
+            self.output_names,
+            {
+                self.input_names[0]: input_ids,
+                self.input_names[1]: attention_mask,
+            },
+        )
+        last_hidden = outputs[0]
+
+        mask = attention_mask[..., None]
+        pooled = (last_hidden * mask).sum(axis=1) / mask.sum(axis=1)
+
+        vec = pooled[0]
+
+        norm = np.linalg.norm(vec)
+        if norm > 0:
+            vec = vec / norm
+
+        return vec.tolist()
+
+
+embedding_model = EmbeddingModel()

src/chatbot/models.py

@@ -0,0 +1,36 @@
+import uuid
+from datetime import datetime
+from typing import List
+
+from pgvector.sqlalchemy import Vector
+from sqlalchemy import Column
+from sqlmodel import Field, Relationship, SQLModel, ForeignKey
+
+from sqlalchemy.dialects.postgresql import UUID
+
+
+class KnowledgeBase(SQLModel, table=True):
+    __tablename__ = "knowledge_base"
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    name: str = Field(nullable=False)
+    description: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
+    knowledge_chunk: List["KnowledgeChunk"] = Relationship(
+        back_populates="knowledge_base"
+    )
+
+
+class KnowledgeChunk(SQLModel, table=True):
+    __tablename__ = "knowledge_chunk"
+    id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    kb_id: uuid.UUID = Field(
+        sa_column=Column(UUID(as_uuid=True),
+            ForeignKey("knowledge_base.id", ondelete="CASCADE"),
+            nullable=False
+        )
+    )
+    chunk_index: int
+    chunk_text: str
+    image_url: str | None = Field(default=None)
+    embedding: List[float] = Field(sa_column=Column(Vector(768)))
+    knowledge_base: "KnowledgeBase" = Relationship(back_populates="knowledge_chunk")

src/chatbot/router.py

@@ -0,0 +1,159 @@
+import os
+import shutil
+import tempfile
+from typing import Optional
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from sqlalchemy import text
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from src.core.database import get_async_session
+from .schemas import ManualTextRequest
+from .service import store_manual_text
+from .embedding import embedding_model
+from .schemas import (
+    SemanticSearchRequest,
+    SemanticSearchResult,
+    TokenizeRequest,
+    TokenizeResponse,
+    UploadKBResponse,
+)
+from .service import process_pdf_and_store
+
+router = APIRouter(prefix="/chatbot", tags=["chatbot"])
+
+@router.post("/tokenize", response_model=TokenizeResponse)
+async def tokenize_text(payload: TokenizeRequest):
+    try:
+        encoded = embedding_model.tokenizer(
+            payload.text,
+            return_tensors="np",
+            truncation=True,
+            padding="longest",
+            max_length=512,
+        )
+
+        return TokenizeResponse(
+            input_ids=encoded["input_ids"][0].tolist(),
+            attention_mask=encoded["attention_mask"][0].tolist(),
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/semantic-search", response_model=list[SemanticSearchResult])
+async def semantic_search(
+    payload: SemanticSearchRequest, session: AsyncSession = Depends(get_async_session)
+):
+
+    if len(payload.embedding) == 0:
+        raise HTTPException(status_code=400, detail="Embedding cannot be empty.")
+
+    q_vector = payload.embedding
+    top_k = payload.top_k or 3
+
+    q_vector_str = "[" + ",".join(str(x) for x in q_vector) + "]"
+
+    sql = text(
+        """
+        SELECT id, kb_id, chunk_text,image_url,
+           embedding <#> :query_vec AS score
+        FROM knowledge_chunk
+        ORDER BY embedding <#> :query_vec ASC
+        LIMIT :top_k
+        """
+    )
+
+    result = await session.execute(
+        sql, {"query_vec": q_vector_str, "top_k": top_k}
+    )
+    rows = result.fetchall()
+    
+    return [
+        SemanticSearchResult(
+            chunk_id=str(r.id),
+            kb_id=str(r.kb_id),
+            text=r.chunk_text,
+            image_url=r.image_url,
+            score=float(r.score),
+        )
+        for r in rows
+    ]
+
+# before hitting this endpoint make sure the model.data & model.onnx_data is available on the asset/onnx folder
+# @router.post("/upload-pdf", response_model=UploadKBResponse)
+# async def upload_pdf(
+#     file: UploadFile = File(...),
+#     name: str = Form(...),
+#     description: Optional[str] = Form(None),
+#     session: AsyncSession = Depends(get_async_session),
+# ):
+#     if not file.filename.endswith(".pdf"):
+#         raise HTTPException(
+#             status_code=400, detail="Only PDF files are supported for now."
+#         )
+
+#     tmp_dir = tempfile.mkdtemp()
+#     tmp_path = os.path.join(tmp_dir, file.filename)
+#     try:
+#         with open(tmp_path, "wb") as out_f:
+#             shutil.copyfileobj(file.file, out_f)
+
+#         with open(tmp_path, "rb") as fobj:
+#             result = await process_pdf_and_store(fobj, name, description, session)
+
+#         return UploadKBResponse(
+#             kb_id=result["kb_id"],
+#             name=result["name"],
+#             chunks_stored=result["chunks_stored"],
+#         )
+#     finally:
+#         try:
+#             os.remove(tmp_path)
+#             os.rmdir(tmp_dir)
+#         except Exception:
+#             pass
+
+# @router.post("/manual-add-chunk")
+# async def manual_add_chunk(
+#     payload: ManualTextRequest,
+#     session: AsyncSession = Depends(get_async_session)
+# ):
+#     return await store_manual_text(
+#         kb_id=payload.kb_id,
+#         text=payload.text,
+#         session=session
+#     )
+
+# @router.post("/test-semantic", response_model=list[SemanticSearchResult])
+# async def test_semantic(
+#     query: str,
+#     top_k: int = 3,
+#     session: AsyncSession = Depends(get_async_session)
+# ):
+
+#     embedding = await embedding_model.embed_text(query)
+
+#     q_vec = "[" + ",".join(map(str, embedding)) + "]"
+
+#     sql = text("""
+#         SELECT id, kb_id, chunk_text,
+#                embedding <#> :vec AS score
+#         FROM knowledge_chunk
+#         ORDER BY embedding <#> :vec ASC
+#         LIMIT :k
+#     """)
+
+#     result = await session.execute(sql, {"vec": q_vec, "k": top_k})
+#     rows = result.fetchall()
+
+#     return [
+#         SemanticSearchResult(
+#             chunk_id=str(r.id),
+#             kb_id=str(r.kb_id),
+#             text=r.chunk_text,
+#             score=float(r.score),
+#         )
+#         for r in rows
+#     ]

src/chatbot/schemas.py

@@ -0,0 +1,41 @@
+import uuid
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class UploadKBResponse(BaseModel):
+    kb_id: uuid.UUID
+    name: str
+    chunks_stored: int
+
+
+class UploadKBRequest(BaseModel):
+    name: str
+    description: Optional[str] = None
+
+
+class TokenizeRequest(BaseModel):
+    text: str
+
+
+class TokenizeResponse(BaseModel):
+    input_ids: List[int]
+    attention_mask: List[int]
+
+
+class SemanticSearchRequest(BaseModel):
+    embedding: List[float]
+    top_k: Optional[int] = 3
+
+
+class SemanticSearchResult(BaseModel):
+    chunk_id: str
+    kb_id: str
+    text: str
+    image_url: str | None = None 
+    score: float
+
+class ManualTextRequest(BaseModel):
+    kb_id: uuid.UUID
+    text: str

src/chatbot/service.py

@@ -0,0 +1,71 @@
+import os
+from uuid import UUID
+from sqlmodel.ext.asyncio.session import AsyncSession
+from sqlmodel import select
+from .embedding import embedding_model
+from .models import KnowledgeBase, KnowledgeChunk
+from .utils import (
+    chunk_sentences_with_overlap,
+    extract_text_from_pdf_fileobj,
+    split_into_sentences,
+)
+
+DEFAULT_MAX_WORDS = int(os.getenv("CHUNK_MAX_WORDS", "200"))
+DEFAULT_OVERLAP = int(os.getenv("CHUNK_OVERLAP_WORDS", "40"))
+
+
+async def process_pdf_and_store(
+    fileobj, kb_name: str, kb_description: str | None, session: AsyncSession
+):
+    raw_text = extract_text_from_pdf_fileobj(fileobj)
+
+    sentences = split_into_sentences(raw_text)
+
+    chunks = chunk_sentences_with_overlap(
+        sentences, max_words=DEFAULT_MAX_WORDS, overlap_words=DEFAULT_OVERLAP
+    )
+
+    kb = KnowledgeBase(name=kb_name, description=kb_description)
+    session.add(kb)
+    await session.commit()
+    await session.refresh(kb)
+
+    chunk_objs = []
+    for idx, chunk_text in enumerate(chunks):
+        emb = await embedding_model.embed_text(chunk_text)
+
+        chunk = KnowledgeChunk(
+            kb_id=kb.id, chunk_index=idx, chunk_text=chunk_text, embedding=emb
+        )
+        session.add(chunk)
+        chunk_objs.append(chunk)
+
+    await session.commit()
+
+    return {"kb_id": kb.id, "name": kb_name, "chunks_stored": len(chunk_objs)}
+
+async def store_manual_text(kb_id: UUID, text: str, session: AsyncSession):
+    embedding = await embedding_model.embed_text(text)
+
+    result = await session.execute(
+        select(KnowledgeChunk).where(KnowledgeChunk.kb_id == kb_id)
+    )
+    existing = result.scalars().all()
+    next_index = len(existing)
+
+    new_chunk = KnowledgeChunk(
+        kb_id=kb_id,
+        chunk_index=next_index,
+        chunk_text=text,
+        embedding=embedding
+    )
+
+    session.add(new_chunk)
+    await session.commit()
+
+    return {
+        "kb_id": kb_id,
+        "chunk_index": next_index,
+        "status": "stored",
+        "text": text
+    }

src/chatbot/utils.py

@@ -0,0 +1,57 @@
+import re
+from typing import List
+import PyPDF2
+
+
+def clean_text(text: str) -> str:
+    text = re.sub(r'\s+', ' ', text)
+    text = re.sub(r'\s+([,.!?;:])', r'\1', text)
+    text = re.sub(r'[_\-]{2,}', ' ', text)
+    text = re.sub(r'\.{2,}', '.', text)
+    text = re.sub(r'\s{2,}', ' ', text)
+    return text.strip()
+
+
+def extract_text_from_pdf_fileobj(fileobj) -> str:
+    reader = PyPDF2.PdfReader(fileobj)
+    all_text = []
+    for page in reader.pages:
+        page_text = page.extract_text()
+        if page_text:
+            all_text.append(page_text)
+    return clean_text(" ".join(all_text))
+
+
+def split_into_sentences(text: str) -> List[str]:
+    sentence_endings = re.compile(r'(?<=[.!?])\s+')
+    sentences = sentence_endings.split(text)
+    return [s.strip() for s in sentences if s.strip()]
+
+
+def chunk_sentences_with_overlap(sentences: List[str], max_words: int = 200, overlap_words: int = 40) -> List[str]:
+    chunks = []
+    current = []
+    current_len = 0
+
+    for sentence in sentences:
+        words = sentence.split()
+        wc = len(words)
+
+        if current_len + wc > max_words and current:
+            chunks.append(" ".join(current))
+
+            if overlap_words > 0:
+                last_words = " ".join(" ".join(current).split()[-overlap_words:])
+                current = [last_words] if last_words else []
+                current_len = len(last_words.split())
+            else:
+                current = []
+                current_len = 0
+
+        current.append(sentence)
+        current_len += wc
+
+    if current:
+        chunks.append(" ".join(current))
+
+    return chunks

src/core/__init__.py

@@ -0,0 +1,9 @@
+from src.auth import models as auth_models
+from src.chatbot import models as chatbot_models
+from src.core import models as core_models
+from src.feed import models as feed_models
+from src.home import models as home_models
+from src.profile import models as profile_models
+from src.wellbeing import models as wellbeing_models
+from src.payslip import models as payslip_models
+from src.journaling import models as journaling_models

src/core/config.py

@@ -0,0 +1,79 @@
+from typing import Optional
+from pydantic import PostgresDsn, computed_field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class SMTPConfig(BaseSettings):
+    server: str
+    port: int
+    username: str
+    password: str
+
+
+class Settings(BaseSettings):
+
+    JWT_ALGORITHM: str
+    JWT_EXPIRE: int
+    SECRET_KEY: str
+
+    POSTGRES_USER: str
+    POSTGRES_PASSWORD: str
+    POSTGRES_HOST: str
+    POSTGRES_DB: str
+
+    APP_NAME: str
+    ENV: str
+    DEBUG: bool
+    PORT: int
+
+    EMAIL_SERVER: str
+    EMAIL_PORT: int
+    EMAIL_USERNAME: str
+    EMAIL_PASSWORD: str
+
+    FERNET_KEY: str
+    VERIFICATION_BASE_URL: str
+
+    GOOGLE_CLIENT_ID: str
+    GOOGLE_CLIENT_SECRET: str
+    GOOGLE_REDIRECT_URI: str
+
+    FCM_SERVER_KEY: Optional[str] = None
+    SICK_LEAVE_LIMIT: int = 10
+    CASUAL_LEAVE_LIMIT: int = 10
+
+    AUTH_BASE: str = "https://accounts.google.com/o/oauth2/v2/auth"
+    TOKEN_URL: str = "https://oauth2.googleapis.com/token"
+    GMAIL_SEND_SCOPE: str = "https://www.googleapis.com/auth/gmail.send"
+
+    FIREBASE_TYPE: str
+    FIREBASE_PROJECT_ID: str
+    FIREBASE_PRIVATE_KEY_ID: str
+    FIREBASE_PRIVATE_KEY: str
+    FIREBASE_CLIENT_EMAIL: str
+    FIREBASE_CLIENT_ID: str
+    FIREBASE_AUTH_URI: str
+    FIREBASE_TOKEN_URI: str
+    FIREBASE_AUTH_PROVIDER_X509_CERT_URL: str
+    FIREBASE_CLIENT_X509_CERT_URL: str
+    FIREBASE_UNIVERSE_DOMAIN: str
+
+
+    @computed_field
+    @property
+    def DATABASE_URL(self) -> PostgresDsn:
+        """Sync DB URL"""
+        return f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}/{self.POSTGRES_DB}"
+
+    @computed_field
+    @property
+    def ASYNC_DATABASE_URL(self) -> PostgresDsn:
+        """Async DB URL"""
+        return f"postgresql+asyncpg://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}/{self.POSTGRES_DB}"
+
+    model_config = SettingsConfigDict(
+        env_file=".env", case_sensitive=False, env_file_encoding="utf-8"
+    )
+
+
+settings = Settings()