update

.dockerignore

@@ -0,0 +1,39 @@
+# Version control
+.git
+.gitignore
+
+# Environment files
+.env
+.venv
+env/
+venv/
+ENV/
+
+# Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Build directories
+build/
+dist/
+*.egg-info/
+
+# Data directories that should be mounted as volumes
+temp/
+uploads/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+Thumbs.db

.gitignore

@@ -0,0 +1,44 @@
+# Flask specific
+instance/*
+!instance/.gitignore
+.webassets-cache
+.env
+
+# Python related
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+
+# IDE specific (common ones)
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Local development
+*.log
+.env.local
+.env.*.local

Dockerfile

@@ -0,0 +1,60 @@
+# Use Python 3.12 as the base image
+FROM python:3.12-slim
+
+# Set working directory in the container
+WORKDIR /app
+
+# Install system dependencies including Tesseract OCR
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    python3-dev \
+    tesseract-ocr \
+    libtesseract-dev \
+    tesseract-ocr-eng \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user and set ownership
+RUN useradd -m -u 1000 appuser && \
+    chown -R appuser:appuser /app
+
+# Copy requirements first to leverage Docker cache
+COPY pyproject.toml .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir .
+
+# Copy the rest of the application
+COPY . .
+
+# Create ALL needed directories with proper permissions
+RUN mkdir -p temp uploads \
+    /app/.cache \
+    /app/nltk_data \
+    /app/app/routers/temp \
+    /app/app/config/temp && \
+    chown -R appuser:appuser /app && \
+    chmod -R 777 temp uploads /app/.cache /app/nltk_data /app/app/routers/temp /app/app/config/temp
+
+# Set environment variables for cache directories and Tesseract
+ENV HF_HOME=/app/.cache/huggingface \
+    TRANSFORMERS_CACHE=/app/.cache/huggingface/transformers \
+    PYTORCH_PRETRAINED_BERT_CACHE=/app/.cache/torch \
+    NLTK_DATA=/app/nltk_data \
+    XDG_CACHE_HOME=/app/.cache \
+    TESSDATA_PREFIX=/usr/share/tesseract-ocr/5/tessdata \
+    TESSERACT_CMD=/usr/bin/tesseract \
+    PATH=/usr/bin:$PATH
+
+# Verify Tesseract installation
+RUN tesseract --version
+
+# Switch to non-root user
+USER appuser
+
+# Expose the port that Hugging Face Spaces expects
+EXPOSE 7860
+
+# Command to run the application using Uvicorn on port 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,11 +1,10 @@
 ---
-title: Derm Ai
-emoji: 🌍
-colorFrom: blue
-colorTo: green
+title: DermAI
+emoji: 🐳
+colorFrom: gray
+colorTo: blue
 sdk: docker
+sdk_version: "1.0.0"
+app_file: app.py
 pinned: false
-license: afl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---

app.py

@@ -0,0 +1,5 @@
+import uvicorn
+from app.main import app
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=5000, reload=True)

app/__init__.py

@@ -0,0 +1,8 @@
+# app/__init__.py
+from app.main import app
+
+__all__ = [
+    "app",
+]
+
+

app/config/__init__.py

@@ -0,0 +1,3 @@
+from app.config.config import Config
+
+config = Config()

app/config/config.py

@@ -0,0 +1,7 @@
+import os
+
+class Config:
+    JWT_SECRET_KEY = os.getenv('JWT_SECRET_KEY')
+    JWT_ACCESS_TOKEN_EXPIRES = int(os.getenv('JWT_ACCESS_TOKEN_EXPIRES'))
+    CORS_ORIGINS = ["http://localhost:3000"]
+    UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'temp')

app/database/__init__.py

@@ -0,0 +1,4 @@
+from app.database.db import get_db, db
+from app.database.database_query import DatabaseQuery
+
+__all__ = ["get_db", "db", "DatabaseQuery"]

app/database/database_query.py

@@ -0,0 +1,684 @@
+from app.database.db import db
+import re
+from bson import ObjectId
+from datetime import datetime, timezone, timedelta
+from pymongo import DESCENDING
+from typing import Optional
+
+
+class DatabaseQuery:
+    def __init__(self):
+        pass
+
+    def create_chat_session(self, chat_session):
+        try:
+            db.chat_sessions.insert_one(chat_session)
+        except Exception as e:
+            raise Exception(f"Error creating chat session: {str(e)}")
+
+    def get_user_chat_sessions(self, user_id):
+        try:
+            sessions = list(db.chat_sessions.find(
+                {"user_id": user_id},
+                {"_id": 0}
+            ).sort("last_accessed", -1))
+            return sessions
+        except Exception as e:
+            raise Exception(f"Error retrieving user chat sessions: {str(e)}")
+
+    def create_chat(self, chat_data):
+        try:
+            db.chats.insert_one(chat_data)
+            return True
+        except Exception as e:
+            raise Exception(f"Error creating chat: {str(e)}")
+
+    def update_last_accessed_time(self, session_id):
+        try:
+            db.chat_sessions.update_one(
+                {"session_id": session_id},
+                {"$set": {"last_accessed": datetime.now(timezone.utc)}}
+            )
+        except Exception as e:
+            raise Exception(f"Error updating last accessed time: {str(e)}")
+
+    def get_session_chats(self, session_id, user_id):
+        try:
+            chats = list(db.chats.find(
+                {"session_id": session_id, "user_id": user_id},
+                {"_id": 0}
+            ).sort("timestamp", 1))
+            return chats
+        except Exception as e:
+            raise Exception(f"Error retrieving session chats: {str(e)}")
+
+    def get_user_by_identifier(self, identifier):
+        try:
+            user = db.users.find_one({'$or': [{'username': identifier}, {'email': identifier}]})
+            return user
+        except Exception as e:
+            raise Exception(f"Error retrieving user by identifier: {str(e)}")
+
+    def add_token_to_blacklist(self, jti):
+        try:
+           db.blacklist.insert_one({'jti': jti})
+        except Exception as e:
+            raise Exception(f"Error adding token to blacklist: {str(e)}")
+
+
+    def create_indexes(self):
+        try:
+           db.chat_sessions.create_index([("user_id", 1), ("last_accessed", -1)])
+           db.chat_sessions.create_index([("session_id", 1)])
+           db.chats.create_index([("session_id", 1), ("timestamp", 1)])
+           db.chats.create_index([("user_id", 1)])
+        except Exception as e:
+            raise Exception(f"Error creating indexes: {str(e)}")
+
+    def check_chat_session(self, session_id):
+        try:
+            chat_session = db.chat_sessions.find_one({'session_id': session_id})
+            return chat_session is not None
+        except Exception as e:
+            raise Exception(f"Error checking chat session: {str(e)}")
+
+    def get_user_profile(self, username):
+        try:
+            user = db.users.find_one({'username': username}, {'password': 0})
+            return user
+        except Exception as e:
+            raise Exception(f"Error getting user profile: {str(e)}")
+
+    def update_user_profile(self, username, update_fields):
+        try:
+            result = db.users.update_one(
+                {'username': username},
+                {'$set': update_fields}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            raise Exception(f"Error updating user profile: {str(e)}")
+
+    def delete_user_account(self, username):
+        try:
+            result = db.users.delete_one({'username': username})
+            return result.deleted_count > 0
+        except Exception as e:
+            raise Exception(f"Error deleting user account: {str(e)}")
+
+    def is_username_or_email_exists(self, username, email):
+        try:
+            user = db.users.find_one({'$or': [{'username': username}, {'email': email}]})
+            return user is not None
+        except Exception as e:
+            raise Exception(f"Error checking if username or email exists: {str(e)}")
+
+    def create_or_update_temp_user(self, username, email, temp_user_data):
+        try:
+            db.temp_users.update_one(
+                {'$or': [{'username': username}, {'email': email}]},
+                {'$set': temp_user_data},
+                upsert=True
+            )
+        except Exception as e:
+            raise Exception(f"Error creating/updating temp user: {str(e)}")
+
+    def get_temp_user_by_username(self, username):
+        try:
+            temp_user = db.temp_users.find_one({'username': username})
+            return temp_user
+        except Exception as e:
+            raise Exception(f"Error retrieving temp user by username: {str(e)}")
+
+    def delete_temp_user(self, username):
+        try:
+            db.temp_users.delete_one({'username': username})
+        except Exception as e:
+            raise Exception(f"Error deleting temp user: {str(e)}")
+
+    def create_user_from_data(self, user_data):
+        try:
+            db.users.insert_one(user_data)
+            return user_data
+        except Exception as e:
+            raise Exception(f"Error creating user from data: {str(e)}")
+
+    def create_user(self, username, email, hashed_password, name, age, created_at,
+                    is_verified=False, verification_code=None, code_expiration=None):
+        try:
+            new_user = {
+                'username': username,
+                'email': email,
+                'password': hashed_password,
+                'name': name,
+                'age': age,
+                'created_at': created_at,
+                'is_verified': is_verified
+            }
+            if verification_code and code_expiration:
+                new_user['verification_code'] = verification_code
+                new_user['code_expiration'] = code_expiration
+
+            db.users.insert_one(new_user)
+            return new_user
+        except Exception as e:
+            raise Exception(f"Error creating user: {str(e)}")
+
+    def get_user_by_username(self, username):
+        try:
+            user = db.users.find_one({'username': username})
+            return user
+        except Exception as e:
+            raise Exception(f"Error retrieving user by username: {str(e)}")
+
+    def verify_user_email(self, username):
+        try:
+            result = db.users.update_one(
+                {'username': username},
+                {'$set': {'is_verified': True}, '$unset': {'verification_code': '', 'code_expiration': ''}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            raise Exception(f"Error verifying user email: {str(e)}")
+
+    def update_verification_code(self, username, verification_code, code_expiration):
+        try:
+            result = db.users.update_one(
+                {'username': username},
+                {'$set': {'verification_code': verification_code, 'code_expiration': code_expiration}}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            raise Exception(f"Error updating verification code: {str(e)}")
+
+    def is_valid_email(self, email):
+        try:
+            email_regex = r'^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}\b'
+            return re.match(email_regex, email) is not None
+        except Exception as e:
+            raise Exception(f"Error validating email: {str(e)}")
+
+    def add_or_update_location(self, username, location):
+        try:
+            db.locations.update_one(
+                {'username': username},
+                {'$set': {'location': location, 'updated_at': datetime.now(timezone.utc)}},
+                upsert=True
+            )
+        except Exception as e:
+            raise Exception(f"Error adding/updating location: {str(e)}")
+
+    def get_location(self, username):
+        try:
+            location = db.locations.find_one({'username': username})
+            return location
+        except Exception as e:
+            raise Exception(f"Error retrieving location: {str(e)}")
+
+    def submit_questionnaire(self, user_id, answers):
+        try:
+            questionnaire_data = {
+                'user_id': user_id,
+                'answers': answers,
+                'created_at': datetime.now(timezone.utc),
+                'updated_at': datetime.now(timezone.utc)
+            }
+            result = db.questionnaires.insert_one(questionnaire_data)
+            return str(result.inserted_id)
+        except Exception as e:
+            raise Exception(f"Error submitting questionnaire: {str(e)}")
+
+    def get_latest_questionnaire(self, user_id):
+        try:
+            questionnaire = db.questionnaires.find_one(
+                {'user_id': user_id},
+                sort=[('created_at', -1)]
+            )
+            if questionnaire:
+                questionnaire['_id'] = str(questionnaire['_id'])
+            return questionnaire
+        except Exception as e:
+            raise Exception(f"Error getting latest questionnaire: {str(e)}")
+
+    def update_questionnaire(self, questionnaire_id, user_id, answers):
+        try:
+            result = db.questionnaires.update_one(
+                {'_id': ObjectId(questionnaire_id), 'user_id': user_id},
+                {
+                    '$set': {
+                        'answers': answers,
+                        'updated_at': datetime.now(timezone.utc)
+                    }
+                }
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            raise Exception(f"Error updating questionnaire: {str(e)}")
+
+    def delete_questionnaire(self, questionnaire_id, user_id):
+        try:
+            result = db.questionnaires.delete_one(
+                {'_id': ObjectId(questionnaire_id), 'user_id': user_id}
+            )
+            return result.deleted_count > 0
+        except Exception as e:
+            raise Exception(f"Error deleting questionnaire: {str(e)}")
+
+
+    def count_answered_questions(self, username):
+        try:
+            answered_count = db.questions.count_documents({
+                'username': username,
+                'answer': {'$ne': None}
+            })
+            return answered_count
+        except Exception as e:
+            raise Exception(f"Error counting answered questions: {str(e)}")
+
+    def get_user_preferences(self, username):
+        try:
+            user_preferences = db.preferences.find_one({'username': username})
+            if not user_preferences:
+                return {
+                    'keywords': False,
+                    'references': False,
+                    'websearch': False,
+                    'personalized_recommendations': False,
+                    'environmental_recommendations': False
+                }
+            return {
+                'keywords': user_preferences.get('keywords', False),
+                'references': user_preferences.get('references', False),
+                'websearch': user_preferences.get('websearch', False),
+                'personalized_recommendations': user_preferences.get('personalized_recommendations', False),
+                'environmental_recommendations': user_preferences.get('environmental_recommendations', False)
+            }
+        except Exception as e:
+            raise Exception(f"Error getting user preferences: {str(e)}")
+
+    def set_user_preferences(self, username, preferences):
+        try:
+            preferences_data = {
+                'username': username,
+                'keywords': bool(preferences.get('keywords', False)),
+                'references': bool(preferences.get('references', False)),
+                'websearch': bool(preferences.get('websearch', False)),
+                'personalized_recommendations': bool(preferences.get('personalized_recommendations', False)),
+                'environmental_recommendations': bool(preferences.get('environmental_recommendations', False)),
+                'updated_at': datetime.now(timezone.utc)
+            }
+            result = db.preferences.update_one(
+                {'username': username},
+                {'$set': preferences_data},
+                upsert=True
+            )
+            return preferences_data
+        except Exception as e:
+            raise Exception(f"Error setting user preferences: {str(e)}")
+
+    def get_user_theme(self, username):
+        try:
+            user_theme = db.user_themes.find_one({'username': username})
+            if not user_theme:
+                return 'light'
+            return user_theme.get('theme', 'light')
+        except Exception as e:
+            raise Exception(f"Error getting user theme: {str(e)}")
+
+    def set_user_theme(self, username, theme):
+        try:
+            theme_data = {
+                'username': username,
+                'theme': "dark" if theme else "light",
+                'updated_at': datetime.now(timezone.utc)
+            }
+            db.user_themes.update_one(
+                {'username': username},
+                {'$set': theme_data},
+                upsert=True
+            )
+            return theme_data
+        except Exception as e:
+            raise Exception(f"Error setting user theme: {str(e)}")
+
+
+    def verify_session(self, session_id, user_id):
+        try:
+            session = db.chat_sessions.find_one({
+                "session_id": session_id,
+                "user_id": user_id
+            })
+            return session is not None
+        except Exception as e:
+            raise Exception(f"Error verifying session: {str(e)}")
+
+    def update_chat_session_title(self, session_id, new_title):
+        try:
+            result = db.chat_sessions.update_one(
+                {"session_id": session_id},
+                {"$set": {"title": new_title}}
+            )
+            if result.matched_count == 0:
+                raise Exception("Chat session not found")
+            return result.modified_count > 0
+        except Exception as e:
+            raise Exception(f"Error updating chat session title: {str(e)}")
+
+    def delete_chat_session(self, session_id, user_id):
+        try:
+            session_result = db.chat_sessions.delete_one({
+                "session_id": session_id,
+                "user_id": user_id
+            })
+            chats_result = db.chats.delete_many({
+                "session_id": session_id,
+                "user_id": user_id
+            })
+
+            return {
+                "session_deleted": session_result.deleted_count > 0,
+                "chats_deleted": chats_result.deleted_count
+            }
+        except Exception as e:
+            raise Exception(f"Error deleting chat session and chats: {str(e)}")
+
+    def delete_all_user_sessions_and_chats(self, user_id):
+        try:
+            chats_result = db.chats.delete_many({"user_id": user_id})
+            sessions_result = db.chat_sessions.delete_many({"user_id": user_id})
+            return {
+                "deleted_chats": chats_result.deleted_count,
+                "deleted_sessions": sessions_result.deleted_count
+            }
+        except Exception as e:
+            raise Exception(f"Error deleting user sessions and chats: {str(e)}")
+
+    def get_all_user_chats(self, user_id):
+        try:
+            sessions = list(db.chat_sessions.find(
+                {"user_id": user_id},
+                {"_id": 0}
+            ).sort("last_accessed", -1))
+            all_chats = []
+            for session in sessions:
+                session_chats = list(db.chats.find(
+                    {"session_id": session["session_id"], "user_id": user_id},
+                    {"_id": 0}
+                ).sort("timestamp", 1))
+
+                all_chats.append({
+                    "session_id": session["session_id"],
+                    "title": session.get("title", "New Chat"),
+                    "created_at": session.get("created_at"),
+                    "last_accessed": session.get("last_accessed"),
+                    "chats": session_chats
+                })
+
+            return all_chats
+        except Exception as e:
+            raise Exception(f"Error retrieving all user chats: {str(e)}")
+
+    def store_reset_token(self, email, token, expiration):
+        try:
+            db.password_resets.update_one(
+                {'email': email},
+                {
+                    '$set': {
+                        'token': token,
+                        'expiration': expiration
+                    }
+                },
+                upsert=True
+            )
+        except Exception as e:
+            raise Exception(f"Error storing reset token: {str(e)}")
+
+    def verify_reset_token(self, token):
+        try:
+            reset_info = db.password_resets.find_one({
+                'token': token,
+                'expiration': {'$gt': datetime.now(timezone.utc)}
+            })
+            return reset_info
+        except Exception as e:
+            raise Exception(f"Error verifying reset token: {str(e)}")
+
+    def update_password(self, email, hashed_password):
+        try:
+            db.users.update_one(
+                {'email': email},
+                {'$set': {'password': hashed_password}}
+            )
+        except Exception as e:
+            raise Exception(f"Error updating password: {str(e)}")
+
+    def delete_reset_token(self, token):
+        try:
+            db.password_resets.delete_one({'token': token})
+        except Exception as e:
+            raise Exception(f"Error deleting reset token: {str(e)}")
+
+    def delete_account_permanently(self, username):
+        try:
+            chat_deletion_result = self.delete_all_user_sessions_and_chats(username)
+            preferences_result = db.preferences.delete_one({'username': username})
+            theme_result = db.user_themes.delete_one({'username': username})
+            location_result = db.locations.delete_one({'username': username})
+            questionnaire_result = db.questionnaires.delete_many({'user_id': username})
+            user_result = db.users.delete_one({'username': username})
+
+            return {
+                'success': True,
+                'deleted_data': {
+                    'chats': chat_deletion_result['deleted_chats'],
+                    'chat_sessions': chat_deletion_result['deleted_sessions'],
+                    'preferences': preferences_result.deleted_count,
+                    'theme': theme_result.deleted_count,
+                    'location': location_result.deleted_count,
+                    'questionnaires': questionnaire_result.deleted_count,
+                    'user_account': user_result.deleted_count
+                }
+            }
+        except Exception as e:
+            raise Exception(f"Error deleting account permanently: {str(e)}")
+
+    def store_reset_token(self, email, token, expiration):
+        try:
+            db.password_resets.update_one(
+                {'email': email},
+                {
+                    '$set': {
+                        'token': token,
+                        'expiration': expiration
+                    }
+                },
+                upsert=True
+            )
+        except Exception as e:
+            raise Exception(f"Error storing reset token: {str(e)}")
+
+    def verify_reset_token(self, token):
+        try:
+            reset_info = db.password_resets.find_one({
+                'token': token,
+                'expiration': {'$gt': datetime.now(timezone.utc)}
+            })
+            return reset_info
+        except Exception as e:
+            raise Exception(f"Error verifying reset token: {str(e)}")
+
+    def update_password(self, email, new_password):
+        try:
+            db.users.update_one(
+                {'email': email},
+                {'$set': {'password': new_password}}
+            )
+        except Exception as e:
+            raise Exception(f"Error updating password: {str(e)}")
+
+    def get_user_language(self, user_id):
+        try:
+            language = db.languages.find_one({'user_id': user_id})
+            return language.get('language') if language else None
+        except Exception as e:
+            raise Exception(f"Error retrieving user language: {str(e)}")
+
+    def set_user_language(self, user_id, language):
+        try:
+            language_data = {
+                'user_id': user_id,
+                'language': language,
+                'updated_at': datetime.now(timezone.utc)
+            }
+            result = db.languages.update_one(
+                {'user_id': user_id},
+                {'$set': language_data},
+                upsert=True
+            )
+            return language_data
+        except Exception as e:
+            raise Exception(f"Error setting user language: {str(e)}")
+
+    def delete_user_language(self, user_id):
+        try:
+            result = db.languages.delete_one({'user_id': user_id})
+            return result.deleted_count > 0
+        except Exception as e:
+            raise Exception(f"Error deleting user language: {str(e)}")
+
+    def get_today_schedule(self, user_id):
+        try:
+            # Get today's date at midnight UTC
+            today = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
+            tomorrow = today.replace(hour=23, minute=59, second=59)
+
+            schedule = db.skin_schedules.find_one({
+                "user_id": user_id,
+                "created_at": {
+                    "$gte": today,
+                    "$lte": tomorrow
+                }
+            })
+            return schedule
+        except Exception as e:
+            raise Exception(f"Error retrieving today's schedule: {str(e)}")
+
+    def save_schedule(self, user_id, schedule_data):
+        try:
+            existing_schedule = self.get_today_schedule(user_id)
+            if existing_schedule:
+                return str(existing_schedule["_id"])
+
+            schedule = {
+                "user_id": user_id,
+                "schedule_data": schedule_data,
+                "created_at": datetime.now(timezone.utc)
+            }
+            result = db.skin_schedules.insert_one(schedule)
+            return str(result.inserted_id)
+        except Exception as e:
+            raise Exception(f"Error saving schedule: {str(e)}")
+
+    def get_last_seven_days_schedules(self, user_id):
+        try:
+            seven_days_ago = datetime.now(timezone.utc) - timedelta(days=7)
+            schedules = db.skin_schedules.find({
+                "user_id": user_id,
+                "created_at": {"$gte": seven_days_ago}
+            }).sort("created_at", -1)
+            return list(schedules)
+        except Exception as e:
+            raise Exception(f"Error fetching last 7 days schedules: {str(e)}")
+
+    def save_rag_interaction(self, user_id: str, session_id: str, context: str, query: str,
+                             response: str, rag_start_time: datetime, rag_end_time: datetime):
+        try:
+            interaction = {
+                "interaction_id": str(ObjectId()),
+                "user_id": user_id,
+                "session_id": session_id,
+                "context": context,
+                "query": query,
+                "response": response,
+                "rag_start_time": rag_start_time.astimezone(timezone.utc),
+                "rag_end_time": rag_end_time.astimezone(timezone.utc),
+                "created_at": datetime.now(timezone.utc)
+            }
+
+            result = db.rag_interactions.insert_one(interaction)
+            return interaction["interaction_id"]
+
+        except Exception as e:
+            raise Exception(f"Error saving RAG interaction: {str(e)}")
+
+    def get_rag_interactions(
+            self,
+            user_id: Optional[str] = None,
+            page: int = 1,
+            page_size: int = 5
+    ) -> dict:
+        try:
+            query_filter = {}
+            if user_id:
+                query_filter["user_id"] = user_id
+
+            skip = (page - 1) * page_size
+            total = db.rag_interactions.count_documents(query_filter)
+            interactions = db.rag_interactions.find(
+                query_filter,
+                {"_id": 0}
+            ).sort("created_at", DESCENDING).skip(skip).limit(page_size)
+
+            result_list = []
+            for interaction in interactions:
+                interaction["rag_start_time"] = interaction["rag_start_time"].isoformat()
+                interaction["rag_end_time"] = interaction["rag_end_time"].isoformat()
+                interaction["created_at"] = interaction["created_at"].isoformat()
+                result_list.append(interaction)
+
+            return {
+                "total_interactions": total,
+                "page": page,
+                "page_size": page_size,
+                "total_pages": (total + page_size - 1) // page_size,
+                "results": result_list
+            }
+        except Exception as e:
+            raise Exception(f"Error retrieving RAG interactions: {str(e)}")
+        
+    def log_image_upload(self, user_id):
+        """Log an image upload for a user"""
+        try:
+            timestamp = datetime.now(timezone.utc)  # This is timezone-aware
+            db.image_uploads.insert_one({
+                "user_id": user_id,
+                "timestamp": timestamp
+            })
+            return True
+        except Exception as e:
+            raise Exception(f"Error logging image upload: {str(e)}")
+
+    def get_user_daily_uploads(self, user_id):
+        """Get number of images uploaded by user in the last 24 hours"""
+        try:
+            now = datetime.now(timezone.utc)
+            yesterday = now - timedelta(days=1)
+
+            count = db.image_uploads.count_documents({
+                "user_id": user_id,
+                "timestamp": {"$gte": yesterday}
+            })
+            return count
+        except Exception as e:
+            raise Exception(f"Error retrieving user daily uploads: {str(e)}")
+
+    def get_user_last_upload_time(self, user_id):
+        """Get the timestamp of user's most recent image upload"""
+        try:
+            last_upload = db.image_uploads.find_one(
+                {"user_id": user_id},
+                sort=[("timestamp", DESCENDING)]
+            )
+            return last_upload["timestamp"] if last_upload else None
+        except Exception as e:
+            raise Exception(f"Error retrieving last upload time: {str(e)}")

app/database/db.py

@@ -0,0 +1,21 @@
+import os
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+
+
+uri = os.getenv('MONGO_URI')
+
+mongo_uri = os.getenv('MONGO_URI')
+if not mongo_uri:
+    raise ValueError("MONGO_URI environment variable is not set")
+
+
+def get_db():
+    client = MongoClient(uri, server_api=ServerApi('1'))
+    try:
+        client.admin.command('ping')
+    except Exception as e:
+        print(e)
+    return client.get_database("dermai")
+
+db = get_db()

app/main.py

@@ -0,0 +1,40 @@
+# app/main.py
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+import os
+from dotenv import load_dotenv
+from app.config.config import Config
+from app.routers import admin, auth, chat, location, preferences, profile, questionnaire, language, chat_session
+
+load_dotenv()
+
+app = FastAPI(title="Skin AI API")
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files for uploads
+os.makedirs(Config.UPLOAD_FOLDER, exist_ok=True)
+app.mount("/uploads", StaticFiles(directory=Config.UPLOAD_FOLDER), name="uploads")
+
+# Register routers
+app.include_router(admin.router, prefix="/api", tags=["admin"])
+app.include_router(auth.router, prefix="/api", tags=["auth"])
+app.include_router(chat.router, prefix="/api", tags=["chat"])
+app.include_router(location.router, prefix="/api", tags=["location"])
+app.include_router(preferences.router, prefix="/api", tags=["preferences"])
+app.include_router(profile.router, prefix="/api", tags=["profile"])
+app.include_router(questionnaire.router, prefix="/api", tags=["questionnaire"])
+app.include_router(language.router, prefix="/api", tags=["language"])
+app.include_router(chat_session.router, prefix="/api", tags=["chat_session"])
+
+@app.get("/")
+async def root():
+    return {"message": "API is running", "status": "healthy"}

app/middleware/auth.py

@@ -0,0 +1,47 @@
+# app/middleware/auth.py
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+import jwt
+from datetime import datetime, timedelta
+import os
+
+security = HTTPBearer()
+JWT_SECRET_KEY = os.getenv('JWT_SECRET_KEY')
+JWT_ACCESS_TOKEN_EXPIRES = int(os.getenv('JWT_ACCESS_TOKEN_EXPIRES'))
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(seconds=JWT_ACCESS_TOKEN_EXPIRES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, JWT_SECRET_KEY, algorithm="HS256")
+    return encoded_jwt
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    try:
+        payload = jwt.decode(credentials.credentials, JWT_SECRET_KEY, algorithms=["HS256"])
+        username: str = payload.get("sub")
+        if username is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid authentication credentials",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        return username
+    except jwt.PyJWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+def get_current_user(username: str = Depends(verify_token)):
+    return username
+
+# For optional JWT authentication (some endpoints allow unauthenticated access)
+def get_optional_user(authorization: HTTPAuthorizationCredentials = Depends(security)):
+    try:
+        payload = jwt.decode(authorization.credentials, JWT_SECRET_KEY, algorithms=["HS256"])
+        username: str = payload.get("sub")
+        return username
+    except:
+        return None

app/routers/admin.py

@@ -0,0 +1,96 @@
+# app/routers/admin.py
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from typing import List
+import os
+from app.database.database_query import DatabaseQuery
+from app.services.vector_database_search import VectorDatabaseSearch
+from app.middleware.auth import get_current_user
+from pydantic import BaseModel
+
+router = APIRouter()
+vector_db = VectorDatabaseSearch()
+query = DatabaseQuery()
+TEMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'temp')
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+class SearchQuery(BaseModel):
+    query: str
+    k: int = 5
+
+@router.get('/books')
+async def get_books(username: str = Depends(get_current_user)):
+    try:
+        book_info = vector_db.get_book_info()
+        return {
+            'status': 'success',
+            'data': book_info
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/books', status_code=201)
+async def add_books(files: List[UploadFile] = File(...), username: str = Depends(get_current_user)):
+    try:
+        pdf_paths = []
+        for file in files:
+            if file.filename.endswith('.pdf'):
+                safe_filename = os.path.basename(file.filename)
+                temp_path = os.path.join(TEMP_DIR, safe_filename)
+                
+                with open(temp_path, "wb") as buffer:
+                    content = await file.read()
+                    buffer.write(content)
+                
+                pdf_paths.append(temp_path)
+
+        if not pdf_paths:
+            raise HTTPException(status_code=400, detail="No valid PDF files provided")
+
+        success_count = 0
+        for pdf_path in pdf_paths:
+            if vector_db.add_pdf(pdf_path):
+                success_count += 1
+
+        # Clean up temporary files
+        for path in pdf_paths:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception:
+                pass
+
+        return {
+            'status': 'success',
+            'message': f'Successfully added {success_count} of {len(pdf_paths)} books'
+        }
+
+    except Exception as e:
+        # Clean up temporary files in case of error
+        for path in pdf_paths:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except:
+                pass
+        
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/search')
+async def search_books(search_data: SearchQuery, username: str = Depends(get_current_user)):
+    try:
+        query_text = search_data.query
+        k = search_data.k
+
+        results = vector_db.search(
+            query=query_text,
+            top_k=k
+        )
+
+        return {
+            'status': 'success',
+            'data': results
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/auth.py

@@ -0,0 +1,291 @@
+# app/routers/auth.py
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel, EmailStr
+from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime, timedelta
+import random
+import string
+from sendgrid import SendGridAPIClient
+from sendgrid.helpers.mail import Mail
+import os
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import create_access_token, get_current_user
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+SENDGRID_API_KEY = os.getenv("SENDGRID_API_KEY")
+FROM_EMAIL = os.getenv("FROM_EMAIL")
+
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class LoginRequest(BaseModel):
+    identifier: str
+    password: str
+
+class LoginResponse(BaseModel):
+    message: str
+    token: str
+
+class RegisterRequest(BaseModel):
+    username: str
+    email: EmailStr
+    password: str
+    name: str
+    age: int
+
+class VerifyEmailRequest(BaseModel):
+    username: str
+    code: str
+
+class ResendCodeRequest(BaseModel):
+    username: str
+
+class ForgotPasswordRequest(BaseModel):
+    email: EmailStr
+
+class ResetPasswordRequest(BaseModel):
+    token: str
+    password: str
+
+class ChatSessionCheck(BaseModel):
+    session_id: str
+
+@router.post('/login', response_model=LoginResponse)
+async def login(login_data: LoginRequest):
+    try:
+        identifier = login_data.identifier
+        password = login_data.password
+
+        user = query.get_user_by_identifier(identifier)
+        if user:
+            if not user.get('is_verified'):
+                raise HTTPException(status_code=401, detail="Please verify your email before logging in")
+
+            if check_password_hash(user['password'], password):
+                access_token = create_access_token({"sub": user['username']})
+                return {"message": "Login successful", "token": access_token}
+
+        raise HTTPException(status_code=401, detail="Invalid username/email or password")
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/register', status_code=201)
+async def register(register_data: RegisterRequest):
+    try:
+        username = register_data.username
+        email = register_data.email
+        password = register_data.password
+        name = register_data.name
+        age = register_data.age
+        
+        if query.is_username_or_email_exists(username, email):
+            raise HTTPException(status_code=409, detail="Username or email already exists")
+            
+        verification_code = ''.join(random.choices(string.digits, k=6))
+        code_expiration = datetime.utcnow() + timedelta(minutes=10)
+        hashed_password = generate_password_hash(password)
+        created_at = datetime.utcnow()
+        
+        temp_user = {
+            'username': username,
+            'email': email,
+            'password': hashed_password,
+            'name': name,
+            'age': age,
+            'created_at': created_at,
+            'verification_code': verification_code,
+            'code_expiration': code_expiration
+        }
+        
+        query.create_or_update_temp_user(username, email, temp_user)
+        
+        message = Mail(
+            from_email=FROM_EMAIL,
+            to_emails=email,
+            subject='Verify your email address',
+            html_content=f'''
+            <p>Hi {name},</p>
+            <p>Thank you for registering. Please use the following code to verify your email address:</p>
+            <h2>{verification_code}</h2>
+            <p>This code will expire in 10 minutes.</p>
+            '''
+        )
+        
+        try:
+            sg = SendGridAPIClient(SENDGRID_API_KEY)
+            sg.send(message)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Failed to send verification email")
+
+        return {"message": "Registration successful. A verification code has been sent to your email."}
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/verify-email')
+async def verify_email(verify_data: VerifyEmailRequest):
+    try:
+        username = verify_data.username
+        code = verify_data.code
+        
+        temp_user = query.get_temp_user_by_username(username)
+        if not temp_user:
+            raise HTTPException(status_code=404, detail="User not found or already verified")
+
+        if temp_user['verification_code'] != code:
+            raise HTTPException(status_code=400, detail="Invalid verification code")
+
+        if datetime.utcnow() > temp_user['code_expiration']:
+            raise HTTPException(status_code=400, detail="Verification code has expired")
+            
+        user_data = temp_user.copy()
+        user_data['is_verified'] = True
+        user_data.pop('verification_code', None)
+        user_data.pop('code_expiration', None)
+        user_data.pop('_id', None)
+        
+        query.create_user_from_data(user_data)
+        query.delete_temp_user(username)
+        
+        # Set default language to English
+        query.set_user_language(username, "English")
+        
+        # Set default theme to light (passing false for dark theme)
+        query.set_user_theme(username, False)
+
+        default_preferences = {
+            'keywords': True,
+            'references': True, 
+            'websearch': False,
+            'personalized_recommendations': True,
+            'environmental_recommendations': True
+        }
+        
+        query.set_user_preferences(username, default_preferences)
+
+        return {"message": "Email verification successful"}
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/resend-code')
+async def resend_code(resend_data: ResendCodeRequest):
+    try:
+        username = resend_data.username
+        
+        temp_user = query.get_temp_user_by_username(username)
+        if not temp_user:
+            raise HTTPException(status_code=404, detail="User not found or already verified")
+            
+        verification_code = ''.join(random.choices(string.digits, k=6))
+        code_expiration = datetime.utcnow() + timedelta(minutes=10)
+        
+        temp_user['verification_code'] = verification_code
+        temp_user['code_expiration'] = code_expiration
+        
+        query.create_or_update_temp_user(username, temp_user['email'], temp_user)
+        
+        message = Mail(
+            from_email=FROM_EMAIL,
+            to_emails=temp_user['email'],
+            subject='Your new verification code',
+            html_content=f'''
+            <p>Hi {temp_user['name']},</p>
+            <p>You requested a new verification code. Please use the following code to verify your email address:</p>
+            <h2>{verification_code}</h2>
+            <p>This code will expire in 10 minutes.</p>
+            '''
+        )
+        
+        try:
+            sg = SendGridAPIClient(SENDGRID_API_KEY)
+            sg.send(message)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail="Failed to send verification email")
+
+        return {"message": "A new verification code has been sent to your email."}
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/checkChatsession')
+async def check_chatsession(data: ChatSessionCheck, username: str = Depends(get_current_user)):
+    session_id = data.session_id
+    is_chat_exit = query.check_chat_session(session_id)
+    return {"ischatexit": is_chat_exit}
+
+@router.get('/check-token')
+async def check_token(username: str = Depends(get_current_user)):
+    try:
+        return {'valid': True, 'user': username}
+    except Exception as e:
+        raise HTTPException(status_code=401, detail=str(e))
+
+@router.post('/forgot-password')
+async def forgot_password(data: ForgotPasswordRequest):
+    try:
+        email = data.email
+        
+        user = query.get_user_by_identifier(email)
+        if not user:
+            raise HTTPException(status_code=404, detail="Email not found")
+            
+        reset_token = ''.join(random.choices(string.ascii_letters + string.digits, k=32))
+        expiration = datetime.utcnow() + timedelta(hours=1)
+        
+        query.store_reset_token(email, reset_token, expiration)
+        
+        reset_link = f"http://localhost:3000/reset-password?token={reset_token}"
+        
+        message = Mail(
+            from_email=FROM_EMAIL,
+            to_emails=email,
+            subject='Reset Your Password',
+            html_content=f'''
+            <p>Hi,</p>
+            <p>You requested to reset your password. Click the link below to reset it:</p>
+            <p><a href="{reset_link}">Reset Password</a></p>
+            <p>This link will expire in 1 hour.</p>
+            <p>If you didn't request this, please ignore this email.</p>
+            '''
+        )
+        
+        sg = SendGridAPIClient(SENDGRID_API_KEY)
+        sg.send(message)
+
+        return {"message": "Password reset instructions sent to email"}
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/reset-password')
+async def reset_password(data: ResetPasswordRequest):
+    try:
+        token = data.token
+        new_password = data.password
+        
+        if not token or not new_password:
+            raise HTTPException(status_code=400, detail="Token and new password are required")
+            
+        reset_info = query.verify_reset_token(token)
+        if not reset_info:
+            raise HTTPException(status_code=400, detail="Invalid or expired reset token")
+            
+        hashed_password = generate_password_hash(new_password)
+        query.update_password(reset_info['email'], hashed_password)
+
+        return {"message": "Password successfully reset"}
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/chat.py

@@ -0,0 +1,385 @@
+# app/routers/chat.py
+import logging
+import os
+import json
+import tempfile
+from datetime import datetime
+
+from bson import ObjectId
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form, Header
+from fastapi.responses import JSONResponse, FileResponse
+from pydantic import BaseModel
+
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user, get_optional_user
+from app.services import ChatProcessor
+from app.services.image_processor import ImageProcessor
+from app.services.report_process import Report
+from app.services.skincare_scheduler import SkinCareScheduler
+from app.services.wheel import EnvironmentalConditions
+from app.services.RAG_evaluation import RAGEvaluation
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class ChatSessionTitleUpdate(BaseModel):
+    title: str
+
+@router.get('/image/{filename}')
+async def serve_image(filename: str):
+    try:
+        # Use an absolute path or environment variable to ensure consistency
+        upload_dir = os.path.abspath('uploads')
+        file_path = os.path.join(upload_dir, filename)
+        
+        # Add logging to debug
+        print(f"Attempting to serve file from: {file_path}")
+        if not os.path.exists(file_path):
+            print(f"File not found: {file_path}")
+            raise FileNotFoundError()
+            
+        return FileResponse(file_path)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Image not found")
+    
+@router.post('/chat-sessions', status_code=201)
+async def create_chat_session(username: str = Depends(get_current_user)):
+    try:
+        session_id = str(ObjectId())
+
+        chat_session = {
+            "user_id": username,
+            "session_id": session_id,
+            "created_at": datetime.utcnow(),
+            "last_accessed": datetime.utcnow(),
+            "title": "New Chat"
+        }
+        query.create_chat_session(chat_session)
+        return {"message": "Chat session created", "session_id": session_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/chat-sessions')
+async def get_user_chat_sessions(username: str = Depends(get_current_user)):
+    try:
+        sessions = query.get_user_chat_sessions(username)
+        return sessions
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.delete('/chat-sessions/{session_id}')
+async def delete_chat_session(session_id: str, username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_chat_session(session_id, username)
+
+        if result["session_deleted"]:
+            return {
+                "message": "Chat session and associated chats deleted successfully",
+                "chats_deleted": result["chats_deleted"]
+            }
+        raise HTTPException(status_code=404, detail="Chat session not found or unauthorized")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.put('/chat-sessions/{session_id}/title')
+async def update_chat_title(
+    session_id: str, 
+    title_data: ChatSessionTitleUpdate, 
+    username: str = Depends(get_current_user)
+):
+    try:
+        new_title = title_data.title
+
+        if not query.verify_session(session_id, username):
+            raise HTTPException(status_code=404, detail="Chat session not found or unauthorized")
+
+        if query.update_chat_session_title(session_id, new_title):
+            return {
+                'message': 'Chat session title updated successfully',
+                'session_id': session_id,
+                'new_title': new_title
+            }
+
+        raise HTTPException(status_code=500, detail="Failed to update chat session title")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/chat-sessions/all')
+async def delete_all_sessions_and_chats(username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_all_user_sessions_and_chats(username)
+
+        return {
+            "message": "Successfully deleted all chat sessions and chats",
+            "deleted_chats": result["deleted_chats"],
+            "deleted_sessions": result["deleted_sessions"]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/chats/session/{session_id}')
+async def get_session_chats(session_id: str, username: str = Depends(get_current_user)):
+    try:
+        chats = query.get_session_chats(session_id, username)
+        return chats
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/export-chat/{session_id}')
+async def export_chat(session_id: str, username: str = Depends(get_current_user)):
+    try:
+        if not query.verify_session(session_id, username):
+            raise HTTPException(status_code=404, detail="Chat session not found or unauthorized")
+
+        chats = query.get_session_chats(session_id, username)
+
+        formatted_chats = []
+        for chat in chats:
+            formatted_chat = {
+                'query': chat.get('query', ''),
+                'response': chat.get('response', ''),
+                'references': chat.get('references', []),
+                'page_no': chat.get('page_no', ''),
+                'date': chat.get('timestamp', ''),
+                'chat_id': chat.get('chat_id', '')
+            }
+            formatted_chats.append(formatted_chat)
+
+        export_data = {
+            'session_id': session_id,
+            'export_date': datetime.utcnow().isoformat(),
+            'chats': formatted_chats
+        }
+
+        return export_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/export-all-chats')
+async def export_all_chats(username: str = Depends(get_current_user)):
+    try:
+        all_chats = query.get_all_user_chats(username)
+        formatted_sessions = []
+        for session in all_chats:
+            formatted_chats = []
+            for chat in session['chats']:
+                formatted_chat = {
+                    'query': chat.get('query', ''),
+                    'response': chat.get('response', ''),
+                    'references': chat.get('references', []),
+                    'page_no': chat.get('page_no', ''),
+                    'timestamp': chat.get('timestamp', ''),
+                    'chat_id': chat.get('chat_id', '')
+                }
+                formatted_chats.append(formatted_chat)
+
+            formatted_session = {
+                'session_id': session['session_id'],
+                'title': session['title'],
+                'created_at': session['created_at'],
+                'last_accessed': session['last_accessed'],
+                'chats': formatted_chats
+            }
+            formatted_sessions.append(formatted_session)
+
+        export_data = {
+            'user': username,
+            'export_date': datetime.utcnow().isoformat(),
+            'sessions': formatted_sessions
+        }
+
+        return export_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/web-search')
+async def web_search(
+    data: dict,
+    authorization: str = Header(None),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        session_id = data.get("session_id")
+        query = data.get("query")
+        num_results = data.get("num_results", 3)
+        num_images = data.get("num_images", 3)
+        
+        if not session_id or not query:
+            return JSONResponse(
+                status_code=400,
+                content={"error": "session_id and query are required"}
+            )
+            
+        chat_processor = ChatProcessor(token=token, session_id=session_id, num_results=num_results, num_images=num_images)
+        response = chat_processor.web_search(query=query)
+        
+        return {"response": response}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/report-analysis')
+async def analyze_report(
+    file: UploadFile = File(...),
+    query: str = Form(...),
+    session_id: str = Form(...),
+    authorization: str = Header(None),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        
+        if not file.filename:
+            return JSONResponse(
+                status_code=400,
+                content={"status": "error", "error": "Empty file provided"}
+            )
+        
+        if not query.strip():
+            return JSONResponse(
+                status_code=400,
+                content={"status": "error", "error": "Query is required"}
+            )
+        
+        file_extension = file.filename.rsplit('.', 1)[1].lower() if '.' in file.filename else ''
+        allowed_extensions = {
+            'pdf': 'pdf',
+            'xlsx': 'excel',
+            'xls': 'excel',
+            'csv': 'csv',
+            'jpg': 'image',
+            'jpeg': 'image',
+            'png': 'image',
+            'doc': 'word',
+            'docx': 'word',
+            'ppt': 'ppt',
+            'txt': 'text',
+            'html': 'html'
+        }
+        
+        if file_extension not in allowed_extensions:
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "status": "success",
+                    "message": f"Unsupported file type. Allowed types: {', '.join(allowed_extensions.keys())}",
+                    "analysis": result
+                }
+            )
+        
+        temp_dir = tempfile.mkdtemp()
+        temp_file_path = os.path.join(temp_dir, file.filename)
+        
+        try:
+            content = await file.read()
+            with open(temp_file_path, "wb") as f:
+                f.write(content)
+            
+            processor = Report(token=token, session_id=session_id)
+            result = processor.process_chat(
+                query=query,
+                report_file=temp_file_path,
+                file_type=allowed_extensions[file_extension]
+            )
+            
+            return {
+                "status": "success",
+                "message": "Report analyzed successfully",
+                "analysis": result
+            }
+        finally:
+            # Clean up temporary files
+            if os.path.exists(temp_file_path):
+                os.remove(temp_file_path)
+            os.rmdir(temp_dir)
+            
+    except Exception as e:
+        logging.error(f"Error in analyze_report: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "status": "error",
+                "error": "Internal server error",
+                "details": str(e)
+            }
+        )
+
+@router.get('/skin-care-schedule')
+async def get_skin_care_schedule(
+    authorization: str = Header(None),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        scheduler = SkinCareScheduler(token, "session_id")
+        schedule = scheduler.createTable()
+        return json.loads(schedule)
+    except Exception as e:
+        logging.error(f"Error generating skin care schedule: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={"error": "Failed to generate skin care schedule"}
+        )
+
+@router.get('/skin-care-wheel')
+async def get_skin_care_wheel(
+    authorization: str = Header(...),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        condition = EnvironmentalConditions(session_id=token)
+        condition_data = condition.get_conditon()
+        return condition_data
+    except Exception as e:
+        logging.error(f"Error generating skin care wheel: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Failed to generate skin care wheel",
+                "message": "An unexpected error occurred"
+            }
+        )
+
+@router.post('/image_disease_search')
+async def disease_search(
+    session_id: str = Form(...),
+    query: str = Form(...),
+    num_results: int = Form(3),
+    num_images: int = Form(3),
+    image: UploadFile = File(...),
+    authorization: str = Header(...),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        image_processor = ImageProcessor(
+            token=token,
+            session_id=session_id,
+            num_results=num_results,
+            num_images=num_images,
+            image=image
+        )
+        response = image_processor.web_search(query=query)
+        return {"response": response}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/get_rag_evaluation')
+async def rag_evaluation(
+    page: int = Form(3),
+    page_size: int = Form(3),
+    authorization: str = Header(...),
+    username: str = Depends(get_current_user)
+):
+    try:
+        token = authorization.split(" ")[1]
+        evaluator = RAGEvaluation(
+            token=token,
+            page=page,
+            page_size=page_size
+        )
+        report = evaluator.generate_evaluation_report()
+        return {"response": report}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/chat_session.py

@@ -0,0 +1,97 @@
+# app/routers/chat_session.py
+from datetime import datetime
+from bson import ObjectId
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class ChatSessionTitleUpdate(BaseModel):
+    title: str
+
+@router.post('/chat-sessions', status_code=201)
+async def create_chat_session(username: str = Depends(get_current_user)):
+    try:
+        session_id = str(ObjectId())
+
+        chat_session = {
+            "user_id": username,
+            "session_id": session_id,
+            "created_at": datetime.utcnow(),
+            "last_accessed": datetime.utcnow(),
+            "title": "New Chat"
+        }
+        query.create_chat_session(chat_session)
+        return {"message": "Chat session created", "session_id": session_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/chat-sessions')
+async def get_user_chat_sessions(username: str = Depends(get_current_user)):
+    try:
+        sessions = query.get_user_chat_sessions(username)
+        return sessions
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.delete('/chat-sessions/{session_id}')
+async def delete_chat_session(session_id: str, username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_chat_session(session_id, username)
+
+        if result["session_deleted"]:
+            return {
+                "message": "Chat session and associated chats deleted successfully",
+                "chats_deleted": result["chats_deleted"]
+            }
+        raise HTTPException(status_code=404, detail="Chat session not found or unauthorized")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.put('/chat-sessions/{session_id}/title')
+async def update_chat_title(
+    session_id: str, 
+    title_data: ChatSessionTitleUpdate, 
+    username: str = Depends(get_current_user)
+):
+    try:
+        new_title = title_data.title
+
+        if not query.verify_session(session_id, username):
+            raise HTTPException(status_code=404, detail="Chat session not found or unauthorized")
+
+        if query.update_chat_session_title(session_id, new_title):
+            return {
+                'message': 'Chat session title updated successfully',
+                'session_id': session_id,
+                'new_title': new_title
+            }
+
+        raise HTTPException(status_code=500, detail="Failed to update chat session title")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/chat-sessions/all')
+async def delete_all_sessions_and_chats(username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_all_user_sessions_and_chats(username)
+
+        return {
+            "message": "Successfully deleted all chat sessions and chats",
+            "deleted_chats": result["deleted_chats"],
+            "deleted_sessions": result["deleted_sessions"]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/chats/session/{session_id}')
+async def get_session_chats(session_id: str, username: str = Depends(get_current_user)):
+    try:
+        chats = query.get_session_chats(session_id, username)
+        return chats
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/language.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from app.middleware.auth import get_current_user
+
+from app.database.database_query import DatabaseQuery
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class LanguageSettings(BaseModel):
+    language: str
+
+@router.post('/language', status_code=201)
+async def set_language(
+    language_data: LanguageSettings,
+    username: str = Depends(get_current_user)
+):
+    try:
+        language = language_data.language
+        
+        if not language:
+            raise HTTPException(status_code=400, detail="Language is required")
+        
+        result = query.set_user_language(username, language)
+        
+        return {
+            "message": "Language set successfully",
+            "language": result["language"]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/language')
+async def get_language(username: str = Depends(get_current_user)):
+    try:
+        language = query.get_user_language(username)
+        
+        if language is None:
+            raise HTTPException(status_code=404, detail="Language not set")
+        
+        return {
+            "message": "Language retrieved successfully",
+            "language": language
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/language')
+async def delete_language(username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_user_language(username)
+        
+        if not result:
+            raise HTTPException(status_code=404, detail="Language not found or already deleted")
+        
+        return {
+            "message": "Language deleted successfully"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/location.py

@@ -0,0 +1,37 @@
+# app/routers/location.py
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class LocationData(BaseModel):
+    location: str
+
+@router.post('/location', status_code=201)
+async def add_location(location_data: LocationData, username: str = Depends(get_current_user)):
+    try:
+        location = location_data.location
+        
+        if not location:
+            raise HTTPException(status_code=400, detail="Location is required")
+
+        query.add_or_update_location(username, location)
+
+        return {'message': 'Location added/updated successfully'}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/location')
+async def get_location(username: str = Depends(get_current_user)):
+    try:
+        location_data = query.get_location(username)
+
+        if not location_data:
+            raise HTTPException(status_code=404, detail="No location found for this user")
+
+        return {'location': location_data['location']}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/preferences.py

@@ -0,0 +1,51 @@
+# app/routers/preferences.py
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import Dict, Any
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class ThemeSettings(BaseModel):
+    theme: bool
+
+@router.get('/preferences')
+async def get_preferences(username: str = Depends(get_current_user)):
+    try:
+        user_preferences = query.get_user_preferences(username)
+        return {'preferences': user_preferences}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/preferences')
+async def set_preferences(preferences: Dict[str, Any], username: str = Depends(get_current_user)):
+    try:
+        preferences_result = query.set_user_preferences(username, preferences)
+        return {
+            'message': 'Preferences updated successfully',
+            'preferences': preferences_result
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/theme')
+async def get_theme(username: str = Depends(get_current_user)):
+    try:
+        user_theme = query.get_user_theme(username)
+        return {'theme': user_theme}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post('/theme')
+async def set_theme(theme_data: ThemeSettings, username: str = Depends(get_current_user)):
+    try:
+        theme = theme_data.theme
+        theme_data = query.set_user_theme(username, theme)
+        return {
+            'message': 'Theme updated successfully',
+            'theme': theme_data['theme']
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/profile.py

@@ -0,0 +1,113 @@
+from fastapi import APIRouter, Depends, HTTPException, Body
+from pydantic import BaseModel, EmailStr, validator
+from typing import Optional
+from werkzeug.security import generate_password_hash
+
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class ProfileUpdateRequest(BaseModel):
+    email: Optional[EmailStr] = None
+    password: Optional[str] = None
+    name: Optional[str] = None
+    age: Optional[int] = None
+    
+    @validator('password')
+    def password_length(cls, v):
+        if v is not None and len(v) < 6:
+            raise ValueError('Password must be at least 6 characters')
+        return v
+    
+    @validator('age')
+    def age_range(cls, v):
+        if v is not None and (v < 13 or v > 120):
+            raise ValueError('Age must be between 13 and 120')
+        return v
+
+@router.get('/profile')
+async def get_profile(username: str = Depends(get_current_user)):
+    try:
+        user = query.get_user_profile(username)
+
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+
+        return {
+            'username': user['username'],
+            'email': user['email'],
+            'name': user['name'],
+            'age': user['age'],
+            'created_at': user['created_at']
+        }
+
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.put('/profile')
+async def update_profile(
+    update_data: ProfileUpdateRequest = Body(...),
+    username: str = Depends(get_current_user)
+):
+    try:
+        update_fields = {}
+
+        if update_data.email:
+            if not query.is_valid_email(update_data.email):
+                raise HTTPException(status_code=400, detail="Invalid email format")
+            update_fields['email'] = update_data.email
+
+        if update_data.password:
+            update_fields['password'] = generate_password_hash(update_data.password)
+
+        if update_data.name:
+            update_fields['name'] = update_data.name
+
+        if update_data.age is not None:
+            update_fields['age'] = update_data.age
+
+        if update_fields:
+            if query.update_user_profile(username, update_fields):
+                return {"message": "Profile updated successfully"}
+
+        return {"message": "No changes made"}
+
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/profile')
+async def delete_account(username: str = Depends(get_current_user)):
+    try:
+        if query.delete_user_account(username):
+            return {"message": "Account deleted successfully"}
+
+        raise HTTPException(status_code=404, detail="User not found")
+
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/delete-account-permanently')
+async def delete_account_permanently(username: str = Depends(get_current_user)):
+    try:
+        result = query.delete_account_permanently(username)
+
+        if result['success']:
+            return {
+                'message': 'Account and all associated data deleted successfully',
+                'details': result['deleted_data']
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Failed to delete account")
+
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/questionnaire.py

@@ -0,0 +1,100 @@
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import Dict, Any
+
+from app.database.database_query import DatabaseQuery
+from app.middleware.auth import get_current_user
+
+router = APIRouter()
+query = DatabaseQuery()
+
+class QuestionnaireSubmission(BaseModel):
+    answers: Dict[str, Any]
+
+@router.post('/questionnaires', status_code=201)
+async def submit_questionnaire(
+    submission: QuestionnaireSubmission,
+    username: str = Depends(get_current_user)
+):
+    try:
+        if not submission.answers:
+            raise HTTPException(status_code=400, detail="Answers are required")
+
+        questionnaire_id = query.submit_questionnaire(username, submission.answers)
+        return {
+            'message': 'Questionnaire submitted successfully',
+            'questionnaire_id': questionnaire_id
+        }
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/questionnaires')
+async def get_questionnaire(username: str = Depends(get_current_user)):
+    try:
+        questionnaire = query.get_latest_questionnaire(username)
+
+        if not questionnaire:
+            return {'message': 'No questionnaire found', 'data': None}
+
+        return {'message': 'Success', 'data': questionnaire}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.put('/questionnaires/{questionnaire_id}')
+async def update_questionnaire(
+    questionnaire_id: str,
+    submission: QuestionnaireSubmission,
+    username: str = Depends(get_current_user)
+):
+    try:
+        if not submission.answers:
+            raise HTTPException(status_code=400, detail="Answers are required")
+
+        if query.update_questionnaire(questionnaire_id, username, submission.answers):
+            return {'message': 'Questionnaire updated successfully'}
+
+        raise HTTPException(
+            status_code=404, 
+            detail='Questionnaire not found or unauthorized'
+        )
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete('/questionnaires/{questionnaire_id}')
+async def delete_questionnaire(
+    questionnaire_id: str,
+    username: str = Depends(get_current_user)
+):
+    try:
+        if query.delete_questionnaire(questionnaire_id, username):
+            return {'message': 'Questionnaire deleted successfully'}
+
+        raise HTTPException(
+            status_code=404, 
+            detail='Questionnaire not found or unauthorized'
+        )
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            raise e
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/check-answers')
+async def check_answers(username: str = Depends(get_current_user)):
+    try:
+        answered_count = query.count_answered_questions(username)
+        return {'has_at_least_two_answers': answered_count >= 2}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get('/check-questionnaire')
+async def check_questionnaire_submission(username: str = Depends(get_current_user)):
+    try:
+        questionnaire = query.get_latest_questionnaire(username)
+        has_questionnaire = questionnaire is not None
+        return {'has_questionnaire': has_questionnaire}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/services/MagicConvert.py

@@ -0,0 +1,685 @@
+import copy
+import html
+import mimetypes
+import os
+import re
+import tempfile
+import traceback
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import quote, unquote, urlparse, urlunparse
+from warnings import warn, resetwarnings, catch_warnings
+import mammoth
+import markdownify
+import pandas as pd
+import pdfminer
+import pdfminer.high_level
+import pptx
+import puremagic
+import requests
+from bs4 import BeautifulSoup
+from charset_normalizer import from_path
+from PIL import Image
+import pytesseract
+import warnings
+warnings.filterwarnings("ignore")
+
+# Set Tesseract path for Linux (Hugging Face Spaces)
+pytesseract.pytesseract.tesseract_cmd = "/usr/bin/tesseract"
+
+class OCRReader:
+    def __init__(self, tesseract_cmd: Optional[str] = None, config: Optional[Dict] = None):
+        # Use provided tesseract_cmd or fallback to environment default
+        if tesseract_cmd:
+            pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
+        self.config = config or {}
+
+    def read_text_from_image(self, image: Image.Image) -> str:
+        try:
+            text = pytesseract.image_to_string(image, **self.config)
+            return text.strip()
+        except Exception as e:
+            raise Exception(f"Error processing image: {str(e)}")
+
+
+class _CustomMarkdownify(markdownify.MarkdownConverter):
+    def __init__(self, **options: Any):
+        options["heading_style"] = options.get("heading_style", markdownify.ATX)
+        super().__init__(**options)
+
+    def convert_a(self, el: Any, text: str, *args, **kwargs):
+        prefix, suffix, text = markdownify.chomp(text)
+        if not text:
+            return ""
+        href = el.get("href")
+        title = el.get("title")
+        if href:
+            try:
+                parsed_url = urlparse(href)  # type: ignore
+                if parsed_url.scheme and parsed_url.scheme.lower() not in ["http", "https", "file"]:  # type: ignore
+                    return "%s%s%s" % (prefix, text, suffix)
+                href = urlunparse(parsed_url._replace(path=quote(unquote(parsed_url.path))))  # type: ignore
+            except ValueError:
+                return "%s%s%s" % (prefix, text, suffix)
+        if (
+            self.options["autolinks"]
+            and text.replace(r"\_", "_") == href
+            and not title
+            and not self.options["default_title"]
+        ):
+            return "<%s>" % href
+        if self.options["default_title"] and not title:
+            title = href
+        title_part = ' "%s"' % title.replace('"', r"\"") if title else ""
+        return (
+            "%s[%s](%s%s)%s" % (prefix, text, href, title_part, suffix)
+            if href
+            else text
+        )
+
+    def convert_hn(self, n: int, el: Any, text: str, convert_as_inline: bool) -> str:
+        if not convert_as_inline:
+            if not re.search(r"^\n", text):
+                return "\n" + super().convert_hn(n, el, text, convert_as_inline)  # type: ignore
+
+        return super().convert_hn(n, el, text, convert_as_inline)  # type: ignore
+
+    def convert_img(self, el: Any, text: str, *args, **kwargs) -> str:
+        # Handle both old and new calling patterns
+        convert_as_inline = kwargs.get('convert_as_inline', False)
+        if len(args) > 0:
+            convert_as_inline = args[0]
+            
+        alt = el.attrs.get("alt", None) or ""
+        src = el.attrs.get("src", None) or ""
+        title = el.attrs.get("title", None) or ""
+        title_part = ' "%s"' % title.replace('"', r"\"") if title else ""
+        if (
+            convert_as_inline
+            and el.parent.name not in self.options["keep_inline_images_in"]
+        ):
+            return alt
+        if src.startswith("data:"):
+            src = src.split(",")[0] + "..."
+
+        return "![%s](%s%s)" % (alt, src, title_part)
+
+    def convert_soup(self, soup: Any) -> str:
+        return super().convert_soup(soup)
+
+
+class DocumentConverterResult:
+    def __init__(self, title: Union[str, None] = None, text_content: str = ""):
+        self.title: Union[str, None] = title
+        self.text_content: str = text_content
+
+
+class DocumentConverter:
+    def convert(self, local_path: str, **kwargs: Any) -> Union[None, DocumentConverterResult]:
+        raise NotImplementedError()
+
+    def supports_extension(self, ext: str) -> bool:
+        """Return True if this converter supports the given extension."""
+        raise NotImplementedError()
+
+
+class PlainTextConverter(DocumentConverter):
+    def convert(
+        self, local_path: str, **kwargs: Any
+    ) -> Union[None, DocumentConverterResult]:
+        content_type, _ = mimetypes.guess_type(
+            "__placeholder" + kwargs.get("file_extension", "")
+        )
+        if content_type is None:
+            return None
+        elif "text/" not in content_type.lower():
+            return None
+
+        text_content = str(from_path(local_path).best())
+        return DocumentConverterResult(
+            title=None,
+            text_content=text_content,
+        )
+
+
+class HtmlConverter(DocumentConverter):
+    def convert(
+        self, local_path: str, **kwargs: Any
+    ) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "")
+        if extension.lower() not in [".html", ".htm"]:
+            return None
+
+        result = None
+        with open(local_path, "rt", encoding="utf-8") as fh:
+            result = self._convert(fh.read())
+
+        return result
+
+    def _convert(self, html_content: str) -> Union[None, DocumentConverterResult]:
+        soup = BeautifulSoup(html_content, "html.parser")
+        for script in soup(["script", "style"]):
+            script.extract()
+        body_elm = soup.find("body")
+        webpage_text = ""
+        if body_elm:
+            webpage_text = _CustomMarkdownify().convert_soup(body_elm)
+        else:
+            webpage_text = _CustomMarkdownify().convert_soup(soup)
+
+        assert isinstance(webpage_text, str)
+
+        return DocumentConverterResult(
+            title=None if soup.title is None else soup.title.string,
+            text_content=webpage_text,
+        )
+
+
+class PdfConverter(DocumentConverter):
+    def supports_extension(self, ext: str) -> bool:
+        return ext.lower() == '.pdf'
+
+    def convert(self, local_path, **kwargs) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "")
+        if extension.lower() != ".pdf":
+            return None
+        return DocumentConverterResult(
+            title=None,
+            text_content=pdfminer.high_level.extract_text(local_path),
+        )
+
+
+class DocxConverter(HtmlConverter):
+    def supports_extension(self, ext: str) -> bool:
+        return ext.lower() == '.docx'
+
+    def convert(self, local_path, **kwargs) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "")
+        if extension.lower() != ".docx":
+            return None
+        result = None
+        with open(local_path, "rb") as docx_file:
+            style_map = kwargs.get("style_map", None)
+            result = mammoth.convert_to_html(docx_file, style_map=style_map)
+            html_content = result.value
+            result = self._convert(html_content)
+        return result
+
+
+class XlsxConverter(HtmlConverter):
+    def convert(self, local_path, **kwargs) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "")
+        if extension.lower() != ".xlsx":
+            return None
+
+        sheets = pd.read_excel(local_path, sheet_name=None)
+        md_content = ""
+        for s in sheets:
+            md_content += f"## {s}\n"
+            html_content = sheets[s].to_html(index=False)
+            md_content += self._convert(html_content).text_content.strip() + "\n\n"
+
+        return DocumentConverterResult(
+            title=None,
+            text_content=md_content.strip(),
+        )
+
+
+class PptxConverter(HtmlConverter):
+    def supports_extension(self, ext: str) -> bool:
+        return ext.lower() == '.pptx'
+
+    def convert(self, local_path, **kwargs) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "")
+        if extension.lower() != ".pptx":
+            return None
+        md_content = ""
+        presentation = pptx.Presentation(local_path)
+        slide_num = 0
+        for slide in presentation.slides:
+            slide_num += 1
+
+            md_content += f"\n\n<!-- Slide number: {slide_num} -->\n"
+
+            title = slide.shapes.title
+            for shape in slide.shapes:
+                if self._is_picture(shape):
+                    alt_text = ""
+                    try:
+                        alt_text = shape._element._nvXxPr.cNvPr.attrib.get("descr", "")
+                    except Exception:
+                        pass
+                    filename = re.sub(r"\W", "", shape.name) + ".jpg"
+                    md_content += (
+                        "\n!["
+                        + (alt_text if alt_text else shape.name)
+                        + "]("
+                        + filename
+                        + ")\n"
+                    )
+
+                # Tables
+                if self._is_table(shape):
+                    html_table = "<html><body><table>"
+                    first_row = True
+                    for row in shape.table.rows:
+                        html_table += "<tr>"
+                        for cell in row.cells:
+                            if first_row:
+                                html_table += "<th>" + html.escape(cell.text) + "</th>"
+                            else:
+                                html_table += "<td>" + html.escape(cell.text) + "</td>"
+                        html_table += "</tr>"
+                        first_row = False
+                    html_table += "</table></body></html>"
+                    md_content += (
+                        "\n" + self._convert(html_table).text_content.strip() + "\n"
+                    )
+                if shape.has_chart:
+                    md_content += self._convert_chart_to_markdown(shape.chart)
+                elif shape.has_text_frame:
+                    if shape == title:
+                        md_content += "# " + shape.text.lstrip() + "\n"
+                    else:
+                        md_content += shape.text + "\n"
+
+            md_content = md_content.strip()
+
+            if slide.has_notes_slide:
+                md_content += "\n\n### Notes:\n"
+                notes_frame = slide.notes_slide.notes_text_frame
+                if notes_frame is not None:
+                    md_content += notes_frame.text
+                md_content = md_content.strip()
+
+        return DocumentConverterResult(
+            title=None,
+            text_content=md_content.strip(),
+        )
+
+    def _is_picture(self, shape):
+        if shape.shape_type == pptx.enum.shapes.MSO_SHAPE_TYPE.PICTURE:
+            return True
+        if shape.shape_type == pptx.enum.shapes.MSO_SHAPE_TYPE.PLACEHOLDER:
+            if hasattr(shape, "image"):
+                return True
+        return False
+
+    def _is_table(self, shape):
+        if shape.shape_type == pptx.enum.shapes.MSO_SHAPE_TYPE.TABLE:
+            return True
+        return False
+
+    def _convert_chart_to_markdown(self, chart):
+        md = "\n\n### Chart"
+        if chart.has_title:
+            md += f": {chart.chart_title.text_frame.text}"
+        md += "\n\n"
+        data = []
+        category_names = [c.label for c in chart.plots[0].categories]
+        series_names = [s.name for s in chart.series]
+        data.append(["Category"] + series_names)
+
+        for idx, category in enumerate(category_names):
+            row = [category]
+            for series in chart.series:
+                row.append(series.values[idx])
+            data.append(row)
+
+        markdown_table = []
+        for row in data:
+            markdown_table.append("| " + " | ".join(map(str, row)) + " |")
+        header = markdown_table[0]
+        separator = "|" + "|".join(["---"] * len(data[0])) + "|"
+        return md + "\n".join([header, separator] + markdown_table[1:])
+
+
+class FileConversionException(BaseException):
+    pass
+
+
+class UnsupportedFormatException(BaseException):
+    pass
+
+
+class ImageConverter(DocumentConverter):
+    def __init__(self, ocr_reader: Optional[OCRReader] = None):
+        self.ocr_reader = ocr_reader or OCRReader()
+
+    def convert(self, local_path: str, **kwargs: Any) -> Union[None, DocumentConverterResult]:
+        extension = kwargs.get("file_extension", "").lower()
+        if extension not in ['.png', '.jpg', '.jpeg', '.tiff', '.bmp']:
+            return None
+
+        try:
+            image = Image.open(local_path)
+            text_content = self.ocr_reader.read_text_from_image(image)
+            markdown_content = self._convert_to_markdown_structure(text_content)
+            return DocumentConverterResult(
+                title=None,
+                text_content=markdown_content
+            )
+        except Exception as e:
+            raise FileConversionException(f"Failed to process image: {str(e)}")
+
+    def _convert_to_markdown_structure(self, text_content: str) -> str:
+        lines = text_content.split('\n')
+        markdown = []
+        current_table = []
+        in_table = False
+
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+            next_line = lines[i + 1].strip() if i + 1 < len(lines) else ""
+
+            if not line:
+                if in_table:
+                    markdown.extend(self._format_table(current_table))
+                    current_table = []
+                    in_table = False
+                markdown.append("")
+                i += 1
+                continue
+
+            header_level = self._detect_header_level(line, next_line)
+            if header_level:
+                if in_table:
+                    markdown.extend(self._format_table(current_table))
+                    current_table = []
+                    in_table = False
+                markdown.append(f"{'#' * header_level} {line}")
+                i += 2 if header_level > 0 and next_line and set(next_line) in [set('='), set('-')] else 1
+                continue
+
+            list_format = self._detect_list_format(line)
+            if list_format:
+                if in_table:
+                    markdown.extend(self._format_table(current_table))
+                    current_table = []
+                    in_table = False
+                markdown.append(list_format)
+                i += 1
+                continue
+            if self._is_likely_table_row(line):
+                in_table = True
+                current_table.append(line)
+                i += 1
+                continue
+            if in_table:
+                markdown.extend(self._format_table(current_table))
+                current_table = []
+                in_table = False
+            line = self._format_emphasis(line)
+
+            markdown.append(line)
+            i += 1
+        if current_table:
+            markdown.extend(self._format_table(current_table))
+
+        return "\n\n".join([l for l in markdown if l])
+
+    def _detect_header_level(self, line: str, next_line: str) -> int:
+        if line.startswith('#'):
+            return len(re.match(r'^#+', line).group())
+        if next_line:
+            if set(next_line) == set('='):
+                return 1
+            if set(next_line) == set('-'):
+                return 2
+        if len(line) <= 100 and line.strip():
+            words = line.split()
+            if all(word[0].isupper() for word in words if word):
+                return 1
+            if line[0].isupper() and len(words) <= 10:
+                return 2
+
+        return 0
+
+    def _detect_list_format(self, line: str) -> Optional[str]:
+        bullet_points = ['-', '•', '*', '○', '►', '·']
+        for bullet in bullet_points:
+            if line.lstrip().startswith(bullet):
+                content = line.lstrip()[1:].strip()
+                return f"- {content}"
+
+        if re.match(r'^\d+[\.\)]', line):
+            content = re.sub(r'^\d+[\.\)]', '', line).strip()
+            return f"1. {content}"
+
+        return None
+
+    def _is_likely_table_row(self, line: str) -> bool:
+        parts = [p for p in re.split(r'\s{2,}', line) if p.strip()]
+        if len(parts) >= 2:
+            lengths = [len(p) for p in parts]
+            avg_length = sum(lengths) / len(lengths)
+            if all(abs(l - avg_length) <= 5 for l in lengths):
+                return True
+        return False
+
+    def _format_table(self, table_rows: List[str]) -> List[str]:
+        if not table_rows:
+            return []
+        split_rows = [re.split(r'\s{2,}', row.strip()) for row in table_rows]
+        max_cols = max(len(row) for row in split_rows)
+        normalized_rows = []
+        for row in split_rows:
+            while len(row) < max_cols:
+                row.append('')
+            normalized_rows.append(row)
+        col_widths = []
+        for col in range(max_cols):
+            width = max(len(row[col]) for row in normalized_rows)
+            col_widths.append(width)
+        markdown_table = []
+
+        header = "| " + " | ".join(cell.ljust(width) for cell, width in zip(normalized_rows[0], col_widths)) + " |"
+        markdown_table.append(header)
+
+        separator = "|" + "|".join("-" * (width + 2) for width in col_widths) + "|"
+        markdown_table.append(separator)
+
+        for row in normalized_rows[1:]:
+            formatted_row = "| " + " | ".join(cell.ljust(width) for cell, width in zip(row, col_widths)) + " |"
+            markdown_table.append(formatted_row)
+
+        return markdown_table
+
+    def _format_emphasis(self, text: str) -> str:
+        text = re.sub(r'\b([A-Z]{2,})\b', r'**\1**', text)
+        text = re.sub(r'[_/](.*?)[_/]', r'*\1*', text)
+        return text
+
+class MagicConvert:
+    def __init__(
+            self,
+            requests_session: Optional[requests.Session] = None,
+            style_map: Optional[str] = None,
+    ):
+        if requests_session is None:
+            self._requests_session = requests.Session()
+        else:
+            self._requests_session = requests_session
+
+        self._style_map = style_map
+        self._page_converters: List[DocumentConverter] = []
+
+        ocr_reader = OCRReader()
+
+        self.register_page_converter(ImageConverter(ocr_reader))
+        self.register_page_converter(PlainTextConverter())
+        self.register_page_converter(HtmlConverter())
+        self.register_page_converter(DocxConverter())
+        self.register_page_converter(XlsxConverter())
+        self.register_page_converter(PptxConverter())
+        self.register_page_converter(PdfConverter())
+
+    def magic(
+        self, source: Union[str, requests.Response], **kwargs: Any
+    ) -> DocumentConverterResult:
+        if isinstance(source, str):
+            if (
+                source.startswith("http://")
+                or source.startswith("https://")
+                or source.startswith("file://")
+            ):
+                return self.convert_url(source, **kwargs)
+            else:
+                return self.convert_local(source, **kwargs)
+        elif isinstance(source, requests.Response):
+            return self.convert_response(source, **kwargs)
+
+    def convert_local(
+        self, path: str, **kwargs: Any
+    ) -> DocumentConverterResult:
+        ext = kwargs.get("file_extension")
+        extensions = [ext] if ext is not None else []
+        base, ext = os.path.splitext(path)
+        self._append_ext(extensions, ext)
+
+        for g in self._guess_ext_magic(path):
+            self._append_ext(extensions, g)
+        return self._convert(path, extensions, **kwargs)
+
+    def convert_stream(
+        self, stream: Any, **kwargs: Any
+    ) -> DocumentConverterResult:
+        ext = kwargs.get("file_extension")
+        extensions = [ext] if ext is not None else []
+        handle, temp_path = tempfile.mkstemp()
+        fh = os.fdopen(handle, "wb")
+        result = None
+        try:
+            content = stream.read()
+            if isinstance(content, str):
+                fh.write(content.encode("utf-8"))
+            else:
+                fh.write(content)
+            fh.close()
+            for g in self._guess_ext_magic(temp_path):
+                self._append_ext(extensions, g)
+            result = self._convert(temp_path, extensions, **kwargs)
+        finally:
+            try:
+                fh.close()
+            except Exception:
+                pass
+            os.unlink(temp_path)
+
+        return result
+
+    def convert_url(
+        self, url: str, **kwargs: Any
+    ) -> DocumentConverterResult:
+        response = self._requests_session.get(url, stream=True)
+        response.raise_for_status()
+        return self.convert_response(response, **kwargs)
+
+    def convert_response(
+        self, response: requests.Response, **kwargs: Any
+    ) -> DocumentConverterResult:
+        ext = kwargs.get("file_extension")
+        extensions = [ext] if ext is not None else []
+        content_type = response.headers.get("content-type", "").split(";")[0]
+        self._append_ext(extensions, mimetypes.guess_extension(content_type))
+        content_disposition = response.headers.get("content-disposition", "")
+        m = re.search(r"filename=([^;]+)", content_disposition)
+        if m:
+            base, ext = os.path.splitext(m.group(1).strip("\"'"))
+            self._append_ext(extensions, ext)
+        base, ext = os.path.splitext(urlparse(response.url).path)
+        self._append_ext(extensions, ext)
+        handle, temp_path = tempfile.mkstemp()
+        fh = os.fdopen(handle, "wb")
+        result = None
+        try:
+            for chunk in response.iter_content(chunk_size=512):
+                fh.write(chunk)
+            fh.close()
+            for g in self._guess_ext_magic(temp_path):
+                self._append_ext(extensions, g)
+
+            result = self._convert(temp_path, extensions, url=response.url, **kwargs)
+        finally:
+            try:
+                fh.close()
+            except Exception:
+                pass
+            os.unlink(temp_path)
+
+        return result
+
+    def _convert(
+    self, local_path: str, extensions: List[Union[str, None]], **kwargs
+    ) -> DocumentConverterResult:
+        error_trace = ""
+        for ext in extensions + [None]:
+            for converter in self._page_converters:
+                _kwargs = copy.deepcopy(kwargs)
+                if ext is None:
+                    if "file_extension" in _kwargs:
+                        del _kwargs["file_extension"]
+                else:
+                    _kwargs.update({"file_extension": ext})
+    
+                _kwargs["_parent_converters"] = self._page_converters
+                if "style_map" not in _kwargs and self._style_map is not None:
+                    _kwargs["style_map"] = self._style_map
+    
+                try:
+                    res = converter.convert(local_path, **_kwargs)
+                    if res is not None:
+                        res.text_content = "\n".join(
+                            [line.rstrip() for line in re.split(r"\r?\n", res.text_content)]
+                        )
+                        res.text_content = re.sub(r"\n{3,}", "\n\n", res.text_content)
+                        return res
+                except Exception as e:
+                    # If this converter supports the extension and fails, raise the exception
+                    if ext is not None and converter.supports_extension(ext):
+                        raise FileConversionException(
+                            f"Could not convert '{local_path}' to Markdown with {converter.__class__.__name__} "
+                            f"for extension '{ext}'. The following error occurred:\n\n{traceback.format_exc()}"
+                        )
+                    # Otherwise, store the error and continue
+                    error_trace = ("\n\n" + traceback.format_exc()).strip()
+    
+        if len(error_trace) > 0:
+            raise FileConversionException(
+                f"Could not convert '{local_path}' to Markdown. File type was recognized as {extensions}. "
+                f"While converting the file, the following error was encountered:\n\n{error_trace}"
+            )
+        raise UnsupportedFormatException(
+            f"Could not convert '{local_path}' to Markdown. The formats {extensions} are not supported."
+        )
+
+    def _append_ext(self, extensions, ext):
+        if ext is None:
+            return
+        ext = ext.strip()
+        if ext == "":
+            return
+        extensions.append(ext)
+
+    def _guess_ext_magic(self, path):
+        try:
+            guesses = puremagic.magic_file(path)
+            extensions = list()
+            for g in guesses:
+                ext = g.extension.strip()
+                if len(ext) > 0:
+                    if not ext.startswith("."):
+                        ext = "." + ext
+                    if ext not in extensions:
+                        extensions.append(ext)
+            return extensions
+        except FileNotFoundError:
+            pass
+        except IsADirectoryError:
+            pass
+        except PermissionError:
+            pass
+        return []
+
+    def register_page_converter(self, converter: DocumentConverter) -> None:
+        self._page_converters.insert(0, converter)

app/services/RAG_evaluation.py

@@ -0,0 +1,85 @@
+from typing import Dict, Any
+import re
+from datetime import datetime
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from app.services.chathistory import ChatSession
+import os
+
+# # Set NLTK data path to a writable location
+# nltk_data_dir = os.path.join(os.getcwd(), "nltk_data")
+# os.makedirs(nltk_data_dir, exist_ok=True)
+# nltk.data.path.append(nltk_data_dir)
+
+# # Download NLTK resources to the specified directory
+# nltk.download('stopwords', download_dir=nltk_data_dir)
+# nltk.download('wordnet', download_dir=nltk_data_dir)
+
+
+class RAGEvaluation:
+    def __init__(self, token: str, page: int = 1, page_size: int = 5):
+        self.chat_session = ChatSession(token, "session_id")
+        self.page = page
+        self.page_size = page_size
+        self.lemmatizer = WordNetLemmatizer()
+        self.stop_words = set(stopwords.words('english'))
+
+    def _preprocess_text(self, text: str) -> str:
+        text = re.sub(r'[^a-zA-Z0-9\s]', '', text.lower())
+        words = text.split()
+        lemmatized_words = [self.lemmatizer.lemmatize(word) for word in words]
+        filtered_words = [word for word in lemmatized_words if word not in self.stop_words]
+        seen = set()
+        cleaned_words = []
+        for word in filtered_words:
+            if word not in seen:
+                seen.add(word)
+                cleaned_words.append(word)
+
+        return ' '.join(cleaned_words)
+
+    def _calculate_cosine_similarity(self, context: str, response: str) -> float:
+        clean_context = self._preprocess_text(context)
+        clean_response = self._preprocess_text(response)
+        vectorizer = TfidfVectorizer(vocabulary=clean_context.split())
+
+        try:
+            context_vector = vectorizer.fit_transform([clean_context])
+            response_vector = vectorizer.transform([clean_response])
+            return cosine_similarity(context_vector, response_vector)[0][0]
+        except ValueError:
+            return 0.0
+
+    def _calculate_time_difference(self, start_time: str, end_time: str) -> float:
+        start = datetime.fromisoformat(start_time)
+        end = datetime.fromisoformat(end_time)
+        return (end - start).total_seconds()
+
+    def _process_interaction(self, interaction: Dict[str, Any]) -> Dict[str, Any]:
+        processed = interaction.copy()
+        processed['accuracy'] = self._calculate_cosine_similarity(
+            interaction['context'],
+            interaction['response']
+        )
+        processed['overall_time'] = self._calculate_time_difference(
+            interaction['rag_start_time'],
+            interaction['rag_end_time']
+        )
+        return processed
+
+    def generate_evaluation_report(self) -> Dict[str, Any]:
+        raw_data = self.chat_session.get_save_details(
+            page=self.page,
+            page_size=self.page_size
+        )
+
+        return {
+            'total_interactions': raw_data['total_interactions'],
+            'page': raw_data['page'],
+            'page_size': raw_data['page_size'],
+            'total_pages': raw_data['total_pages'],
+            'results': [self._process_interaction(i) for i in raw_data['results']]
+        }

app/services/__init__.py

@@ -0,0 +1,32 @@
+# app/services/__init__.py
+from app.services.image_processor import ImageProcessor
+from app.services.image_classification_vit import SkinDiseaseClassifier
+from app.services.llm_model import Model
+from app.services.chat_processor import ChatProcessor
+from app.services.chathistory import ChatSession
+from app.services.environmental_condition import EnvironmentalData
+from app.services.prompts import *
+from app.services.RAG_evaluation import RAGEvaluation
+from app.services.report_process import Report
+from app.services.skincare_scheduler import SkinCareScheduler
+from app.services.vector_database_search import VectorDatabaseSearch
+from app.services.websearch import WebSearch
+from app.services.wheel import EnvironmentalConditions
+from app.services.MagicConvert import MagicConvert
+
+__all__ = [
+    "ImageProcessor",
+    "AISkinDetector",
+    "SkinDiseaseClassifier",
+    "Model", 
+    "ChatProcessor",
+    "ChatSession",
+    "EnvironmentalData",
+    "RAGEvaluation",
+    "Report",
+    "SkinCareScheduler",
+    "VectorDatabaseSearch",
+    "WebSearch",
+    "EnvironmentalConditions"
+    "MagicConvert"
+]

app/services/chat_processor.py

@@ -0,0 +1,278 @@
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+from concurrent.futures import ThreadPoolExecutor
+from yake import KeywordExtractor
+from app.services.chathistory import ChatSession
+from app.services.websearch import WebSearch
+from app.services.llm_model import Model
+from app.services.environmental_condition import EnvironmentalData
+from app.services.prompts import *
+from app.services.vector_database_search import VectorDatabaseSearch
+import re
+vectordb = VectorDatabaseSearch()
+
+class ChatProcessor:
+    def __init__(self, token: str, session_id: Optional[str] = None, num_results: int = 3, num_images: int = 3):
+        self.token = token
+        self.session_id = session_id
+        self.num_results = num_results
+        self.num_images = num_images
+        self.chat_session = ChatSession(token, session_id)
+        self.user_city = self.chat_session.get_city()
+        city = self.user_city if self.user_city else ''
+        self.environment_data = EnvironmentalData(city)
+        self.web_searcher = WebSearch(num_results=num_results, max_images=num_images)
+        self.web_search_required = True
+
+    def extract_keywords_yake(self, text: str, language: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
+        lang_code = "en"
+        if language.lower() == "urdu":
+            lang_code = "ur"
+
+        kw_extractor = KeywordExtractor(
+            lan=lang_code,
+            n=max_ngram_size,
+            top=num_keywords,
+            features=None
+        )
+        keywords = kw_extractor.extract_keywords(text)
+        return [kw[0] for kw in keywords]
+
+    def ensure_valid_session(self, title: str = None) -> str:
+        if not self.session_id or not self.session_id.strip():
+            self.chat_session.create_new_session(title=title)
+            self.session_id = self.chat_session.session_id
+        else:
+            try:
+                if not self.chat_session.validate_session(self.session_id, title=title):
+                    self.chat_session.create_new_session(title=title)
+                    self.session_id = self.chat_session.session_id
+            except ValueError:
+                self.chat_session.create_new_session(title=title)
+                self.session_id = self.chat_session.session_id
+        return self.session_id
+
+    def process_chat(self, query: str) -> Dict[str, Any]:
+        try:
+            profile = self.chat_session.get_name_and_age()
+            name = profile['name']
+            age = profile['age']
+            self.chat_session.load_chat_history()
+            self.chat_session.update_title(self.session_id,query)
+            history = self.chat_session.format_history()
+
+            history_based_prompt = HISTORY_BASED_PROMPT.format(history=history,query= query)
+
+            enhanced_query = Model().send_message_openrouter(history_based_prompt)
+
+            self.session_id = self.ensure_valid_session(title=enhanced_query)
+            permission = self.chat_session.get_user_preferences()
+            websearch_enabled  = permission.get('websearch', False)
+            env_recommendations = permission.get('environmental_recommendations', False)
+            personalized_recommendations = permission.get('personalized_recommendations', False)
+            keywords_permission = permission.get('keywords', False)
+            reference_permission = permission.get('references', False)
+            language = self.chat_session.get_language().lower()
+
+
+            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language = language)
+
+            if websearch_enabled :
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_web = executor.submit(self.web_searcher.search, enhanced_query)
+                    future_images = executor.submit(self.web_searcher.search_images, enhanced_query)
+                    web_results = future_web.result()
+                    image_results = future_images.result()
+
+                context_parts = []
+                references = []
+
+                for idx, result in enumerate(web_results, 1):
+                    if result['text']:
+                        context_parts.append(f"From Source {idx}: {result['text']}\n")
+                        references.append(result['link'])
+
+                context = "\n".join(context_parts)
+
+                if env_recommendations and personalized_recommendations:
+                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        history=history,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                elif personalized_recommendations:
+                    prompt = PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                elif env_recommendations :
+                    prompt = ENVIRONMENTAL_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                else:
+                    prompt = DEFAULT_PROMPT.format(
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+
+                prompt = prompt + language_prompt
+
+                response = Model().llm(prompt,enhanced_query)
+
+                keywords = ""
+
+                if (keywords_permission):
+                    keywords = self.extract_keywords_yake(response, language=language)
+                if (not reference_permission):
+                    references = ""
+
+                chat_data = {
+                    "query": enhanced_query,
+                    "response": response,
+                    "references": references,
+                    "page_no": "",
+                    "keywords": keywords,
+                    "images": image_results,
+                    "context": context,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+                return chat_data
+            
+            else:
+                attach_image = False
+
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_images = executor.submit(self.web_searcher.search_images, enhanced_query)
+                    image_results = future_images.result()
+
+                start_time = datetime.now(timezone.utc)
+
+                results = vectordb.search( query=enhanced_query, top_k=3)
+
+                context_parts = []
+                references = []
+                seen_pages = set() 
+
+                for result in results:
+                    confidence = result['confidence']
+                    if confidence > 60:
+                        context_parts.append(f"Content: {result['content']}")
+                        page = result['page']
+                        if page not in seen_pages:  # Only append if page is not seen
+                            references.append(f"Source: {result['source']}, Page: {page}")
+                            seen_pages.add(page)
+                        attach_image = True 
+
+                context = "\n".join(context_parts)
+
+                if not context or len(context) < 10:
+                    context = "There is no context found unfortunately"
+
+                if env_recommendations  and personalized_recommendations:
+                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age = age,
+                        history=history,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                elif personalized_recommendations:
+                    prompt = PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                elif env_recommendations :
+                    prompt = ENVIRONMENTAL_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+                else:
+                    prompt = DEFAULT_PROMPT.format(
+                        previous_history=history,
+                        context=context,
+                        current_query=enhanced_query
+                    )
+
+                prompt = prompt + language_prompt
+
+                response = Model().response = Model().llm(prompt,query)
+
+                end_time = datetime.now(timezone.utc)
+
+                keywords = ""
+
+                if (keywords_permission):
+                    keywords = self.extract_keywords_yake(response, language=language)
+                    
+                if (not reference_permission):
+                    references = ""
+
+                if  not attach_image:
+                    image_results = ""
+                    keywords = ""
+
+                chat_data = {
+                    "query": enhanced_query,
+                    "response": response,
+                    "references": references,
+                    "page_no": "",
+                    "keywords": keywords,
+                    "images": image_results,
+                    "context": context,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+                match = re.search(r'(## Personal Recommendations|## Environmental Considerations)', response)
+                if match:
+                    truncated_response = response[:match.start()].strip()
+                else:
+                    truncated_response = response
+                if not self.chat_session.save_details(session_id=self.session_id , context= context , query= enhanced_query , response=truncated_response , rag_start_time=start_time  , rag_end_time=end_time ):
+                    raise ValueError("Failed to save the RAG details")
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+                return chat_data
+
+        except Exception as e:
+            return {
+                "error": str(e),
+                "query": query,
+                "response": "Sorry, there was an error processing your request.",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+
+    def web_search(self, query: str) -> Dict[str, Any]:
+        if self.session_id and len(self.session_id) > 5:
+            return self.process_chat(query=query)
+        else:
+            return self.process_chat(query=query)

app/services/chathistory.py

@@ -0,0 +1,309 @@
+from app.database.database_query import DatabaseQuery
+import os
+import jwt
+from dotenv import load_dotenv
+from typing import Optional, Dict, List
+from bson import ObjectId
+from datetime import datetime
+
+load_dotenv()
+jwt_secret_key = os.getenv('JWT_SECRET_KEY')
+query = DatabaseQuery()
+
+class ChatSession:
+    def __init__(self, token: str , session_id: str):
+        self.token = token
+        self.session_id = session_id
+        self.chats = []
+        self.identity = self._decode_token(token)
+        self.query = query
+
+    def _decode_token(self, token: str) -> str:
+        try:
+            decoded_token = jwt.decode(token, jwt_secret_key, algorithms=["HS256"])
+            identity = decoded_token['sub']
+            return identity
+        except jwt.ExpiredSignatureError:
+            raise ValueError("The token has expired.")
+        except jwt.InvalidTokenError:
+            raise ValueError("Invalid token.")
+        except Exception as e:
+            raise ValueError(f"Failed to decode token: {e}")
+
+    def get_user_preferences(self) -> dict:
+        current_user = self.identity
+        preferences = self.query.get_user_preferences(current_user)
+        if preferences is not None:
+            return preferences
+        raise ValueError("Failed to fetch user preferences.")
+
+    def get_personalized_recommendation(self) -> Optional[str]:
+        current_user = self.identity
+        response = self.query.get_latest_questionnaire(current_user)
+
+        if not response:
+            return None
+
+        answers = response.get('answers', {})
+        if not answers:
+            return None
+
+        def format_answer(answer):
+            if answer is None:
+                return None
+            if isinstance(answer, str):
+                stripped_answer = answer.strip().lower()
+                if stripped_answer in ['none', ''] or len(stripped_answer) < 3:
+                    return None
+                return stripped_answer
+            if isinstance(answer, list):
+                filtered_answer = [item for item in answer if "Other" not in item
+                                   and item.strip().lower() not in ['none', '']
+                                   and len(item.strip()) >= 3]
+                return ", ".join(filtered_answer) if filtered_answer else None
+            return answer
+
+        questions = {
+            "skinType": "How would you describe your skin type?",
+            "currentConditions": "Do you currently have any skin conditions?",
+            "autoImmuneConditions": "Do you have a history of autoimmune or hormonal conditions?",
+            "allergies": "Do you have any known allergies to skincare ingredients?",
+            "medications": "Are you currently taking any medications that might affect your skin?",
+            "hormonal": "Do you experience hormonal changes that affect your skin?",
+            "diet": "Have you noticed any foods that trigger skin reactions?",
+            "diabetes": "Do you have diabetes?",
+            "outdoorTime": "How much time do you spend outdoors during the day?",
+            "sleep": "How many hours of sleep do you get on average?",
+            "familyHistory": "Do you have a family history of skin conditions?",
+            "products": "What skincare products are you currently using?"
+        }
+
+        valid_answers = {key: format_answer(answers.get(key))
+                         for key in questions
+                         if format_answer(answers.get(key)) is not None}
+
+        if not valid_answers:
+            return None
+
+        formatted_response = []
+        for key, answer in valid_answers.items():
+            question = questions.get(key)
+            formatted_response.append(f"question: {question}\nUser answer: {answer}")
+
+        profile = self.get_profile()
+        name = profile.get('name', 'Unknown')
+        age = profile.get('age', 'Unknown')
+
+        return f"user name: {name}\nuser age: {age}\n\n" + "\n\n".join(formatted_response)
+
+
+    def create_new_session(self, title: str = None) -> bool:
+        current_user = self.identity
+        session_id = str(ObjectId())
+
+        chat_session = {
+            "user_id": current_user,
+            "session_id": session_id,
+            "created_at": datetime.utcnow(),
+            "last_accessed": datetime.utcnow(),
+            "title": title if title else "New Chat"
+        }
+
+        try:
+            self.query.create_chat_session(chat_session)
+            self.session_id = session_id
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to create session: {str(e)}")
+
+    def verify_session_exists(self, session_id: str) -> bool:
+        current_user = self.identity
+        return self.query.verify_session(session_id, current_user)
+
+    def validate_session(self, session_id: Optional[str] = None, title: str = None) -> bool:
+        if not session_id or not session_id.strip():
+            return self.create_new_session(title=title)
+
+        if self.verify_session_exists(session_id):
+            self.session_id = session_id
+            return self.load_chat_history()
+
+        return self.create_new_session(title=title)
+
+    def load_session(self, session_id: str) -> bool:
+        return self.validate_session(session_id)
+
+    def load_chat_history(self) -> bool:
+        if not self.session_id:
+            raise ValueError("No session ID provided.")
+
+        current_user = self.identity
+        try:
+            self.chats = self.query.get_session_chats(self.session_id, current_user)
+            return True
+        except Exception as e:
+            raise Exception(f"Failed to load chat history: {str(e)}")
+
+    def get_chat_history(self) -> List[Dict]:
+        return self.chats
+
+    def format_history(self) -> str:
+        formatted_chats = []
+        for chat in self.chats:
+            query = chat.get('query', '').strip()
+            response = chat.get('response', '').strip()
+            if query and response:
+                formatted_chats.append(f"User: {query}")
+                formatted_chats.append(f"Assistant: {response}")
+        return "\n".join(formatted_chats) if formatted_chats else ""
+
+    def save_chat(self, chat_data: Dict) -> bool:
+        if not self.session_id:
+            raise ValueError("No active session to save chat")
+
+        current_user = self.identity
+
+        data = {
+            "user_id": current_user,
+            "session_id": self.session_id,
+            "query": chat_data.get("query", "").strip(),
+            "response": chat_data.get("response", "").strip(),
+            "references": chat_data.get("references", []),
+            "page_no": chat_data.get("page_no", []),
+            "keywords": chat_data.get("keywords", []),
+            "images": chat_data.get("images", []),
+            "context": chat_data.get("context", ""),
+            "timestamp": datetime.utcnow(),
+            "chat_id": str(ObjectId())
+        }
+
+        try:
+            if self.query.create_chat(data):
+                self.query.update_last_accessed_time(self.session_id)
+                self.chats.append(data)
+                return True
+            return False
+        except Exception as e:
+            raise Exception(f"Failed to save chat: {str(e)}")
+
+    def get_name_and_age(self):
+        current_user = self.identity
+        try:
+            user_profile = self.query.get_user_profile(current_user)
+            return user_profile
+        except Exception as e:
+            raise Exception(f"Failed to get user name and age: {str(e)}")
+
+    def get_profile(self):
+        current_user = self.identity
+        try:
+            user = query.get_user_profile(current_user)
+            if not user:
+                return {'error': 'User not found'}
+            return {
+                'username': user['username'],
+                'email': user['email'],
+                'name': user['name'],
+                'age': user['age'],
+                'created_at': user['created_at']
+            }
+        except Exception as e:
+            return {'error': str(e)}
+
+    def update_title(self , sessionId , new_title):
+        query.update_chat_session_title(sessionId, new_title)
+
+    def get_city(self) -> Optional[str]:
+        current_user = self.identity
+        try:
+            location_data = self.query.get_location(current_user)
+            if location_data and 'location' in location_data:
+                return location_data['location']
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to get user city: {str(e)}")
+
+    def get_language(self) -> Optional[str]:
+        current_user = self.identity
+        try:
+            language = self.query.get_user_language(current_user)
+            if not language :
+                return "english"
+            else:
+                return language
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to get user city: {str(e)}")
+
+
+    def get_language(self) -> Optional[str]:
+        current_user = self.identity
+        try:
+            language = self.query.get_user_language(current_user)
+            if not language :
+                return "english"
+            else:
+                return language
+            return None
+        except Exception as e:
+            raise Exception(f"Failed to get user city: {str(e)}")
+
+    def get_today_schedule(self):
+        data = self.query.get_today_schedule(user_id=self.identity)
+        if not data:
+            return ""
+        return data
+
+    def save_schedule(self, schedule_data):
+        return self.query.save_schedule(user_id=self.identity, schedule_data=schedule_data)
+
+    def get_last_seven_days_schedules(self):
+        data = self.query.get_last_seven_days_schedules(user_id=self.identity)
+        if not data:
+            return ""
+        return data
+
+
+    def save_details(self, session_id, context, query, response, rag_start_time, rag_end_time):
+        data = self.query.save_rag_interaction(
+            user_id="admin",
+            session_id=session_id,
+            context=context,
+            query=query,
+            response=response,
+            rag_start_time=rag_start_time,
+            rag_end_time=rag_end_time
+        )
+        return data
+
+    def get_save_details(self, page: int, page_size: int) -> dict:
+        data = self.query.get_rag_interactions(
+            user_id="admin",
+            page=page,
+            page_size=page_size
+        )
+        return data
+    
+    def log_user_image_upload(self):
+        """Log an image upload for the current user"""
+        try:
+            return self.query.log_image_upload(self.identity)
+        except Exception as e:
+            raise ValueError(f"Failed to log image upload: {e}")
+
+    def get_user_daily_uploads(self):
+        """Get number of images uploaded by current user in the last 24 hours"""
+        try:
+            return self.query.get_user_daily_uploads(self.identity)
+        except Exception as e:
+            raise ValueError(f"Failed to get user daily uploads: {e}")
+
+    def get_user_last_upload_time(self):
+        """Get the timestamp of current user's most recent image upload"""
+        try:
+            return self.query.get_user_last_upload_time(self.identity)
+        except Exception as e:
+            raise ValueError(f"Failed to get user's last upload time: {e}")
+
+
+

app/services/environmental_condition.py

@@ -0,0 +1,70 @@
+import requests
+from bs4 import BeautifulSoup
+
+
+class EnvironmentalData:
+    def __init__(self, city):
+        self.city = city
+        self.aqi_url = f"https://api.waqi.info/feed/{city}/?token=466cde4d55e7c5d6cc658ad9c391214b593f46b9"
+        self.uv_url = f"https://www.weatheronline.co.uk/Pakistan/{city}/UVindex.html"
+
+    def fetch_aqi_data(self):
+        try:
+            response = requests.get(self.aqi_url)
+            data = response.json()
+
+            if data["status"] == "ok":
+                return {
+                    "Temperature": data["data"]["iaqi"].get("t", {}).get("v", "N/A"),
+                    "Humidity": data["data"]["iaqi"].get("h", {}).get("v", "N/A"),
+                    "Wind Speed": data["data"]["iaqi"].get("w", {}).get("v", "N/A"),
+                    "Pressure": data["data"]["iaqi"].get("p", {}).get("v", "N/A"),
+                    "AQI": data["data"].get("aqi", "N/A"),
+                    "Dominant Pollutant": data["data"].get("dominentpol", "N/A"),
+                }
+            return self.get_default_aqi_data()
+        except:
+            return self.get_default_aqi_data()
+
+    def get_default_aqi_data(self):
+        return {
+            "Temperature": "N/A",
+            "Humidity": "N/A",
+            "Wind Speed": "N/A",
+            "Pressure": "N/A",
+            "AQI": "N/A",
+            "Dominant Pollutant": "N/A"
+        }
+
+    def fetch_uv_data(self):
+        try:
+            response = requests.get(self.uv_url)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            gr1_elements = soup.find_all(class_='gr1')
+
+            if gr1_elements:
+                tr_elements = gr1_elements[0].find_all('tr')
+                if len(tr_elements) > 1:
+                    second_tr = tr_elements[1]
+                    td_elements = second_tr.find_all('td')
+                    if len(td_elements) > 1:
+                        return int(td_elements[1].text.strip())
+            return "N/A"
+        except:
+            return "N/A"
+
+    def get_environmental_data(self):
+        aqi_data = self.fetch_aqi_data()
+        uv_index = self.fetch_uv_data()
+
+        environmental_data = {
+            "Temperature": f"{aqi_data['Temperature']} °C" if aqi_data['Temperature'] != "N/A" else "N/A",
+            "Humidity": f"{aqi_data['Humidity']} %" if aqi_data['Humidity'] != "N/A" else "N/A",
+            "Wind Speed": f"{aqi_data['Wind Speed']} m/s" if aqi_data['Wind Speed'] != "N/A" else "N/A",
+            "Pressure": f"{aqi_data['Pressure']} hPa" if aqi_data['Pressure'] != "N/A" else "N/A",
+            "Air Quality Index": aqi_data['AQI'],
+            "Dominant Pollutant": aqi_data["Dominant Pollutant"],
+            "UV_Index": uv_index
+        }
+
+        return environmental_data

app/services/image_classification_vit.py

@@ -0,0 +1,110 @@
+import torch
+from PIL import Image
+import torch.nn.functional as F
+from torchvision import transforms
+from transformers import AutoModelForImageClassification, AutoConfig
+import requests
+from io import BytesIO
+import os
+from huggingface_hub import hf_hub_download
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+
+
+class SkinDiseaseClassifier:
+    CLASS_NAMES = [
+        "Acne", "Basal Cell Carcinoma", "Benign Keratosis-like Lesions", "Chickenpox", "Eczema", "Healthy Skin",
+        "Measles", "Melanocytic Nevi", "Melanoma", "Monkeypox", "Psoriasis Lichen Planus and related diseases",
+        "Seborrheic Keratoses and other Benign Tumors", "Tinea Ringworm Candidiasis and other Fungal Infections",
+        "Vitiligo", "Warts Molluscum and other Viral Infections"
+    ]
+
+    def __init__(self, repo_id="muhammadnoman76/skin-disease-classifier"):
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.repo_id = repo_id
+        self.model = self.load_trained_model()
+        self.transform = self.get_inference_transform()
+
+    def load_trained_model(self):
+        model_path= hf_hub_download(repo_id=self.repo_id, filename="healthy.pth", token=HUGGINGFACE_TOKEN)
+        
+        checkpoint = torch.load(model_path, map_location=self.device, weights_only=True)
+        classifier_weight = checkpoint['model_state_dict']['classifier.3.weight']
+        num_classes = classifier_weight.size(0)
+
+        config = AutoConfig.from_pretrained("google/vit-base-patch16-224-in21k", num_labels=num_classes)
+        model = AutoModelForImageClassification.from_pretrained(
+            "google/vit-base-patch16-224-in21k",
+            config=config,
+            ignore_mismatched_sizes=True
+        )
+
+        in_features = model.classifier.in_features
+        model.classifier = torch.nn.Sequential(
+            torch.nn.Linear(in_features, 512),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.3),
+            torch.nn.Linear(512, num_classes)
+        )
+
+        model.load_state_dict(checkpoint['model_state_dict'])
+        model = model.to(self.device)
+        if self.device.type == 'cuda':
+            model = model.half()
+
+        model.eval()
+        return model
+
+    def get_inference_transform(self):
+        return transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        ])
+
+    def load_image(self, image_input):
+        try:
+            if isinstance(image_input, Image.Image):
+                image = image_input
+            elif isinstance(image_input, str):
+                if image_input.startswith(('http://', 'https://')):
+                    response = requests.get(image_input)
+                    image = Image.open(BytesIO(response.content))
+                else:
+                    if not os.path.exists(image_input):
+                        raise FileNotFoundError(f"Image file not found: {image_input}")
+                    image = Image.open(image_input)
+            elif hasattr(image_input, 'read'):
+                image = Image.open(image_input)
+            else:
+                raise ValueError("Unsupported image input type")
+            return image.convert('RGB')
+        except Exception as e:
+            raise Exception(f"Error loading image: {str(e)}")
+
+    def predict(self, image_input, confidence_threshold=0.3):
+        try:
+            image = self.load_image(image_input)
+            image_tensor = self.transform(image).unsqueeze(0)
+            if self.device.type == 'cuda':
+                image_tensor = image_tensor.half()
+            image_tensor = image_tensor.to(self.device)
+            with torch.inference_mode():
+                outputs = self.model(pixel_values=image_tensor).logits
+                probabilities = F.softmax(outputs, dim=1)
+                confidence, predicted = torch.max(probabilities, 1)
+
+                confidence = confidence.item()
+                predicted_class_idx = predicted.item()
+                confidence_percentage = round(confidence * 100, 2)
+                predicted_class_name = self.CLASS_NAMES[predicted_class_idx]
+
+                return predicted_class_name, confidence_percentage
+
+        except Exception as e:
+            raise Exception(f"Error during prediction: {str(e)}")

app/services/image_processor.py

@@ -0,0 +1,459 @@
+from datetime import datetime, timezone, timedelta
+from typing import Dict, Any
+from concurrent.futures import ThreadPoolExecutor
+from yake import KeywordExtractor
+from app.services.chathistory import ChatSession
+from app.services.websearch import WebSearch
+from app.services.llm_model import Model
+from app.services.environmental_condition import EnvironmentalData
+from app.services.prompts import *
+from app.services.vector_database_search import VectorDatabaseSearch
+from app.services.image_classification_vit import SkinDiseaseClassifier
+import io
+from PIL import Image
+import os
+import shutil
+from werkzeug.utils import secure_filename
+
+temp_dir = "temp"
+if not os.path.exists(temp_dir):
+    os.makedirs(temp_dir)
+
+upload_dir = "uploads"
+if not os.path.exists(upload_dir):
+    os.makedirs(upload_dir)
+
+class ImageProcessor:
+    def __init__(self, token: str, session_id: str, num_results: int, num_images: int, image):
+        self.token = token
+        self.image = image
+        self.session_id = session_id
+        self.num_results = num_results
+        self.num_images = num_images
+        self.vectordb = VectorDatabaseSearch()
+        self.chat_session = ChatSession(token, session_id)
+        self.user_city = self.chat_session.get_city()
+        city = self.user_city if self.user_city else ''
+        self.environment_data = EnvironmentalData(city)
+        self.web_searcher = WebSearch(num_results=num_results, max_images=num_images)
+
+    def extract_keywords_yake(self, text: str, language: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
+        lang_code = "en"
+        if language.lower() == "urdu":
+            lang_code = "ur"
+
+        kw_extractor = KeywordExtractor(
+            lan=lang_code,
+            n=max_ngram_size,
+            top=num_keywords,
+            features=None
+        )
+        keywords = kw_extractor.extract_keywords(text)
+        return [kw[0] for kw in keywords]
+
+    def ensure_valid_session(self, title: str = None) -> str:
+        if not self.session_id or not self.session_id.strip():
+            self.chat_session.create_new_session(title=title)
+            self.session_id = self.chat_session.session_id
+        else:
+            try:
+                if not self.chat_session.validate_session(self.session_id, title=title):
+                    self.chat_session.create_new_session(title=title)
+                    self.session_id = self.chat_session.session_id
+            except ValueError:
+                self.chat_session.create_new_session(title=title)
+                self.session_id = self.chat_session.session_id
+        return self.session_id
+    
+    def validate_upload(self):
+        """Validate if user can upload an image based on daily limit and time restriction"""
+        try:
+            # Check daily upload limit
+            daily_uploads = self.chat_session.get_user_daily_uploads()
+            print(f"Daily uploads: {daily_uploads}")
+            
+            if daily_uploads >= 5:
+                if self.chat_session.get_language().lower() == "urdu":
+                    return False, "آپ کی روزانہ کی حد (5 تصاویر) پوری ہو چکی ہے۔ براہ کرم کل کوشش کریں۔"
+                else:
+                    return False, "You've reached your daily limit (5 images). Please try again tomorrow."
+            
+            # Check time between uploads
+            last_upload_time = self.chat_session.get_user_last_upload_time()
+            print(f"Last upload time: {last_upload_time}")
+            
+            if last_upload_time:
+                # Ensure last_upload_time is timezone-aware
+                if last_upload_time.tzinfo is None:
+                    # If naive, make it timezone-aware by attaching UTC
+                    last_upload_time = last_upload_time.replace(tzinfo=timezone.utc)
+                    
+                # Now get the current time (which is already timezone-aware)
+                now = datetime.now(timezone.utc)
+                
+                # Now both times are timezone-aware, so the subtraction will work
+                time_since_last = now - last_upload_time
+                print(f"Time since last: {time_since_last}")
+                
+                if time_since_last < timedelta(minutes=1):
+                    seconds_remaining = 60 - time_since_last.seconds
+                    print(f"Seconds remaining: {seconds_remaining}")
+                    
+                    if self.chat_session.get_language().lower() == "urdu":
+                        return False, f"براہ کرم {seconds_remaining} سیکنڈ انتظار کریں اور دوبارہ کوشش کریں۔"
+                    else:
+                        return False, f"Please wait {seconds_remaining} seconds before uploading another image."
+            
+            # Log this upload
+            result = self.chat_session.log_user_image_upload()
+            print(f"Logged upload: {result}")
+            return True, ""
+        except Exception as e:
+            print(f"Error in validate_upload: {str(e)}")
+            # Fail safely - if we can't validate, we should allow the upload
+            return True, ""
+
+    def process_chat(self, query: str) -> Dict[str, Any]:
+        try:
+            is_valid, message = self.validate_upload()
+            if not is_valid:
+                return {
+                    "query": query,
+                    "response": message,
+                    "references": "",
+                    "page_no": "",
+                    "keywords": "",
+                    "images": "",
+                    "context": "",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.session_id or ""
+                }
+
+            profile = self.chat_session.get_name_and_age()
+            name = profile['name']
+            age = profile['age']
+            self.chat_session.load_chat_history()
+            self.chat_session.update_title(self.session_id, query)
+            history = self.chat_session.format_history()
+            language = self.chat_session.get_language().lower()
+
+            filename = secure_filename(self.image.filename)
+            temp_path = os.path.join(temp_dir, filename)
+            upload_path = os.path.join(upload_dir, filename)
+
+            content = self.image.file.read()
+
+            with open(temp_path, 'wb') as buffer:
+                buffer.write(content)
+                self.image.file.seek(0)
+                
+            img_content = io.BytesIO(content)
+            pil_image = Image.open(img_content)
+            
+            self.image.file.seek(0)
+
+            def background_file_ops(src, dst):
+                shutil.copy2(src, dst)
+                os.remove(src)
+
+            with ThreadPoolExecutor(max_workers=1) as file_executor:
+                file_executor.submit(background_file_ops, temp_path, upload_path)
+
+            if language != "urdu":
+                response1 = "Please provide a clear image of your skin with good lighting and a proper angle, without any filters! we can only analysis the image of skin :)"
+                response3 = "You have healthy skin, MaShaAllah! I don't notice any issues at the moment. However, based on my current confidence level of {diseases_detection_confidence}, I recommend consulting a doctor for more detailed advice and analysis."
+                response4 = "I'm sorry, I'm not able to identify your skin condition yet as I'm still learning, but I hope to be able to detect any skin issues in the future. :) Right now, my confidence in identifying your skin is below 50%."
+                response5 = ADVICE_REPORT_SUGGESTION
+            else:
+                response1 = "براہ کرم اپنی جلد کی واضح تصویر اچھی روشنی اور مناسب زاویے سے فراہم کریں، کسی فلٹر کے بغیر! ہم صرف جلد کی تصویر کا تجزیہ کر سکتے ہیں"
+                response3 = "آپ کی جلد صحت مند ہے، ماشاءاللہ! مجھے اس وقت کوئی مسئلہ نظر نہیں آ رہا۔ تاہم، میری موجودہ اعتماد کی سطح {diseases_detection_confidence} کی بنیاد پر، میں مزید تفصیلی مشورے اور تجزیے کے لیے ڈاکٹر سے رجوع کرنے کی تجویز کرتا ہوں۔"
+                response4 = "معذرت، میں ابھی آپ کی جلد کی حالت کی شناخت کرنے کے قابل نہیں ہوں کیونکہ میں ابھی سیکھ رہا ہوں، لیکن مجھے امید ہے کہ مستقبل میں جلد کے کسی بھی مسئلے کو پہچان سکوں گا۔ :) اس وقت آپ کی جلد کی شناخت میں میرا اعتماد 50% سے کم ہے۔"
+                response5 = URDU_ADVICE_REPORT_SUGGESTION
+
+            model = Model()
+            result = model.llm_image(text=SKIN_NON_SKIN_PROMPT, image=pil_image)
+            result_lower = result.lower().strip()
+            is_negative = any(marker in result_lower for marker in ["<no>", "no"])
+    
+            if is_negative:
+                chat_data = {
+                    "query": query,
+                    "response": response1,
+                    "references": "",
+                    "page_no": filename,
+                    "keywords": "",
+                    "images": "",
+                    "context": "",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+
+                return chat_data
+
+            diseases_detector = SkinDiseaseClassifier()
+            diseases_name, diseases_detection_confidence = diseases_detector.predict(pil_image, 5)
+
+            if diseases_name == "Healthy Skin":
+                chat_data = {
+                    "query": query,
+                    "response": response3.format(diseases_detection_confidence=diseases_detection_confidence),
+                    "references": "",
+                    "page_no": filename,
+                    "keywords": "",
+                    "images": "",
+                    "context": "",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+
+                return chat_data
+
+            elif diseases_detection_confidence < 46:
+                chat_data = {
+                    "query": query,
+                    "response": response4,
+                    "references": "",
+                    "page_no": filename,
+                    "keywords": "",
+                    "images": "",
+                    "context": "",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+                return chat_data
+            
+            
+            if not result:
+                chat_data = {
+                    "query": query,
+                    "response": response1,
+                    "references": "",
+                    "page_no": filename,
+                    "keywords": "",
+                    "images": "",
+                    "context": "",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+
+                return chat_data
+
+            self.session_id = self.ensure_valid_session(title=query)
+            permission = self.chat_session.get_user_preferences()
+            websearch_enabled = permission.get('websearch', False)
+            env_recommendations = permission.get('environmental_recommendations', False)
+            personalized_recommendations = permission.get('personalized_recommendations', False)
+            keywords_permission = permission.get('keywords', False)
+            reference_permission = permission.get('references', False)
+            language = self.chat_session.get_language().lower()
+            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language=language)
+
+            if websearch_enabled:
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_web = executor.submit(self.web_searcher.search, diseases_name)
+                    future_images = executor.submit(self.web_searcher.search_images, diseases_name)
+                    web_results = future_web.result()
+                    image_results = future_images.result()
+
+                context_parts = []
+                references = []
+
+                for idx, result in enumerate(web_results, 1):
+                    if result['text']:
+                        context_parts.append(f"From Source {idx}: {result['text']}\n")
+                        references.append(result['link'])
+
+                context = "\n".join(context_parts)
+
+                if env_recommendations and personalized_recommendations:
+                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+                elif personalized_recommendations:
+                    prompt = PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+                elif env_recommendations:
+                    prompt = ENVIRONMENTAL_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+                else:
+                    prompt = DEFAULT_PROMPT.format(
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+
+                prompt = prompt + f"\the query is related to {diseases_name}" + language_prompt
+
+                llm_response = Model().llm(prompt, query)
+
+                response = response5.format(
+                    diseases_name=diseases_name,
+                    diseases_detection_confidence=diseases_detection_confidence,
+                    response=llm_response
+                )
+
+                keywords = ""
+
+                if keywords_permission:
+                    keywords = self.extract_keywords_yake(response, language=language)
+                if not reference_permission:
+                    references = ""
+
+                chat_data = {
+                    "query": query,
+                    "response": response,
+                    "references": references,
+                    "page_no": filename,
+                    "keywords": keywords,
+                    "images": image_results,
+                    "context": context,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+                return chat_data
+            
+            else:
+                attach_image = False
+
+                with ThreadPoolExecutor(max_workers=2) as executor:
+                    future_images = executor.submit(self.web_searcher.search_images, diseases_name)
+                    image_results = future_images.result()
+
+                results = self.vectordb.search(diseases_name , top_k= 3)
+
+                context_parts = []
+                references = []
+                seen_pages = set() 
+
+                for result in results:
+                    confidence = result['confidence']
+                    if confidence > 60:
+                        context_parts.append(f"Content: {result['content']}")
+                        page = result['page']
+                        if page not in seen_pages:
+                            references.append(f"Source: {result['source']}, Page: {page}")
+                            seen_pages.add(page)
+                        attach_image = True 
+
+                context = "\n".join(context_parts)
+                
+                if not context or len(context) < 10:
+                    context = "There is no context found unfortunately please do not answer anything and ignore previous information or recommendations that were mentioned earlier in the context."
+
+                if env_recommendations and personalized_recommendations:
+                    prompt = ENVIRONMENTAL_PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+                elif personalized_recommendations:
+                    prompt = PERSONALIZED_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        user_details=self.chat_session.get_personalized_recommendation(),
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+                elif env_recommendations:
+                    prompt = ENVIRONMENTAL_PROMPT.format(
+                        user_name=name,
+                        user_age=age,
+                        environmental_condition=self.environment_data.get_environmental_data(),
+                        previous_history=history,
+                        context=context,
+                        current_query=query
+                    )
+                else:
+                    prompt = DEFAULT_PROMPT.format(
+                        previous_history="",
+                        context=context,
+                        current_query=query
+                    )
+
+                prompt = prompt + f"\the query is related to {diseases_name}" + language_prompt
+
+                llm_response = Model().llm(prompt, query)
+
+                response = response5.format(
+                    diseases_name=diseases_name,
+                    diseases_detection_confidence=diseases_detection_confidence,
+                    response=llm_response
+                )
+
+                keywords = ""
+
+                if keywords_permission:
+                    keywords = self.extract_keywords_yake(response, language=language)
+                if not reference_permission:
+                    references = ""
+                if not attach_image:
+                    image_results = ""
+                    keywords = ""
+
+                chat_data = {
+                    "query": query,
+                    "response": response,
+                    "references": references,
+                    "page_no": filename,
+                    "keywords": keywords,
+                    "images": image_results,
+                    "context": context,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "session_id": self.chat_session.session_id
+                }
+                
+                if not self.chat_session.save_chat(chat_data):
+                    raise ValueError("Failed to save chat message")
+                return chat_data
+            
+        except Exception as e:
+            return {
+                "error": str(e),
+                "query": query,
+                "response": "Sorry, there was an error processing your request.",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+
+    def web_search(self, query: str) -> Dict[str, Any]:
+        if self.session_id and len(self.session_id) > 5:
+            return self.process_chat(query=query)
+        else:
+            return self.process_chat(query=query)

app/services/llm_model.py

@@ -0,0 +1,102 @@
+import json
+from google import genai
+from dotenv import load_dotenv
+import os
+from google import genai
+from google.genai import types
+import re
+from g4f.client import Client
+
+load_dotenv()
+
+class Model:
+    def __init__(self):
+        self.gemini_api_key = os.getenv("GEMINI_API_KEY")
+        self.gemini_model = os.getenv("GEMINI_MODEL")
+        self.client = genai.Client(api_key=self.gemini_api_key)
+
+    def fall_back_llm(self, prompt):
+        """Fallback method using gpt-4o-mini when Gemini fails"""
+        try:
+            response = Client().chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": prompt}],
+                    web_search=False
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Both primary and fallback models failed. Error: {str(e)}"
+        
+    def send_message_openrouter(self, prompt):
+        try:
+            response = self.client.models.generate_content(
+                model=self.gemini_model, 
+                contents=prompt
+            )
+            return response.text
+        except Exception as e:
+            print(f"Gemini failed: {str(e)}. Trying fallback model...")
+            return self.fall_back_llm(prompt)
+
+    def llm(self, prompt, query):
+        try:
+            combined_content = f"{prompt}\n\n{query}"
+            response = self.client.models.generate_content(
+                model=self.gemini_model, 
+                contents=combined_content
+            )
+            return response.text
+        except Exception as e:
+            print(f"Gemini failed: {str(e)}. Trying fallback model...")
+            return self.fall_back_llm(f"{prompt}\n\n{query}")
+        
+    def llm_image(self, text, image):
+        try:
+            response = self.client.models.generate_content(
+                model=self.gemini_model,
+                contents=[image, text],
+            )
+            return response.text
+        except Exception as e:
+            print(f"Error in llm_image: {str(e)}")
+            return f"Error: {str(e)}"
+
+    def clean_json_response(self, response_text):
+        """Clean the model's response to extract valid JSON."""
+        start = response_text.find('[')
+        end = response_text.rfind(']') + 1
+        if start != -1 and end != -1:
+            json_str = re.sub(r",\s*]", "]", response_text[start:end])
+            return json_str
+        return response_text
+
+    def skinScheduler(self, prompt, max_retries=3):
+        """Generate a skincare schedule with retries and cleaning."""
+        for attempt in range(max_retries):
+            try:
+                response = self.client.models.generate_content(
+                    model=self.gemini_model,
+                    contents=prompt
+                )
+                cleaned_response = self.clean_json_response(response.text)
+                return json.loads(cleaned_response)
+            except json.JSONDecodeError as je:
+                if attempt == max_retries - 1:
+                    # If all Gemini retries fail, try fallback model
+                    print(f"Gemini failed to produce valid JSON after {max_retries} retries. Trying fallback model...")
+                    fallback_response = self.fall_back_llm(prompt)
+                    try:
+                        cleaned_fallback = self.clean_json_response(fallback_response)
+                        return json.loads(cleaned_fallback)
+                    except json.JSONDecodeError:
+                        return {"error": f"Both models failed to produce valid JSON"}
+            except Exception as e:
+                # For other exceptions, go directly to fallback
+                print(f"Gemini API Error: {str(e)}. Trying fallback model...")
+                fallback_response = self.fall_back_llm(prompt)
+                try:
+                    cleaned_fallback = self.clean_json_response(fallback_response)
+                    return json.loads(cleaned_fallback)
+                except json.JSONDecodeError:
+                    return {"error": "Both models failed to produce valid JSON"}
+        return {"error": "Max retries reached"}

app/services/prompts.py

@@ -0,0 +1,483 @@
+NON_WEB_DEFAULT_PROMPT = """
+Previous Conversation Context:
+{previous_history}
+
+Note: If the current question is unrelated to the previous conversation, disregard the history and treat it as a new topic.
+
+**Instruction:**  
+- If the user's current question is related to the previous conversation, maintain continuity.  
+- If the current question is unrelated, smoothly transition to the new topic while remaining friendly and conversational.  
+
+**Your Role:**  
+You are a **Friendly Doctor/Dermatologist** who is approachable, knowledgeable, and easy to talk to. You not only address medical questions but also answer other non-medical queries in a concise, clear, and friendly manner.  
+---
+
+### Communication Style:  
+1. **Approachable & Warm:**  
+   - Be kind, conversational, and supportive.  
+   - Avoid overly formal or technical language unless the user explicitly asks for it.  
+
+2. **Direct & Clear:**  
+   - Provide straightforward, accurate answers.  
+   - Avoid long-winded or overly complicated explanations.  
+
+3. **Engaging & Adaptive:**  
+   - Engage naturally with the user and adapt to their tone or style.  
+   - Balance being informative with being personable.  
+
+---
+
+### Key Principles for Response:  
+1. **Be Consistently Helpful:**  
+   - Prioritize offering practical, actionable, and supportive advice.  
+   - If a question is outside your scope as a dermatologist, still aim to help by providing brief and accurate responses.  
+
+2. **Provide Guidance Based on Medical Knowledge:**  
+   - Share insights grounded in credible and up-to-date dermatological and medical understanding.  
+   - Avoid speculation and stay within the scope of evidence-based medicine.  
+
+3. **Ensure Enjoyable Interaction:**  
+   - Keep the tone friendly, relaxed, and enjoyable while staying professional.  
+   - Avoid coming across as robotic or overly formal.  
+
+4. **Handle Non-Medical Topics:**  
+   - If the user asks a non-medical question, address it concisely and directly without diverting too much.  
+
+---
+
+### Your Primary Objectives in Each Response:  
+1. **Understand the Query Clearly:**  
+   - Contextualize the current query against previous conversations.  
+   - If the query is unclear, ask politely for clarification.  
+
+2. **Deliver a High-Quality Answer:**  
+   - For medical topics, ensure the answer is medically accurate and understandable.  
+   - For non-medical topics, provide a helpful and to-the-point response.  
+
+3. **Maintain a Friendly and Approachable Tone:**  
+   - Balance being professional and conversational to make the user feel comfortable.  
+
+---
+
+**Current User Query:**  
+{current_query}  
+"""
+
+HISTORY_BASED_PROMPT = """
+You are an expert in formulating queries based on history. You have no concern with the answer to the user's question; your focus is solely on the question asked by the user.
+
+History: {history}
+
+new_question_by_human: {query}
+
+Given the conversation history and the new question, return only the concise question that should be understood by a web search engine. Ensure that the final question correctly reflects the context of the conversation, especially when a specific term (like things "disease", "person", "anything") is implied. Do not include any explanation or additional text, just return the final question and remember if the question is not related to history then just write the same question without changing anything even a single word.
+
+Weather what language give you, you should strictly just response english 
+"""
+
+DEFAULT_PROMPT = """
+Previous Conversation Context:
+{previous_history}
+
+Note: If the current question is unrelated to the previous conversation, disregard the history and treat it as a new topic. Do not much focus on previous history response more focus on query of user.
+
+You are a dermatology assistant. Your task is to answer the user's question based SOLELY on the following context. If the context doesn't contain enough information to fully answer the question, say so and provide only the information that is available in the context.
+
+Context:
+{context}
+User Question: {current_query}
+
+Answer the question using ONLY the information provided in the context above. Do not use any external knowledge or make assumptions. If the context doesn't provide enough information to answer fully, state that clearly.
+
+and please do not mention the instruction which I am given you strictly.
+"""
+
+
+WEB_SEARCH_FILTER_PROMPT_VECTOR_DB = """
+History: {history}
+new_question_by_human: {query}
+
+Return ONLY "yes" if the question requires factual information, current data, or specific knowledge that would benefit from web search. Return <NO_WEB_SEARCH_REQUIRED> if the question can be answered without external information.
+
+CRITICAL RULES:
+1. Output ONLY "yes" or <NO_WEB_SEARCH_REQUIRED> - nothing else
+2. Return "yes" for questions that need:
+   - Factual information
+   - Current events/data
+   - Specific details
+   - Statistics
+   - Product information
+   - Research findings
+   - Historical facts
+   - Technical specifications
+   
+3. Return <NO_WEB_SEARCH_REQUIRED> for:
+   - Greetings ("hi", "how are you")
+   - Basic chat
+   - Opinion questions
+   - Hypothetical scenarios
+   - Simple calculations
+   - Basic coding help
+   - General advice
+   - Logic puzzles
+   - Questions about the assistant
+
+4. If unclear, return <NO_WEB_SEARCH_REQUIRED>
+
+5.If question is related to medical term then return"yes".
+
+Most importantly that if any qustion ask before and its required  web search then allow it web search then use "yes"
+"""
+
+PERSONALIZED_PROMPT = """
+User who is talking to you name is {user_name} and age is {user_age}
+
+Here is User {user_name} Details:
+<user_details>
+{user_details}
+</user_details>
+
+Previous Conversation Context of user {user_name}:
+{previous_history}
+
+Note: If the current question is unrelated to the previous conversation, disregard the history and treat it as a new topic.
+
+You are a dermatology assistant. Your task is to answer the user's question based **solely** on the following context. If the context doesn't contain enough information to fully answer the question, state clearly that "I don't have enough information" and provide only the information that is available in the context.
+
+Context:
+{context}
+
+Here is User {user_name} Question: {current_query}
+
+Answer the question using **only** the information provided in the context above. Do not use any external knowledge or make assumptions. If the context doesn't provide enough information to answer fully, state clearly that "I don't have enough information".
+   
+After answering the question:
+1. First determine if the question is EXPLICITLY about a medical/dermatological topic
+   - If NO: Provide only the direct answer
+   - If YES: Then check if ALL these conditions are met:
+      * The question requires personalized medical advice AND
+      * The provided context contains relevant medical information AND
+      * The user details directly impact the medical condition
+      * dont show that you are using context for answer just behave like an friendly dermatologist and sound like human dermatologist and give answer even context is have not so much information but have bit knowledge about the query but never said (The context provided does not specifically mention or The context mentions that) just say what context say simple.
+
+2. Only if ALL above conditions are met in Step 1, include the following sections:
+   ## Personal Recommendations
+
+For all other cases, provide ONLY the direct answer with no additional sections or explanations about recommendations.
+
+Response Structure:
+   ## TITLE OF TOPIC
+   [Provide an answer strictly based on the provided context, and nothing else.]
+
+   [The following sections should ONLY be included if ALL medical conditions above are met:]
+   ## Personal Recommendations
+   
+   [At Last add this disclaimer]
+   *We acknowledge the possibility of errors, so it is always recommended to consult with a doctor for a thorough check-up.*
+"""
+
+ENVIRONMENTAL_PROMPT = """
+User who is talking to you name is {user_name} and age is {user_age}
+
+Environmental Condition of user {user_name} location 
+<environmental_info>
+{environmental_condition}
+</environmental_info>
+
+Previous Conversation Context of user {user_name}:
+{previous_history}
+
+Note: If the current question is unrelated to the previous conversation, disregard the history and treat it as a new topic.
+
+You are a dermatology assistant. Your task is to answer the user's question based **solely** on the following context. If the context doesn't contain enough information to fully answer the question, state clearly that "I don't have enough information" and provide only the information that is available in the context.
+
+Context:
+{context}
+
+Here is User {user_name} Question: {current_query}
+
+Answer the question using **only** the information provided in the context above. Do not use any external knowledge or make assumptions. If the context doesn't provide enough information to answer fully, state clearly that "I don't have enough information".
+
+After answering the question, if and only if:
+After answering the question:
+1. First determine if the question is EXPLICITLY about a medical/dermatological topic
+   - If NO: Provide only the direct answer
+   - If YES: Then check if ALL these conditions are met:
+      * The question requires personalized medical advice AND
+      * The provided context contains relevant medical information AND
+      * The user details directly impact the medical condition
+      * dont show that you are using context for answer just behave like an friendly dermatologist and sound like human dermatologist and give answer even context is have not so much information but have bit knowledge about the query but never said (The context provided does not specifically mention or The context mentions that) just say what context say simple.
+
+2. Only if ALL above conditions are met in Step 1, include the following sections:
+   ## Environmental Considerations
+   
+For all other cases, provide ONLY the direct answer with no additional sections or explanations about recommendations.
+
+Response Structure:
+   ## TITLE OF TOPIC
+   [Provide an answer strictly based on the provided context, and nothing else.]
+
+   [The following sections should ONLY be included if ALL medical conditions above are met:]
+   ## Environmental Considerations
+   
+   [At Last add this disclaimer]
+   *We acknowledge the possibility of errors, so it is always recommended to consult with a doctor for a thorough check-up.*
+"""
+
+
+ENVIRONMENTAL_PERSONALIZED_PROMPT = """
+User who is talking to you name is {user_name} and age is {user_age}
+
+Here is User {user_name} Details:
+<user_details>
+{user_details}
+</user_details>
+
+Environmental Condition of user {user_name} location 
+<environmental_info>
+{environmental_condition}
+</environmental_info>
+
+Previous Conversation Context of user {user_name}:
+{previous_history}
+
+Note: If the current question is unrelated to the previous conversation, disregard the history and treat it as a new topic.
+
+You are a dermatology assistant. Your task is to answer the user's question based **solely** on the following context. If the context doesn't contain enough information to fully answer the question, state clearly that "I don't have enough information" and provide only the information that is available in the context.
+
+Context:
+{context}
+
+Here is User {user_name} Question: {current_query}
+
+Answer the question using **only** the information provided in the context above. Do not use any external knowledge or make assumptions. If the context doesn't provide enough information to answer fully, state clearly that "I don't have enough information".
+   
+After answering the question:
+1. First determine if the question is EXPLICITLY about a medical/dermatological topic
+   - If NO: Provide only the direct answer
+   - If YES: Then check if ALL these conditions are met:
+      * The question requires personalized medical advice AND
+      * The provided context contains relevant medical information AND
+      * The user/environmental details directly impact the medical condition
+      * dont show that you are using context for answer just behave like an friendly dermatologist and sound like human dermatologist and give answer even context is have not so much information but have bit knowledge about the query but never said (The context provided does not specifically mention or The context mentions that) just say what context say simple.
+
+2. Only if ALL above conditions are met in Step 1, include the following sections:
+   ## Personal Recommendations
+   ## Environmental Considerations
+
+For all other cases, provide ONLY the direct answer with no additional sections or explanations about recommendations.
+
+Response Structure:
+   ## TITLE OF TOPIC
+   [Provide an answer strictly based on the provided context, and nothing else.]
+
+   [The following sections should ONLY be included if ALL medical conditions above are met:]
+   ## Personal Recommendations
+   ## Environmental Considerations
+
+   [At Last add this disclaimer]
+   *We acknowledge the possibility of errors, so it is always recommended to consult with a doctor for a thorough check-up.*
+"""
+
+MEDICAL_REPORT_ANALYSIS_PROMPT = """
+You are an advanced medical report analysis system specializing in dermatology. Your purpose is to analyze and interpret the medical report for patient with the highest level of accuracy and clinical relevance.
+
+CONTEXT AND CONSTRAINTS:
+- Base your analysis EXCLUSIVELY on the provided medical report content
+- Do not make assumptions or introduce external medical knowledge
+- Maintain strict medical privacy and confidentiality standards
+
+MEDICAL REPORT:
+{report}
+
+CURRENT QUERY:
+{current_query}
+
+ANALYSIS GUIDELINES:
+1. Primary Findings
+   - Identify and explain key clinical observations
+   - Highlight any critical diagnostic information
+   - Note any abnormal results or concerning findings
+
+2. Clinical Interpretation
+   - Analyze the findings in their clinical context
+   - Connect related symptoms and observations
+   - Identify any patterns or correlations in the data
+
+3. Response Format:
+   - Start with a clear, direct answer to the query
+   - Support your response with specific evidence from the report
+   - Use medical terminology appropriately with plain language explanations
+   - Clearly separate facts from interpretations
+   - Structure information in a logical, easy-to-follow manner
+
+4. Information Gaps:
+   - If any critical information is missing, clearly state: "The report does not contain sufficient information regarding [specific aspect]"
+   - Specify what additional information would be needed for a complete assessment
+
+IMPORTANT NOTES:
+- If the report contains laboratory values or measurements, include the relevant numbers and reference ranges
+- For any medical terms used, provide brief explanations in parentheses
+- If multiple interpretations are possible, list them in order of likelihood based on the report data
+- Flag any urgent or critical findings that may require immediate attention
+
+Please analyze the provided report and respond to the query while adhering to these guidelines. Maintain professional medical communication standards while ensuring clarity for the reader.
+
+    [At Last add this disclaimer]
+    *We acknowledge the possibility of errors, so it is always recommended to consult with a doctor for a thorough check-up.*
+    
+    And If the report is not Related to Medical the just write 
+    `Sorry Please upload Medical related Report`
+"""
+
+
+
+LANGUAGE_RESPONSE_PROMPT = """
+STRICT LANGUAGE REQUIREMENTS:
+1. Response must be written EXCLUSIVELY in {language} using its official script/orthography
+2. English terms ONLY permitted when:
+   - There's no direct translation (technical terms/proper nouns)
+   - Retention is crucial for meaning preservation
+3. STRICTLY PROHIBITED:
+   - Code-switching/mixing languages
+   - Transliterations of {language} words using Latin script
+   - Non-native punctuation/formatting
+4. Ensure:
+   - Correct grammatical structure for {language}
+   - Proper script-specific punctuation
+   - Native character set compliance
+5. Formatting must follow {language}'s typographical conventions
+6. If unsure about translations: Use native {language} equivalents first
+
+Respond ONLY in {language} script. Never include translations/explanations.
+"""
+
+
+SKIN_CARE_SCHEDULER = """As a skincare expert, generate a daily schedule based on:
+- User's skin profile: {personalized_condition}
+- Current environmental conditions: {environmental_values}
+- Historical routines: {historical_data}
+
+Create EXACTLY 5 entries in this JSON format:
+[
+  {{
+    "time": "6:00 AM - 8:00 AM",
+    "recommendation": "Cleanse with [Product Name]",
+    "icon": "💧",
+    "category": "morning"
+  }},
+  {{
+    "time": "8:00 AM - 10:00 AM",
+    "recommendation": "Apply [Sunscreen Name] SPF 50",
+    "icon": "☀️",
+    "category": "morning"
+  }},
+  {{
+    "time": "12:00 PM - 2:00 PM",
+    "recommendation": "Reapply sunscreen",
+    "icon": "🌤️",
+    "category": "afternoon"
+  }},
+  {{
+    "time": "6:00 PM - 8:00 PM",
+    "recommendation": "Evening cleansing routine",
+    "icon": "🌙",
+    "category": "evening"
+  }},
+  {{
+    "time": "9:00 PM - 11:00 PM",
+    "recommendation": "Night serum application",
+    "icon": "✨",
+    "category": "night"
+  }}
+]
+
+Important rules:
+1. Use only double quotes
+2. Maintain category order: morning, morning, afternoon, evening, night
+3. Include specific product names from historical data when available
+4. Never add comments or text outside the JSON array
+5. Time ranges must follow "HH:MM AM/PM - HH:MM AM/PM" format
+6. Use appropriate emojis for each activity
+"""
+
+
+DEFAULT_SCHEDULE = [
+    {
+        "time": "6:00 AM - 8:00 AM",
+        "recommendation": "Cleanse with a gentle cleanser",
+        "icon": "💧",
+        "category": "Dummy"
+    },
+    {
+        "time": "8:00 AM - 10:00 AM",
+        "recommendation": "Apply sunscreen SPF 30+",
+        "icon": "☀️",
+        "category": "morning"
+    },
+    {
+        "time": "12:00 PM - 2:00 PM",
+        "recommendation": "Reapply sunscreen if needed",
+        "icon": "🌤️",
+        "category": "afternoon"
+    },
+    {
+        "time": "6:00 PM - 8:00 PM",
+        "recommendation": "Evening cleansing routine",
+        "icon": "🌙",
+        "category": "evening"
+    },
+    {
+        "time": "9:00 PM - 11:00 PM",
+        "recommendation": "Apply night cream or serum",
+        "icon": "✨",
+        "category": "night"
+    }
+]
+
+DISEASE_BASED_PROMPT = """You are an expert at generating web search queries based on a predicted disease and user question. Use this format:
+
+Disease from image model: {disease_name}
+User question: {query}
+
+Generate a concise English search query that either:
+1. Combines disease name with question context when relevant, OR
+2. Returns original question unchanged if unrelated to disease
+
+Output ONLY the final search query. Never explain. Maintain original language intent but output must be English.
+
+Examples:
+- "How to treat?" → "{disease_name} treatment"
+- "Causes?" → "{disease_name} causes"
+- "Unrelated question" → "Unrelated question" 
+"""
+
+ADVICE_REPORT_SUGGESTION = """
+## Based on your Image Analysis:
+
+    
+We have identified the presence of {diseases_name} with a confidence level of {diseases_detection_confidence}.  
+
+
+{response}  
+"""
+
+URDU_ADVICE_REPORT_SUGGESTION = """
+## آپ کی تصویر کے تجزیے کی بنیاد پر:
+
+
+ہم نے {diseases_detection_confidence} کی اعتماد کی سطح کے ساتھ {diseases_name} کی موجودگی کی شناخت کی ہے۔
+
+
+{response}
+"""
+
+SKIN_NON_SKIN_PROMPT = """
+    You are an expert at analyzing whether an image shows human skin or not. 
+    Your task is to determine if the given image should be processed by a skin disease model. 
+    Examine the image carefully and provide a clear two-word response: 
+    answer <YES> if the image shows human skin, otherwise answer <NO>.
+"""
+
+
+

app/services/report_process.py

@@ -0,0 +1,93 @@
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any
+from yake import KeywordExtractor
+from app.services.chathistory import ChatSession
+from app.services.llm_model import Model
+from app.services.environmental_condition import EnvironmentalData
+from app.services.prompts import *
+from app.services.MagicConvert import MagicConvert
+
+class Report:
+    def __init__(self, token: str, session_id: Optional[str] = None):
+        self.token = token
+        self.session_id = session_id
+        self.chat_session = ChatSession(token, session_id)
+        self.user_city = self.chat_session.get_city()
+        city = self.user_city if self.user_city else ''
+        self.environment_data = EnvironmentalData(city)
+        self.markitdown = MagicConvert()
+
+    def extract_keywords_yake(self, text: str, max_ngram_size: int = 2, num_keywords: int = 4) -> list:
+        kw_extractor = KeywordExtractor(
+            lan="en",
+            n=max_ngram_size,
+            top=num_keywords,
+            features=None
+        )
+        keywords = kw_extractor.extract_keywords(text)
+        return [kw[0] for kw in keywords]
+
+    def ensure_valid_session(self, title: str = None) -> str:
+        if not self.session_id or not self.session_id.strip():
+            self.chat_session.create_new_session(title=title)
+            self.session_id = self.chat_session.session_id
+        else:
+            try:
+                if not self.chat_session.validate_session(self.session_id, title=title):
+                    self.chat_session.create_new_session(title=title)
+                    self.session_id = self.chat_session.session_id
+            except ValueError:
+                self.chat_session.create_new_session(title=title)
+                self.session_id = self.chat_session.session_id
+        return self.session_id
+
+    def process_chat(self, query: str, report_file: str, file_type: Optional[str] = None) -> Dict[str, Any]:
+        try:
+            profile = self.chat_session.get_name_and_age()
+            self.chat_session.update_title(self.session_id, query)
+            self.session_id = self.ensure_valid_session(title=query)
+            language = self.chat_session.get_language().lower()
+            language_prompt = LANGUAGE_RESPONSE_PROMPT.format(language=language)
+            if not report_file or not file_type:
+                return {
+                    "error": "Report file or file type missing",
+                    "query": query,
+                    "response": "Sorry, report file or file type is missing.",
+                    "timestamp": datetime.now(timezone.utc).isoformat()
+                }
+            report_file_name = report_file + " (File Uploaded)"
+            conversion_result = self.markitdown.magic(report_file)
+            report_text = conversion_result.text_content
+
+            prompt = MEDICAL_REPORT_ANALYSIS_PROMPT.format(
+                report=report_text,
+                current_query=query
+            )
+
+            response = Model().response = Model().llm(prompt + "\n" + language_prompt , query)
+            keywords = self.extract_keywords_yake(response)
+
+            chat_data = {
+                "query": report_file_name + "\n" +query,
+                "response": response,
+                "references": "",
+                "page_no": "",
+                "keywords": keywords,
+                "images": "",
+                "context": report_text,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "session_id": self.chat_session.session_id
+            }
+
+            if not self.chat_session.save_chat(chat_data):
+                raise ValueError("Failed to save chat message")
+
+            return chat_data
+
+        except Exception as e:
+            return {
+                "error": str(e),
+                "query": query,
+                "response": "Sorry, there was an error processing your request.",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }

app/services/skincare_scheduler.py

@@ -0,0 +1,62 @@
+import json
+import logging
+
+from app.services.chathistory import ChatSession
+from app.services.llm_model import Model
+from app.services.environmental_condition import EnvironmentalData
+from app.services.prompts import SKIN_CARE_SCHEDULER, DEFAULT_SCHEDULE
+
+class SkinCareScheduler:
+    def __init__(self, token, session_id):
+        self.token = token
+        self.session_id = session_id
+        self.chat_session = ChatSession(token, session_id)
+        self.user_city = self.chat_session.get_city() or ''
+        self.environment_data = EnvironmentalData(self.user_city)
+
+    def get_historical_data(self):
+        """Retrieve the last 7 days of schedules."""
+        schedules = self.chat_session.get_last_seven_days_schedules()
+        return [schedule["schedule_data"] for schedule in schedules]
+
+    def createTable(self):
+        """Generate and return a daily skincare schedule."""
+        try:
+            # Check for an existing valid schedule
+            existing_schedule = self.chat_session.get_today_schedule()
+            if existing_schedule and isinstance(existing_schedule.get("schedule_data"), list):
+                return json.dumps(existing_schedule["schedule_data"], indent=2)
+
+            # Gather input data
+            historical_data = self.get_historical_data()
+            personalized_condition = self.chat_session.get_personalized_recommendation() or "No specific skin conditions provided"
+            environmental_data = self.environment_data.get_environmental_data()
+
+            # Format the prompt
+            formatted_prompt = SKIN_CARE_SCHEDULER.format(
+                personalized_condition=personalized_condition,
+                environmental_values=json.dumps(environmental_data, indent=2),
+                historical_data=json.dumps(historical_data, indent=2)
+            )
+
+            # Generate schedule with the model
+            model = Model()
+            result = model.skinScheduler(formatted_prompt)
+
+            # Handle errors by falling back to default schedule
+            if isinstance(result, dict) and "error" in result:
+                logging.error(f"Model error: {result['error']}")
+                result = DEFAULT_SCHEDULE
+
+            # Validate basic structure (optional, but ensures 5 entries)
+            if not isinstance(result, list) or len(result) != 5:
+                logging.warning("Generated schedule invalid; using default.")
+                result = DEFAULT_SCHEDULE
+
+            # Save and return the schedule
+            self.chat_session.save_schedule(result)
+            return json.dumps(result, indent=2)
+
+        except Exception as e:
+            logging.error(f"Schedule generation failed: {str(e)}")
+            return json.dumps(DEFAULT_SCHEDULE, indent=2)

app/services/vector_database_search.py

@@ -0,0 +1,100 @@
+import os
+import uuid
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain_qdrant import Qdrant
+from qdrant_client import QdrantClient, models
+from dotenv import load_dotenv
+
+load_dotenv()
+
+os.environ["GOOGLE_API_KEY"] = os.getenv("GEMINI_API_KEY")
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+QDRANT_COLLECTION_NAME = os.getenv("QDRANT_COLLECTION_NAME")
+
+class VectorDatabaseSearch:
+    def __init__(self, collection_name=QDRANT_COLLECTION_NAME):
+        self.collection_name = collection_name
+        self.embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+        self.client = QdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY)
+        self._initialize_collection()
+        
+        self.vectorstore = Qdrant(
+            client=self.client,
+            collection_name=collection_name,
+            embeddings=self.embeddings
+        )
+
+    def _initialize_collection(self):
+        """Initialize Qdrant collection if it doesn't exist"""
+        try:
+            collections = self.client.get_collections()
+            if not any(c.name == self.collection_name for c in collections.collections):
+                self.client.create_collection(
+                    collection_name=self.collection_name,
+                    vectors_config=models.VectorParams(
+                        size=768,  
+                        distance=models.Distance.COSINE
+                    )
+                )
+                print(f"Created collection: {self.collection_name}")
+        except Exception as e:
+            print(f"Error initializing collection: {e}")
+
+    def add_pdf(self, pdf_path):
+        """Add PDF to vector database"""
+        try:
+            loader = PyPDFLoader(pdf_path)
+            docs = loader.load()
+            splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+            split_docs = splitter.split_documents(docs)
+            
+            book_name = os.path.splitext(os.path.basename(pdf_path))[0]
+            for doc in split_docs:
+                doc.metadata = {
+                    "source": book_name,
+                    "page": doc.metadata.get('page', 1),
+                    "id": str(uuid.uuid4())
+                }
+            
+            self.vectorstore.add_documents(split_docs)
+            print(f"Added {len(split_docs)} chunks from {book_name}")
+            return True
+        except Exception as e:
+            print(f"Error adding PDF: {e}")
+            return False
+
+    def search(self, query, top_k=5):
+        """Search documents based on query"""
+        try:
+            results = self.vectorstore.similarity_search_with_score(query, k=top_k)
+            
+            formatted = []
+            for doc, score in results:
+                formatted.append({
+                    "source": doc.metadata['source'],
+                    "page": doc.metadata['page'],
+                    "content": doc.page_content[:500],
+                    "confidence": round(score * 100, 2)
+                })
+            return formatted
+        except Exception as e:
+            print(f"Search error: {e}")
+            return []
+
+    def get_book_info(self):
+        """Retrieve list of unique book sources in the collection"""
+        try:
+            points = self.client.scroll(
+                collection_name=self.collection_name,
+                limit=1000,
+                with_payload=True
+            )[0]
+            
+            books = set(point.payload.get('source', '') for point in points if point.payload)
+            return list(books)
+        except Exception as e:
+            print(f"Error retrieving book info: {e}")
+            return []

app/services/websearch.py

@@ -0,0 +1,141 @@
+import re
+import warnings
+import requests
+from bs4 import BeautifulSoup
+import urllib.parse
+import time
+import random
+
+warnings.simplefilter('ignore', requests.packages.urllib3.exceptions.InsecureRequestWarning)
+
+class WebSearch:
+    def __init__(self, num_results=4, max_chars_per_page=6000 , max_images=10):
+        self.num_results = num_results
+        self.max_chars_per_page = max_chars_per_page
+        self.reference = []
+        self.results = []
+        self.max_images = max_images
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+        }
+
+    def extract_text_from_webpage(self, html_content):
+        soup = BeautifulSoup(html_content, "html.parser")
+        for tag in soup(["script", "style", "header", "footer", "nav", "form", "svg"]):
+            tag.extract()
+        visible_text = soup.get_text(strip=True)
+        return visible_text
+
+    def search(self, query):
+        results = []
+        encoded_query = urllib.parse.quote(query)
+        url = f'https://html.duckduckgo.com/html/?q={encoded_query}'
+
+        try:
+            with requests.Session() as session:
+                session.headers.update(self.headers)
+
+                response = session.get(url, timeout=10)
+                soup = BeautifulSoup(response.text, 'html.parser')
+                search_results = soup.find_all('div', class_='result')[:self.num_results]
+
+                from concurrent.futures import ThreadPoolExecutor, as_completed
+
+                def fetch_page(link):
+                    try:
+                        time.sleep(random.uniform(0.2, 0.5))
+                        page_response = session.get(link, timeout=5)
+                        page_soup = BeautifulSoup(page_response.text, 'lxml')
+
+                        [tag.decompose() for tag in page_soup(['script', 'style', 'header', 'footer', 'nav'])]
+
+                        text = ' '.join(page_soup.stripped_strings)
+                        return {
+                            'link': link,
+                            'text': text[:self.max_chars_per_page]
+                        }
+                    except Exception as e:
+                        return None
+
+                links = [result.find('a', class_='result__a')['href']
+                         for result in search_results
+                         if result.find('a', class_='result__a')]
+
+                with ThreadPoolExecutor(max_workers=min(len(links), 4)) as executor:
+                    future_to_url = {executor.submit(fetch_page, link): link for link in links}
+
+                    for future in as_completed(future_to_url):
+                        result = future.result()
+                        if result:
+                            results.append(result)
+
+                return results
+
+        except Exception as e:
+            return []
+
+    def search_images(self, query):
+        images = []
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1'
+        }
+
+        url = f"https://www.google.com/search?q={query}&tbm=isch&hl=en"
+        response = requests.get(url, headers=headers, verify=False)
+
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        for img in soup.find_all('img'):
+            src = img.get('src', '')
+            if src.startswith('http') and self.is_image_url(src):
+                images.append(src)
+
+        for script in soup.find_all('script'):
+            if script.string:
+                urls = re.findall(r'https?://[^\s<>"\']+?(?:\.(?:jpg|jpeg|png|gif|bmp|webp))', script.string)
+                for url in urls:
+                    if self.is_image_url(url):
+                        images.append(url)
+
+        alternative_url = f"https://www.google.com/search?q={query}&source=lnms&tbm=isch"
+        response = requests.get(alternative_url, headers=headers, verify=False)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        for script in soup.find_all('script'):
+            if script.string and 'AF_initDataCallback' in script.string:
+                matches = re.findall(r'https?://[^\s<>"\']+?(?:\.(?:jpg|jpeg|png|gif|bmp|webp))', script.string)
+                for url in matches:
+                    if self.is_image_url(url):
+                        images.append(url)
+
+        images = [self.clean_url(url) for url in images]
+
+        seen = set()
+        images = [x for x in images if not (x in seen or seen.add(x))]
+
+        return images[:self.max_images]
+
+    def is_image_url(self, url):
+        image_extensions = ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp')
+        return any(url.lower().endswith(ext) for ext in image_extensions)
+
+    def clean_url(self, url):
+        base_url = url.split('?')[0]
+        return base_url
+
+
+
+
+

app/services/wheel.py

@@ -0,0 +1,94 @@
+from app.services.chathistory import ChatSession
+from app.services.environmental_condition import EnvironmentalData
+
+
+def map_air_quality_index(aqi):
+    if aqi <= 50:
+        return {"displayValue": "Good", "value": aqi, "color": "#00C853"}
+    elif aqi <= 100:
+        return {"displayValue": "Moderate", "value": aqi, "color": "#FFB74D"}
+    elif aqi <= 150:
+        return {"displayValue": "Unhealthy Tolerate", "value": aqi, "color": "#FF7043"}
+    elif aqi <= 200:
+        return {"displayValue": "Unhealthy", "value": aqi, "color": "#E53935"}
+    else:
+        return {"displayValue": "Very Unhealthy", "value": aqi, "color": "#8E24AA"}
+
+
+def map_pollution_level(aqi):
+    if aqi <= 50:
+        return 20
+    elif aqi <= 100:
+        return 40
+    elif aqi <= 150:
+        return 60
+    elif aqi <= 200:
+        return 80
+    else:
+        return 100
+
+class CityNotProvidedError(Exception):
+    pass
+
+
+class EnvironmentalConditions:
+    def __init__(self, session_id):
+        self.session_id = session_id
+        self.chat_session = ChatSession(session_id, "session_id")
+        self.user_city = self.chat_session.get_city()
+
+        if not self.user_city:
+            raise CityNotProvidedError("City information is required but not provided")
+
+        self.city = self.user_city
+        self.environment_data = EnvironmentalData(self.city)
+
+    def get_conditon(self):
+        data = self.environment_data.get_environmental_data()
+
+        formatted_data = [
+            {
+                "label": "Humidity",
+                # Handle decimal values by converting to float first
+                "value": int(float(data['Humidity'].strip(' %'))),
+                "color": "#4FC3F7",
+                "icon": "FaTint",
+                "type": "numeric"
+            },
+            {
+                "label": "UV Rays",
+                "value": data['UV_Index'] * 10,
+                "color": "#FFB74D",
+                "icon": "FaSun",
+                "type": "numeric"
+            },
+            {
+                "label": "Pollution",
+                "value": map_pollution_level(data['Air Quality Index']),
+                "color": "#F06292",
+                "icon": "FaLeaf",
+                "type": "numeric"
+            },
+            {
+                "label": "Air Quality",
+                **map_air_quality_index(data['Air Quality Index']),
+                "icon": "FaCloud",
+                "type": "categorical"
+            },
+            {
+                "label": "Wind",
+                "value": float(data['Wind Speed'].strip(' m/s')) * 10,
+                "color": "#9575CD",
+                "icon": "FaWind",
+                "type": "numeric"
+            },
+            {
+                "label": "Temperature",
+                "value": int(float(data['Temperature'].strip(' °C'))),
+                "color": "#FF7043",
+                "icon": "FaThermometerHalf",
+                "type": "numeric"
+            }
+        ]
+
+        return formatted_data

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3'
+
+services:
+  api:
+    build: .
+    ports:
+      - "5000:5000"
+    volumes:
+      - ./temp:/app/temp
+      - ./uploads:/app/uploads
+    env_file:
+      - .env
+    restart: unless-stopped

pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "derm_ai"
+version = "0.1.0"
+description = "This is derm_ai backend"
+authors = [
+    { name = "Muhammad Noman", email = "muhammadnoman76@gmail.com" }
+]
+dependencies = [
+    "beautifulsoup4==4.13.4",
+    "fastapi==0.115.12",
+    "google-genai==1.13.0",
+    "huggingface_hub==0.30.2",
+    "langchain_community==0.3.23",
+    "langchain_google_genai==2.1.4",
+    "langchain_qdrant==0.2.0",
+    "langchain_text_splitters==0.3.8",
+    "nltk==3.9.1",
+    "numpy==2.2.4",
+    "pillow==11.2.1",
+    "pydantic[email]==2.11.3",
+    "pymongo==4.12.1",
+    "pypdf==5.4.0",
+    "PyJWT==1.7.1",
+    "python-dotenv==1.1.0",
+    "qdrant_client==1.14.2",
+    "requests==2.32.3",
+    "scikit-learn==1.6.1",
+    "sendgrid==6.11.0",
+    "torch==2.5.1",
+    "torchvision==0.20.1",
+    "transformers==4.51.3",
+    "werkzeug==3.1.3",
+    "yake==0.4.8",
+    "uvicorn==0.34.1",
+    "python-multipart==0.0.20",
+    "g4f==0.5.2.1",
+    "mammoth==1.9.0",
+    "markdownify==1.1.0",
+    "pandas==2.2.3",
+    "pdfminer.six==20250416",
+    "python-pptx==1.0.2",
+    "puremagic==1.28",
+    "charset-normalizer==3.4.1",
+    "pytesseract==0.3.13"
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"