first commit

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/intelligent_routing/train_data/training_data.json filter=lfs diff=lfs merge=lfs -text
+models/job_recommendation/train_data/training_data.json filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+myenv/
+
+# IDE
+.idea/
+.vscode/
+
+# Logs
+*.log
+test_results/
+models/*/test_results/
+
+# Environment variables
+.env
+.env.local
+
+# Google Cloud
+app.yaml
+credentials.json
+
+# Large training files
+models/intelligent_routing/train_data/training_data.json
+models/job_recommendation/train_data/training_data.json

README.md

@@ -1,14 +1,13 @@
 ---
-title: Hostel Management And Greivance Redressal System
-emoji: 🔥
+title: Hostel Management System
+emoji: 🏨
 colorFrom: blue
-colorTo: red
-sdk: streamlit
-sdk_version: 1.39.0
-app_file: app.py
+colorTo: green
+sdk: docker
+app_port: 7860
 pinned: false
-license: mit
-short_description: deployed the hmgrs
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Hostel Management System API
+
+This is a Flask-based API for hostel management with ML capabilities.

app.py

@@ -0,0 +1,59 @@
+import streamlit as st
+from datetime import datetime
+import logging
+from routes import (
+    translation_model, 
+    sentiment_model,
+    routing_model, 
+    job_model
+)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+
+# Page config
+st.set_page_config(
+    page_title="Hostel Management System",
+    page_icon="🏨",
+    layout="wide"
+)
+
+def main():
+    st.title("🏨 Hostel Management System")
+    
+    # Sidebar navigation
+    page = st.sidebar.selectbox(
+        "Select Service",
+        ["Translation", "Sentiment Analysis", "Grievance Routing", "Job Recommendation"]
+    )
+    
+    if page == "Translation":
+        translation_page()
+    elif page == "Sentiment Analysis":
+        sentiment_page()
+    elif page == "Grievance Routing":
+        routing_page()
+    else:
+        job_recommendation_page()
+
+def translation_page():
+    st.header("Translation Service")
+    user_message = st.text_area("Enter text to translate")
+    target_lang = st.selectbox("Select target language", ["English", "Spanish", "French", "German"])
+    
+    if st.button("Translate"):
+        if user_message:
+            result = translation_model.process_message({
+                "user_message": user_message,
+                "target_language": target_lang
+            })
+            st.success(result.get("translated_text", "Translation failed"))
+
+# Add similar functions for other pages...
+
+if __name__ == "__main__":
+    main()

config/__init__.py

@@ -0,0 +1 @@
+from .config import config_by_name, Config

config/config.py

@@ -0,0 +1,60 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class Config:
+    # API Configuration
+    API_VERSION = "v1"
+    API_TITLE = "Hostel Grievance System API"
+    DEBUG = os.getenv("DEBUG", True)
+    
+    # Security
+    SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-here")
+    JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", "your-jwt-secret-key")
+    
+    # Model Paths
+    INTELLIGENT_ROUTING_MODEL_PATH = "models/intelligent_routing/model/"
+    SENTIMENT_ANALYSIS_MODEL_PATH = "models/sentiment_analysis/model/"
+    MULTILINGUAL_TRANSLATION_MODEL_PATH = "models/multilingual_translation/model/"
+    JOB_RECOMMENDATION_MODEL_PATH = "models/job_recommendation/model/"
+    
+    # Data Paths
+    TRAIN_DATA_PATH = "train_data/training_data.json"
+    TEST_DATA_PATH = "test_data/test_data.json"
+    
+    # API Endpoints
+    INTELLIGENT_ROUTING_ENDPOINT = "/api/v1/intelligent-routing"
+    SENTIMENT_ANALYSIS_ENDPOINT = "/api/v1/sentiment-analysis"
+    MULTILINGUAL_TRANSLATION_ENDPOINT = "/api/v1/multilingual-translation"
+    JOB_RECOMMENDATION_ENDPOINT = "/api/v1/job-recommendation"
+    
+    # Model Parameters
+    BATCH_SIZE = 32
+    LEARNING_RATE = 0.001
+    EPOCHS = 10
+    
+    # Logging Configuration
+    LOG_LEVEL = "INFO"
+    LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    LOG_FILE = "app.log"
+
+class DevelopmentConfig(Config):
+    DEBUG = True
+    TESTING = False
+
+class ProductionConfig(Config):
+    DEBUG = False
+    TESTING = False
+
+class TestingConfig(Config):
+    DEBUG = True
+    TESTING = True
+
+# Configuration dictionary
+config_by_name = {
+    'dev': DevelopmentConfig,
+    'prod': ProductionConfig,
+    'test': TestingConfig
+}

dir_structure.md

@@ -0,0 +1,82 @@
+# Directory Structure
+
+```
+Directory Structure:
+📁 config
+  📄 __init__.py
+  📄 config.py
+📁 docs
+  📄 README.md
+  📄 ai_plan.md
+  📄 data_plan.md
+  📄 plan.md
+📁 models
+  📁 intelligent_routing
+    📁 saved_model
+      📄 model.keras
+    📁 test_data
+      📄 __init__.py
+      📄 test_data.json
+    📁 test_results
+      📄 confusion_matrix.png
+      📄 roc_curve.png
+      📄 test_report.json
+    📁 train_data
+      📄 __init__.py
+      📄 training_data.json
+    📄 generate_data.py
+    📄 model.py
+    📄 test_model.py
+    📄 train.py
+  📁 job_recommendation
+    📁 saved_model
+      📄 model.keras
+    📁 test_data
+      📄 __init__.py
+      📄 test_data.json
+    📁 test_results
+      📄 test_report.json
+    📁 train_data
+      📄 __init__.py
+      📄 training_data.json
+    📄 generate_data.py
+    📄 model.py
+    📄 test.py
+    📄 train.py
+  📁 multilingual_translation
+    📁 test_data
+      📄 __init__.py
+      📄 test_data.json
+    📁 test_results
+      📄 test_report.json
+    📁 train_data
+      📄 __init__.py
+      📄 training_data.json
+    📄 model.py
+    📄 test_model.py
+  📁 sentiment_analysis
+    📁 test_data
+      📄 __init__.py
+      📄 test_data.json
+    📁 test_results
+      📄 test_report.json
+    📁 train_data
+      📄 __init__.py
+      📄 training_data.json
+    📄 model.py
+    📄 test_model.py
+📁 test_results
+  📄 endpoint_test_results.json
+📁 utils
+  📄 __init__.py
+  📄 logger.py
+📄 .env
+📄 .gitignore
+📄 A.py
+📄 app.py
+📄 dir_structure.md
+📄 readme.md
+📄 requirements.txt
+📄 routes.py
+📄 test_endpoints.py
+```

docs/README.md

@@ -0,0 +1,251 @@
+# Hostel Grievance Redressal System
+
+## Overview
+
+The Hostel Grievance Redressal System is a web application designed to facilitate the submission, tracking, and resolution of grievances raised by hostel residents. It provides a user-friendly interface for residents to report issues and enables administrators to efficiently manage and resolve them.
+
+## Features
+
+- **User-friendly Interface**
+  - Simple and intuitive design for easy grievance submission by residents.
+
+- **Real-time Updates**
+  - Residents receive real-time updates on the status of their submitted grievances.
+
+- **Admin Dashboard**
+  - An administrative dashboard to manage and prioritize grievances effectively.
+
+- **Chatroom Integration**
+  - Real-time communication channels between workers and complainees. Whenever a complaint is filed, a dedicated chatroom (ticket) is created to facilitate direct interaction and efficient resolution.
+
+- **Multilingual Transcription Services**
+  - Automatically transcribes and translates grievance inputs from any language to ensure clear understanding and effective communication between parties, similar to YouTube's comment translation feature.
+
+- **AI-Powered Grievance Analysis**
+  - **Voice-to-Text Integration for Complaint Submission**
+    - Integrates voice recognition technology to allow residents to submit grievances via voice input, which is then transcribed and processed by the system. This enhances accessibility and convenience for users who prefer speaking over typing.
+
+## AI/ML Functionalities
+
+To enhance the Hostel Grievance Redressal System with cutting-edge AI/ML capabilities, the following functionalities are proposed. These features are technically challenging and essential for improving the system's efficiency and effectiveness.
+
+### 1. Intelligent Routing and Workflow Automation
+
+**Description:**
+Implement an AI-driven routing system that intelligently assigns grievances to the most suitable personnel or department based on multiple factors such as expertise, current workload, past resolution success rates, and urgency.
+
+**Implementation Highlights:**
+- **Machine Learning Algorithms:** Use reinforcement learning and multi-criteria decision-making models to optimize grievance assignment dynamically.
+- **Real-time Load Balancing:** Continuously assess the workload of administrators and adjust assignments to prevent bottlenecks.
+- **Adaptive Learning:** Allow the system to learn from past assignments and outcomes to improve future routing decisions.
+
+**Benefits:**
+- Ensures grievances are handled by the most appropriate and capable personnel.
+- Reduces resolution times by balancing workloads effectively.
+- Increases the overall efficiency and effectiveness of the grievance redressal process.
+
+### 2. Advanced Sentiment and Emotional Intelligence Analysis
+
+**Description:**
+Enhance sentiment analysis by incorporating emotional intelligence to better understand the nuances and underlying emotions in resident grievances. This involves detecting complex emotional states such as frustration, anger, satisfaction, or indifference.
+
+**Implementation Highlights:**
+- **Deep Learning Models:** Utilize transformer-based models like BERT or GPT for nuanced sentiment and emotion detection.
+- **Contextual Understanding:** Analyze the context of grievances to distinguish between different emotional tones and intensities.
+- **Response Optimization:** Tailor administrative responses based on the detected emotional state to improve communication efficacy and resident relations.
+
+**Benefits:**
+- Provides deeper insights into resident sentiments, enabling more empathetic and effective responses.
+- Helps prioritize grievances that carry strong negative emotions, ensuring timely attention to sensitive issues.
+- Enhances the overall user experience by addressing the emotional needs of residents.
+
+
+### 3. Context-Aware Chatbots for Initial Grievance Handling
+
+**Description:**
+Deploy intelligent chatbots that can handle initial interactions with residents, providing immediate assistance, answering common queries, and guiding users through the grievance submission process.
+
+**Implementation Highlights:**
+- **Conversational AI Models:** Use state-of-the-art models like GPT-4 to create context-aware and adaptive conversational agents.
+- **Intent Recognition:** Implement intent recognition to accurately understand and respond to resident queries and concerns.
+- **Seamless Handover:** Ensure smooth transition from chatbot interactions to human administrators when queries exceed the chatbot's capabilities.
+
+**Benefits:**
+- Provides residents with instant support and guidance, enhancing user experience.
+- Reduces the workload on human administrators by handling routine inquiries and submissions.
+- Ensures that residents receive timely assistance, increasing satisfaction and trust in the system.
+
+### 4. Anomaly Detection in Grievance Patterns
+
+**Description:**
+Detect unusual patterns or spikes in specific types of grievances using anomaly detection algorithms. Identifying such anomalies early can help in addressing systemic issues before they escalate.
+
+**Implementation Highlights:**
+- **Anomaly Detection Algorithms:** Implement algorithms like Isolation Forest or DBSCAN to identify outliers in grievance data.
+- **Real-time Monitoring:** Continuously monitor grievance submissions to detect anomalies as they occur.
+- **Alert Systems:** Set up alert mechanisms to notify administrators of detected anomalies for immediate action.
+
+**Benefits:**
+- Enables proactive identification of systemic issues within the hostel.
+- Helps in maintaining a stable and satisfactory living environment for residents.
+- Facilitates timely interventions to prevent minor issues from becoming major problems.
+
+## Technology Stack
+
+- **Frontend:** 
+  - **React.js:** For a responsive and dynamic user interface.
+  - **Tailwind CSS:** For a modern look and feel.
+
+- **Backend:** 
+  - **Node.js and Express.js:** For server-side development.
+
+- **Database:** 
+  - **PostgreSQL:** For reliable and scalable data storage.
+
+- **Real-time Communication:** 
+  - **Socket.io:** To enable live chatrooms between users and administrators.
+
+- **Translation Services:** 
+  - **Google Translate API** or similar services for multilingual transcription and translation features.
+
+- **AI/ML Technologies:**
+  - **Natural Language Processing (NLP):** Leveraging libraries like TensorFlow.js or spaCy for text analysis and sentiment detection.
+  - **Machine Learning Models:** Custom models for grievance categorization and predictive analytics using Python-based frameworks such as scikit-learn or TensorFlow.
+  - **Deep Learning Frameworks:** Utilizes transformer-based models like BERT or GPT for advanced sentiment and emotion analysis.
+  - **Knowledge Graph Tools:** Implements Neo4j or similar graph databases for constructing and managing knowledge graphs.
+  - **Conversational AI Platforms:** Integrates platforms like Dialogflow or Rasa for developing intelligent chatbots.
+
+## Styling with Tailwind CSS
+
+The application's UI is styled using Tailwind CSS, providing a modern and consistent design across all components.
+
+## Component Library
+
+This project utilizes the following component libraries:
+- **Preline**
+- **ComponentLand**
+  
+These libraries are used for cards, pages, and other reusable components.
+
+## Project Preview
+
+### Login Page
+
+![Login Page](./images/login(1).png)
+
+### Signup Page
+
+![Signup Page](./images/signup(2).png)
+
+### Student Dashboard
+
+![Student Dashboard](./images/studentDashboard(3).png)
+
+### Student Profile Info
+
+![Student Profile Info](./images/studentAccountInfo(9).png)
+
+### Student Submitting Complaint
+
+![Student Complaint Submission](./images/createComplaint(4).png)
+
+### Student Dashboard After Submitting Complaint
+
+![Student Complaint](./images/studentComplaint(5).png)
+
+### Warden Dashboard
+
+![Warden Dashboard](./images/wardenDashboard(6).png)
+
+### Warden Resolves Complaint (Clicking "Not Completed" Changes to "Completed")
+
+![Warden Complaint](./images/wardenResolvedComplaint(7).png)
+
+### Student Dashboard Updated
+
+![Student Dashboard Updated](./images/studentDashboardUpdated(8).png)
+
+### Schema Diagram
+
+![Entity Relationship Diagram](./images/hostelDatabaseErDiagram.png)
+
+## Getting Started
+
+To run the Hostel Grievance Redressal System locally, follow these steps:
+
+1. **Clone the repository:**
+    ```bash
+    git clone [repository_url]
+    ```
+
+2. **Navigate to the project directory:**
+    ```bash
+    cd [project_directory]
+    ```
+
+3. **Install dependencies:**
+    ```bash
+    npm install
+    ```
+
+4. **Configure the database:**
+    - Set up PostgreSQL and update the database configuration.
+
+5. **Run the backend server:**
+    ```bash
+    node server.js
+    ```
+
+6. **Run the application:**
+    ```bash
+    npm run dev
+    ```
+
+## Contributing
+
+Contributions are welcome! Please follow these steps to contribute:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bugfix.
+3. Commit your changes with clear messages.
+4. Push to your branch and create a pull request.
+
+## Future Enhancements
+
+- **Mobile Application:** 
+  - Develop a mobile version of the system for on-the-go grievance submission and tracking.
+
+- **Integration with Notification Systems:** 
+  - Implement SMS and email notifications to keep residents informed about the status of their grievances in real-time.
+
+- **Advanced Analytics Dashboard:** 
+  - Provide administrators with detailed analytics and reporting tools to monitor grievance trends, resolution efficiency, and overall system performance.
+
+# License
+
+This project is licensed under the [MIT License](LICENSE).
+
+# Contact
+
+For any questions or feedback, please contact [your-email@example.com](mailto:your-email@example.com).
+
+**Description:**
+Deploy intelligent chatbots that can handle initial interactions with residents, providing immediate assistance, answering common queries, and guiding users through the grievance submission process.
+
+**Implementation Highlights:**
+- **Conversational AI Models**: Use state-of-the-art models like GPT-4 to create context-aware and adaptive conversational agents.
+- **Intent Recognition**: Implement intent recognition to accurately understand and respond to resident queries and concerns.
+- **Seamless Handover**: Ensure smooth transition from chatbot interactions to human administrators when queries exceed the chatbot's capabilities.
+
+**Benefits:**
+- Provides residents with instant support and guidance, enhancing user experience.
+- Reduces the workload on human administrators by handling routine inquiries and submissions.
+- Ensures that residents receive timely assistance, increasing satisfaction and trust in the system.
+
+## Future Enhancements
+
+- **Mobile Application**: Develop a mobile version of the system for on-the-go grievance submission and tracking.
+  
+- **Integration with Notification Systems**: Implement SMS and email notifications to keep residents informed about the status of their grievances in real-time.
+
+- **Advanced Analytics Dashboard**: Provide administrators with detailed analytics and reporting tools to monitor grievance trends, resolution efficiency, and overall system performance.

docs/ai_plan.md

@@ -0,0 +1,936 @@
+# Detailed Implementation Plans for AI/ML Functionalities
+
+This section provides an in-depth guide on implementing each AI/ML functionality within the Hostel Grievance Redressal System. Each feature is broken down into its purpose, model design pipeline, training data requirements, and example input/output data to ensure a comprehensive understanding of the implementation process. Additionally, the system architecture will be designed as a Flask API to allow seamless interaction between different models and external applications.
+
+---
+
+## System Architecture Overview
+
+The Hostel Grievance Redressal System will be built as a centralized Flask API server that hosts all AI/ML models. This architecture allows different services and applications to interact with the models by sending HTTP requests containing input data and receiving the model predictions in response. Each AI/ML functionality is exposed through distinct endpoints, enabling modularity and scalability.
+
+### **Key Components**
+
+1. **Flask API Server**
+   - **Purpose:** Serve as the central hub for all AI/ML models, managing incoming requests and routing them to the appropriate model endpoints.
+   - **Features:**
+     - RESTful API design for standardized interactions.
+     - Authentication and authorization mechanisms to secure endpoints.
+     - Logging and monitoring to track usage and performance.
+
+2. **Model Endpoints**
+   - **Purpose:** Each AI/ML functionality is encapsulated within its dedicated endpoint, allowing independent interaction and management.
+   - **Endpoints:**
+     - `/api/intelligent-routing`
+     - `/api/sentiment-analysis`
+     - `/api/multilingual-translation`
+     - `/api/job-recommendation`
+
+3. **Data Handling and Validation**
+   - **Purpose:** Ensure that incoming data adheres to the required schemas and formats before processing.
+   - **Features:**
+     - Input validation using libraries like `pydantic` or `marshmallow`.
+     - Error handling to manage invalid or malformed requests gracefully.
+
+4. **Scalability and Deployment**
+   - **Purpose:** Deploy the Flask API server in a scalable environment to handle varying loads and ensure high availability.
+   - **Tools:**
+     - Docker for containerization.
+     - Kubernetes or cloud-based services (e.g., AWS, GCP) for orchestration.
+     - CI/CD pipelines for automated deployment and updates.
+
+---
+
+## 1. Intelligent Routing and Workflow Automation
+
+### **Purpose**
+The Intelligent Routing and Workflow Automation system aims to efficiently assign grievances to the most suitable personnel or department. By considering factors like expertise, current workload, past resolution success rates, urgency, and additional contextual information such as student location and floor-specific metrics, the system ensures that grievances are handled promptly and effectively.
+
+### **Model Design Pipeline**
+
+1. **Data Collection**
+   - **Grievance Data:** Includes grievance type, description, submission time, student details.
+   - **Staff Data:** Includes staff department, current workload, availability, past performance metrics.
+   - **Historical Assignments:** Records of past grievance assignments, resolutions, time taken, and outcomes.
+   - **Additional Data:**
+     - **Student Details:** Room number, hostel name, floor number in hostel (0, 1, 2, 3).
+     - **Floor Metrics:** Number of requests per floor, total delays.
+     - **Availability Data:**
+       - **Worker Availability:** Availability status of workers at specific times.
+       - **Student Availability:** Availability of students at specific times.
+
+2. **Data Preprocessing**
+   - **Cleaning:** Remove duplicates, handle missing values, and normalize data to ensure consistency.
+   - **Feature Engineering:** 
+     - Extract features such as grievance category, sentiment scores.
+     - Calculate staff availability and workload metrics.
+     - Incorporate student room number, hostel name, and floor number as categorical or numerical features.
+     - Aggregate data per floor: number of requests, delays.
+     - Include time-based features capturing worker and student availability.
+   - **Encoding:** Convert categorical data (e.g., grievance types, staff departments, hostel names) into numerical formats using techniques like One-Hot Encoding or Label Encoding to facilitate model training.
+
+3. **Model Selection**
+   
+   - **Reinforcement Learning (RL):** Utilizes RL algorithms to optimize the assignment strategy based on rewards (e.g., reduced resolution time). RL is suitable for dynamic environments where the system can learn optimal policies through interactions.
+     - **Advantages:**
+       - Capable of handling sequential decision-making processes.
+       - Learns from the consequences of actions, allowing for continuous improvement.
+     - **Use Case Justification:** Ideal for scenarios where assignments need to adapt based on real-time feedback and evolving conditions.
+   
+   - **Multi-Criteria Decision-Making (MCDM):** Implements models like Weighted Sum Model (WSM) or Analytic Hierarchy Process (AHP) to evaluate multiple factors influencing assignments.
+     - **Advantages:**
+       - Transparent decision-making process with easily interpretable weights for each criterion.
+       - Suitable for environments where decision factors are well-defined and static.
+     - **Use Case Justification:** Effective when prioritizing multiple, potentially conflicting criteria is essential, and interpretability of the decision process is required.
+   
+   - **Comparison and Selection Logic:**
+     - **RL** is preferred when the system benefits from learning and adapting over time with continuous feedback.
+     - **MCDM** is advantageous for its simplicity and clarity in scenarios with well-established criteria and limited need for adaptability.
+
+4. **Training the Model**
+   - **Reinforcement Learning:**
+     - Define the environment with states (current assignments, staff status, floor metrics) and actions (assignment decisions).
+     - Implement reward functions based on resolution efficiency, reduced delays, and satisfaction metrics.
+     - Train using algorithms like Q-Learning or Deep Q-Networks (DQN) which are effective for handling high-dimensional state spaces.
+   
+   - **MCDM:**
+     - Assign weights to different criteria based on their importance through expert input or statistical methods.
+     - Train the model using historical assignment data to optimize weight configurations, ensuring that the most critical factors influence decision-making appropriately.
+
+5. **Model Evaluation**
+   - **Metrics:** Resolution time, assignment accuracy, staff utilization rates, floor-specific delay reductions, and user satisfaction scores.
+   - **Cross-Validation:** Apply techniques like k-fold cross-validation to ensure model robustness and prevent overfitting.
+   - **Benchmarking:** Compare model performance against baseline methods (e.g., random assignment or rule-based systems) to quantify improvements.
+
+6. **Deployment**
+   - **Integration into Flask API:**
+     - Deploy the trained model as a Flask endpoint (`/api/intelligent-routing`) using scalable frameworks (e.g., TensorFlow Serving, FastAPI).
+     - **Endpoint Functionality:**
+       - **Input:** Grievance details in JSON format.
+       - **Output:** Assigned staff details and assignment metadata.
+     - **API Development:** Develop RESTful APIs for real-time grievance assignment, ensuring low latency and high availability.
+     - **Response Structure:**
+       ```json
+       {
+         "grievance_id": "G12346",
+         "assigned_staff_id": "S67890",
+         "assignment_timestamp": "2023-10-02T08:16:00Z",
+         "expected_resolution_time": "1 hour",
+         "floor_number": 2,
+         "hostel_name": "bh2",
+         "student_room_no": "204"
+       }
+       ```
+   - **Monitoring Tools:** Implement monitoring tools (e.g., Prometheus, Grafana) to track performance metrics and trigger alerts for anomalies.
+   - **Retraining Schedule:** Schedule periodic retraining with new data to maintain model accuracy and adaptability to changing patterns.
+
+7. **Interacting with the Model**
+   - **API Requests:** External applications can interact with the Intelligent Routing model by sending POST requests to `/api/intelligent-routing` with grievance data.
+   - **Example Request:**
+     ```json
+     {
+       "grievance_id": "G12346",
+       "category": "electricity",
+       "submission_timestamp": "2023-10-02T08:15:00Z",
+       "student_room_no": "204",
+       "hostel_name": "bh2",
+       "floor_number": 2,
+       "current_staff_status": [
+         {
+           "staff_id": "S67890",
+           "department": "electricity",
+           "current_workload": 3,
+           "availability_status": "Available",
+           "past_resolution_rate": 0.95
+         },
+         {
+           "staff_id": "S67891",
+           "department": "plumber",
+           "current_workload": 2,
+           "availability_status": "Available",
+           "past_resolution_rate": 0.90
+         }
+       ],
+       "floor_metrics": {
+         "number_of_requests": 15,
+         "total_delays": 1
+       },
+       "availability_data": {
+         "staff_availability": [
+           {
+             "staff_id": "S67890",
+             "time_slot": "08:00-12:00",
+             "availability_status": "Available"
+           }
+         ],
+         "student_availability": [
+           {
+             "student_id": "STU204",
+             "time_slot": "08:00-10:00",
+             "availability_status": "Unavailable"
+           }
+         ]
+       }
+     }
+     ```
+
+### **Training Data Requirements**
+
+- **Grievance Dataset:**
+  - **Features:** Grievance ID, category, description, submission timestamp, student room number, hostel name, floor number.
+  - **Example:**
+    ```json
+    {
+      "grievance_id": "G12345",
+      "category": "plumber",
+      "submission_timestamp": "2023-10-01T10:30:00Z",
+      "student_room_no": "204",
+      "hostel_name": "bh1",
+      "floor_number": 2
+    }
+    ```
+
+- **Staff Dataset:**
+  - **Features:** Staff ID, department, current workload, availability status, past resolution rate.
+  - **Example:**
+    ```json
+    {
+      "staff_id": "S67890",
+      "department": "plumber",
+      "current_workload": 5,
+      "availability_status": "Available",
+      "past_resolution_rate": 0.95
+    }
+    ```
+
+- **Historical Assignments:**
+  - **Features:** Grievance ID, staff ID, assignment timestamp, resolution time, outcome, floor number.
+  - **Example:**
+    ```json
+    {
+      "grievance_id": "G12340",
+      "staff_id": "S67885",
+      "assignment_timestamp": "2023-09-25T09:00:00Z",
+      "resolution_time": "2 hours",
+      "outcome": "Resolved Successfully",
+      "floor_number": 1
+    }
+    ```
+
+- **Floor Metrics Dataset:**
+  - **Features:** Hostel name, floor number, date, number of requests, total delays.
+  - **Example:**
+    ```json
+    {
+      "hostel_name": "bh2",
+      "floor_number": 2,
+      "date": "2023-10-01",
+      "number_of_requests": 20,
+      "total_delays": 2
+    }
+    ```
+
+- **Availability Dataset:**
+  - **Features:** Staff ID, date, time slots, availability status; Student ID, date, time slots, availability status.
+  - **Example:**
+    ```json
+    {
+      "staff_id": "S67890",
+      "date": "2023-10-02",
+      "time_slot": "09:00-12:00",
+      "availability_status": "Available"
+    },
+    {
+      "student_id": "STU123",
+      "date": "2023-10-02",
+      "time_slot": "14:00-16:00",
+      "availability_status": "Unavailable"
+    }
+    ```
+
+### **Sample Input and Output**
+
+- **Sample Input:**
+  ```json
+  {
+    "grievance_id": "G12346",
+    "category": "electricity",
+    "submission_timestamp": "2023-10-02T08:15:00Z",
+    "student_room_no": "204",
+    "hostel_name": "bh2",
+    "floor_number": 2,
+    "current_staff_status": [
+      {
+        "staff_id": "S67890",
+        "department": "electricity",
+        "current_workload": 3,
+        "availability_status": "Available",
+        "past_resolution_rate": 0.95
+      },
+      {
+        "staff_id": "S67891",
+        "department": "plumber",
+        "current_workload": 2,
+        "availability_status": "Available",
+        "past_resolution_rate": 0.90
+      }
+    ],
+    "floor_metrics": {
+      "number_of_requests": 15,
+      "total_delays": 1
+    },
+    "availability_data": {
+      "staff_availability": [
+        {
+          "staff_id": "S67890",
+          "time_slot": "08:00-12:00",
+          "availability_status": "Available"
+        }
+      ],
+      "student_availability": [
+        {
+          "student_id": "STU204",
+          "time_slot": "08:00-10:00",
+          "availability_status": "Unavailable"
+        }
+      ]
+    }
+  }
+  ```
+
+- **Sample Output:**
+  ```json
+  {
+    "grievance_id": "G12346",
+    "assigned_staff_id": "S67890",
+    "assignment_timestamp": "2023-10-02T08:16:00Z",
+    "expected_resolution_time": "1 hour",
+    "floor_number": 2,
+    "hostel_name": "bh2",
+    "student_room_no": "204"
+  }
+  ```
+
+### **Allowable Field Values**
+
+1. **Category**: 
+   - electricity
+   - internet
+   - plumber
+   - water cooler
+   - sweeper
+   - carpenter
+
+2. **Floor Number**: 
+   - 0
+   - 1
+   - 2
+   - 3
+
+3. **Staff Department**: 
+   - electricity
+   - internet
+   - plumber
+   - water cooler
+   - sweeper
+   - carpenter
+
+4. **Availability Status**: 
+   - Available
+   - Unavailable
+
+5. **Hostel Name**: 
+   - bh1
+   - bh2
+   - bh3
+   - ivh
+   - gh
+
+6. **Student Room Number**: 
+   - Any valid room number string (e.g., "101", "204", etc.)
+
+7. **Staff ID**: 
+   - Any valid staff ID string (e.g., "S67890", "S67891", etc.)
+
+8. **Student ID**: 
+   - Any valid student ID string (e.g., "STU123", "STU204", etc.)
+
+9. **Grievance ID**: 
+   - Any valid grievance ID string (e.g., "G12345", "G12346", etc.)
+
+10. **Time Slot**: 
+    - Any valid time range string (e.g., "08:00-12:00", "14:00-16:00", etc.)
+
+11. **Resolution Time**: 
+    - Any valid time duration string (e.g., "1 hour", "2 hours", etc.)
+
+12. **Outcome**: 
+    - "Resolved Successfully"
+    - "Unresolved"
+    - "Pending"
+
+13. **Current Workload**: 
+    - Any non-negative integer
+
+14. **Past Resolution Rate**: 
+    - Any float value between 0 and 1 (inclusive)
+
+15. **Number of Requests**: 
+    - Any non-negative integer
+
+16. **Total Delays**: 
+    - Any non-negative integer
+
+---
+
+## 2. Advanced Sentiment and Emotional Intelligence Analysis
+
+### **Purpose**
+The Advanced Sentiment and Emotional Intelligence Analysis system enhances the understanding of resident grievances by detecting complex emotional states such as frustration, anger, satisfaction, or indifference. This enables more empathetic and effective responses from administrators.
+
+### **Model Design Pipeline**
+
+1. **Data Collection**
+   - **Grievance Texts:** Includes descriptions and any textual communication from residents.
+   - **Emotional Labels:** Annotated data indicating the emotional state of each grievance (e.g., frustrated, angry).
+
+2. **Data Preprocessing**
+   - **Text Cleaning:** Remove HTML tags, special characters, and perform lowercasing to standardize the text data.
+   - **Tokenization:** Split text into tokens (words or subwords) to prepare for feature extraction.
+   - **Removing Stop Words:** Eliminate common words that do not contribute to sentiment (e.g., "and", "the").
+   - **Stemming/Lemmatization:** Reduce words to their base forms to minimize variability.
+   - **Padding/Truncating:** Ensure uniform input length for model training, handling varying sentence lengths.
+
+3. **Feature Extraction**
+   - **Word Embeddings:** Utilize embeddings like BERT or Word2Vec to capture semantic meaning and contextual relationships between words.
+   - **Contextual Embeddings:** Employ transformer-based models to understand the context in which words are used, enhancing sentiment detection accuracy.
+
+4. **Model Selection**
+   - **Transformer-Based Models:** Utilize models like BERT, RoBERTa, or GPT-4 fine-tuned for sentiment and emotion detection.
+     - **Advantages:**
+       - Capable of understanding context and nuances in language.
+       - Pre-trained on large datasets, reducing the need for extensive training data.
+     - **Use Case Justification:** Ideal for capturing the subtleties in resident grievances, leading to more accurate emotional labeling.
+   
+   - **Hybrid Models:** Combine Long Short-Term Memory (LSTM) layers with transformers for enhanced performance.
+     - **Advantages:**
+       - LSTM layers can capture sequential dependencies, complementing transformer models.
+       - Provides a balance between computational efficiency and model complexity.
+     - **Use Case Justification:** Suitable when additional sequential information from the data can improve sentiment analysis.
+   
+   - **Comparison and Selection Logic:**
+     - **Transformer-Based Models** are preferred for their superior performance in understanding language context.
+     - **Hybrid Models** can be considered when specific sequential patterns in text need to be captured alongside contextual understanding.
+
+5. **Training the Model**
+   - **Fine-Tuning:** Pre-trained transformer models are fine-tuned on the labeled grievance dataset to adapt to the specific domain language and sentiment expressions.
+   - **Loss Function:** Use cross-entropy loss for multi-class classification to effectively handle multiple emotional categories.
+   - **Optimization:** Apply optimizers like Adam with appropriate learning rates to ensure efficient convergence and avoid overfitting.
+
+6. **Model Evaluation**
+   - **Metrics:** Precision, Recall, F1-Score, and Accuracy for each emotional category to assess the model's performance comprehensively.
+   - **Validation:** Use a dedicated validation set to prevent overfitting and ensure the model generalizes well to unseen data.
+   - **Confusion Matrix:** Analyze misclassifications to identify areas for improvement and understand model biases.
+
+7. **Deployment**
+   - **Integration into Flask API:**
+     - Deploy the trained model as a Flask endpoint (`/api/sentiment-analysis`) using scalable frameworks (e.g., TensorFlow Serving, FastAPI).
+     - **Endpoint Functionality:**
+       - **Input:** Grievance text in JSON format.
+       - **Output:** Predicted emotional label and confidence score.
+     - **API Development:** Develop RESTful APIs for receiving grievance texts and returning emotional insights, ensuring scalability and accessibility.
+     - **Response Structure:**
+       ```json
+       {
+         "grievance_id": "G12349",
+         "predicted_emotional_label": "Anger",
+         "confidence_score": 0.92
+       }
+       ```
+   - **Monitoring Tools:** Implement monitoring tools to track model performance and trigger alerts for potential degradation.
+   - **Retraining Schedule:** Schedule periodic model updates with new data to maintain accuracy and adapt to evolving sentiment expressions.
+
+8. **Interacting with the Model**
+   - **API Requests:** External applications can interact with the Sentiment Analysis model by sending POST requests to `/api/sentiment-analysis` with grievance text.
+   - **Example Request:**
+     ```json
+     {
+       "grievance_id": "G12349",
+       "text": "Why hasn't the maintenance team fixed the leaking roof yet? This is unacceptable!",
+       "emotional_label": null
+     }
+     ```
+
+### **Training Data Requirements**
+
+- **Grievance Dataset:**
+  - **Features:** Grievance ID, text, annotated emotional labels.
+  - **Example:**
+    ```json
+    {
+      "grievance_id": "G12347",
+      "text": "I am extremely frustrated with the constant power outages in my room.",
+      "emotional_label": "Frustration"
+    }
+    ```
+
+- **Emotional Labels:**
+  - **Categories:** Frustration, Anger, Satisfaction, Indifference, etc.
+  - **Example:**
+    ```json
+    {
+      "grievance_id": "G12348",
+      "text": "Thank you for resolving my issue so quickly.",
+      "emotional_label": "Satisfaction"
+    }
+    ```
+
+### **Sample Input and Output**
+
+- **Sample Input:**
+  ```json
+  {
+    "grievance_id": "G12349",
+    "text": "Why hasn't the maintenance team fixed the leaking roof yet? This is unacceptable!",
+    "emotional_label": null
+  }
+  ```
+
+- **Sample Output:**
+  ```json
+  {
+    "grievance_id": "G12349",
+    "predicted_emotional_label": "Anger",
+    "confidence_score": 0.92
+  }
+  ```
+
+---
+
+## 3. Multilingual Translation in Chatroom
+
+### **Purpose**
+The Multilingual Translation feature aims to facilitate seamless communication between residents and workers who may speak different languages. By automatically translating messages between the user's preferred language and the worker's default language (e.g., English), the system ensures clear and effective communication, thereby enhancing user experience and resolving grievances efficiently.
+
+### **Model Design Pipeline**
+
+1. **Data Collection**
+   - **Multilingual Conversation Logs:** Collect chat logs in multiple languages to understand common phrases and context-specific terminology used in grievances and responses.
+   - **Translation Pairs:** Gather datasets containing sentence pairs in source and target languages (e.g., Tamil-English) for training translation models.
+   - **Domain-Specific Vocabulary:** Compile a glossary of common terms related to hostel grievances (e.g., plumbing issues, electrical faults) in both languages to ensure accurate translations.
+
+2. **Data Preprocessing**
+   - **Cleaning:** Remove noise such as HTML tags, special characters, and correct typos in both source and target languages.
+   - **Tokenization:** Split text into tokens appropriate for each language, considering language-specific rules (e.g., agglutinative structures in Tamil).
+   - **Alignment:** Ensure that translation pairs are correctly aligned for supervised learning, maintaining the contextual integrity of conversations.
+   - **Normalization:** Convert all text to a consistent format (e.g., Unicode normalization) to handle different character encodings.
+
+3. **Feature Extraction**
+   - **Sentence Embeddings:** Utilize models like BERT multilingual or dedicated translation models to capture semantic meanings across languages.
+   - **Contextual Information:** Incorporate context from previous messages to improve translation accuracy, especially for ambiguous phrases and maintaining conversation flow.
+   - **Language Identification:** Implement language detection models to accurately identify the source and target languages of each message.
+
+4. **Model Selection**
+   - **Neural Machine Translation (NMT) Models:** Implement transformer-based models like Google's T5 or Facebook's M2M-100 for high-quality translations.
+     - **Advantages:**
+       - Capable of handling diverse language pairs with contextual understanding.
+       - Pre-trained models can be fine-tuned for specific domain vocabularies.
+     - **Use Case Justification:** Essential for providing accurate and context-aware translations between resident and worker languages.
+   
+   - **Hybrid Translation Systems:** Combine rule-based and neural approaches to enhance translation quality for language-specific nuances.
+     - **Advantages:**
+       - Better handling of idiomatic expressions and cultural context.
+       - Improved accuracy for low-resource language pairs.
+     - **Use Case Justification:** Suitable when dealing with languages that have complex grammatical structures or limited training data.
+   
+   - **Comparison and Selection Logic:**
+     - **NMT Models** are preferred for their superior performance in general translation tasks and adaptability through fine-tuning.
+     - **Hybrid Systems** are selected when specific language nuances and domain-specific terminology require additional rule-based adjustments to achieve higher accuracy.
+
+5. **Training the Model**
+   - **Fine-Tuning:** Adapt pre-trained NMT models on domain-specific translation pairs to ensure relevance in context (e.g., maintenance-related terminology).
+   - **Handling Dialects:** Incorporate regional dialects and colloquialisms to improve translation fidelity, ensuring that translations are contextually appropriate.
+   - **Optimization:** Use optimizers like Adam with learning rate scheduling to achieve efficient convergence without overfitting.
+   - **Data Augmentation:** Employ techniques like back-translation to augment the training dataset, enhancing model robustness and performance.
+
+6. **Model Evaluation**
+   - **Metrics:** BLEU (Bilingual Evaluation Understudy) score, METEOR, and human evaluation for translation accuracy and fluency.
+   - **Validation:** Create a diverse validation set that includes various dialects, slang, and context-specific phrases to test model robustness.
+   - **Error Analysis:** Identify common translation errors to iteratively improve the model, focusing on problematic language pairs or specific terms.
+   - **User Feedback:** Incorporate feedback from actual users to assess translation quality and identify areas needing improvement.
+
+7. **Deployment**
+   - **Integration into Flask API:**
+     - Deploy the trained translation model as a Flask endpoint (`/api/multilingual-translation`) using scalable frameworks (e.g., TensorFlow Serving, FastAPI).
+     - **Endpoint Functionality:**
+       - **Input:** User message with source and target language identifiers.
+       - **Output:** Translated message.
+     - **API Development:** Develop RESTful APIs that handle translation requests, ensuring low latency and high throughput to maintain real-time communication standards.
+     - **Response Structure:**
+       ```json
+       {
+         "translated_message": "There is no water coming in the toilet."
+       }
+       ```
+   - **Monitoring Tools:** Utilize monitoring tools to track translation service performance, latency, and error rates, ensuring timely detection and resolution of issues.
+   - **Retraining Schedule:** Schedule periodic updates and retraining sessions with new data to maintain translation accuracy and adapt to evolving language use patterns.
+
+8. **Interacting with the Model**
+   - **API Requests:** External applications can interact with the Multilingual Translation model by sending POST requests to `/api/multilingual-translation` with messages to be translated.
+   - **Example Request:**
+     ```json
+     {
+       "user_message": "toilet me paani nahi aa rha hain",
+       "source_language": "Hindi",
+       "target_language": "English"
+     }
+     ```
+
+### **Training Data Requirements**
+
+- **Conversation Dataset:**
+  - **Features:** User messages, worker responses, language identifiers, annotated intents, extracted entities.
+  - **Example:**
+    ```json
+    {
+      "user_message": "toilet me paani nahi aa rha hain",
+      "intent": "submit_grievance",
+      "entities": {
+        "grievance_type": "Water Supply",
+        "location": "Toilet"
+      },
+      "bot_response": "There is no water coming in the toilet.",
+      "detected_language": "Hindi",
+      "target_language": "English"
+    }
+    ```
+
+- **Translation Pairs:**
+  - **Features:** Source sentence, target sentence, language pair.
+  - **Example:**
+    ```json
+    {
+      "source_sentence": "toilet me paani nahi aa rha hain",
+      "target_sentence": "There is no water coming in the toilet.",
+      "language_pair": "Hindi-English"
+    }
+    ```
+
+### **Sample Input and Output**
+
+- **Sample Input:**
+  ```json
+  {
+    "user_message": "toilet me paani nahi aa rha hain",
+    "target_language": "English"
+  }
+  ```
+
+- **Sample Output:**
+  ```json
+  {
+    "translated_message": "There is no water coming in the toilet."
+  }
+  ```
+
+- **Sample Translation Scenario:**
+
+  - **Resident to Staff:**
+    - **Resident's Message:** "toilet me paani nahi aa rha hain"
+    - **Translated Message to Staff:** "There is no water coming in the toilet."
+
+  - **Staff's Response Back:**
+    - **Staff's Message:** "We will send a technician to fix the issue."
+    - **Translated Message to Resident:** "हम तकनीशियन को समस्या को ठीक करने के लिए भेजेंगे।"
+
+### **Implementation Considerations**
+- **Real-Time Translation:** Ensure that translations occur in real-time to maintain the flow of conversation without noticeable delays.
+- **Context Preservation:** Maintain the context of the conversation to ensure translations are accurate and contextually appropriate.
+- **User Control:** Allow users to enable or disable automatic translations based on their preferences.
+- **Error Handling:** Implement robust error handling to manage translation failures gracefully, including notifying users and providing manual translation options.
+- **Security and Privacy:** Ensure that all translated data is handled securely, complying with data privacy regulations, encrypting data in transit and at rest to protect sensitive information.
+
+### **Benefits**
+- **Enhanced Communication:** Bridges language barriers between residents and workers, ensuring clear and effective communication.
+- **Improved Efficiency:** Reduces misunderstandings and clarifications, speeding up the grievance resolution process.
+- **User Satisfaction:** Enhances user experience by providing support in the user's native language, fostering trust and reliability.
+- **Scalability:** Supports a diverse user base with multiple language preferences, making the system adaptable to various linguistic demographics.
+
+---
+
+## 6. Worker Job Recommendation
+
+### **Purpose**
+The Worker Job Recommendation system aims to optimize the assignment of specific jobs to workers based on various factors to save time and enhance efficiency. By considering the urgency of requests, proximity of tasks within the same floor or hostel, similarity in job descriptions, job success rates, and additional relevant factors, the system ensures that workers are assigned tasks that best match their skills and current context, thereby improving overall operational efficiency.
+
+### **Model Design Pipeline**
+
+1. **Data Collection**
+   - **Job Requests Data:** Details of all incoming job requests, including type, description, urgency level, location (floor, hostel), and timestamps.
+   - **Worker Profiles:** Information about workers, such as department, current assignments, availability, past performance, and job success rates.
+   - **Historical Assignments:** Records of past job assignments, including job types, worker assignments, time taken, and outcomes.
+   - **Spatial Data:** Mapping of tasks and worker locations to understand proximity and optimize assignments based on geographic density.
+
+2. **Data Preprocessing**
+   - **Cleaning:** Remove duplicates, handle missing values, and ensure the consistency of data across different datasets.
+   - **Feature Engineering:**
+     - Extract features such as job category, detailed descriptions, and urgency levels.
+     - Calculate workers' current workload and availability status.
+     - Incorporate location data to assess proximity.
+     - Analyze historical success rates to prioritize reliable workers.
+     - Map job types to relevant departments.
+   - **Encoding:** Convert categorical data (e.g., job types, hostel names) into numerical representations using One-Hot Encoding or Label Encoding to facilitate model training.
+
+3. **Model Selection**
+   - **Collaborative Filtering:** Utilize recommendation algorithms like Matrix Factorization or K-Nearest Neighbors to predict worker-job compatibility based on historical assignment patterns.
+     - **Advantages:**
+       - Effective in capturing latent relationships between workers and job types.
+       - Scales well with large datasets.
+     - **Use Case Justification:** Suitable for leveraging historical data to recommend appropriate worker assignments.
+   
+   - **Decision Trees/Random Forest:** Implement models to make assignment decisions based on importance of features such as urgency, proximity, and worker performance.
+     - **Advantages:**
+       - Handles both numerical and categorical data efficiently.
+       - Provides interpretability through feature importance.
+     - **Use Case Justification:** Ideal for scenarios where multiple factors influence assignment decisions and interpretability is important.
+   
+   - **Deep Learning Models:** Use neural networks to capture complex interactions between features for improved recommendation accuracy.
+     - **Advantages:**
+       - Capable of modeling non-linear relationships between features.
+       - Can integrate various data types seamlessly.
+     - **Use Case Justification:** Beneficial when the complexity of interactions between features necessitates more robust modeling capabilities.
+   
+   - **Comparison and Selection Logic:**
+     - **Collaborative Filtering** is chosen for its effectiveness in leveraging historical assignment data to recommend suitable workers.
+     - **Random Forest** is preferred when feature importance and interpretability are critical in understanding assignment decisions.
+     - **Deep Learning Models** are considered when the complexity of interactions between features necessitates more robust modeling capabilities.
+
+4. **Training the Model**
+   - **Data Splitting:** Divide the dataset into training, validation, and testing sets to evaluate model performance effectively.
+   - **Model Training:** Train selected models using the training data, ensuring they learn the optimal patterns for job-worker assignments.
+   - **Hyperparameter Tuning:** Optimize model parameters using techniques like Grid Search or Random Search to enhance performance.
+   - **Validation:** Use the validation set to fine-tune models and prevent overfitting by adjusting model complexity as necessary.
+
+5. **Model Evaluation**
+   - **Metrics:** Use evaluation metrics such as Precision, Recall, F1-Score, and Mean Absolute Error (MAE) to assess model performance.
+   - **Cross-Validation:** Apply k-fold cross-validation to ensure model robustness and generalizability across different data subsets.
+   - **Benchmarking:** Compare model performance against baseline assignment methods (e.g., manual assignment or rule-based systems) to quantify improvements.
+
+6. **Deployment**
+   - **Integration into Flask API:**
+     - Deploy the trained recommendation model as a Flask endpoint (`/api/job-recommendation`) using scalable frameworks (e.g., TensorFlow Serving, FastAPI).
+     - **Endpoint Functionality:**
+       - **Input:** Job request details and available workers in JSON format.
+       - **Output:** Assigned worker details and assignment metadata.
+     - **API Development:** Create RESTful APIs that handle job assignment requests, ensuring real-time recommendations with minimal latency.
+     - **Response Structure:**
+       ```json
+       {
+         "job_id": "J12346",
+         "assigned_worker_id": "W67890",
+         "assignment_timestamp": "2023-10-02T08:16:00Z",
+         "expected_resolution_time": "1 hour",
+         "location": {
+           "hostel_name": "Hostel A",
+           "floor_number": 2,
+           "room_number": "204"
+         }
+       }
+       ```
+   - **Monitoring Tools:** Implement monitoring tools (e.g., Prometheus, Grafana) to track model performance and system health, triggering alerts for any deviations.
+   - **Retraining Schedule:** Establish periodic retraining intervals using new assignment data to keep the model updated and maintain recommendation accuracy.
+
+7. **Interacting with the Model**
+   - **API Requests:** External applications can interact with the Job Recommendation model by sending POST requests to `/api/job-recommendation` with job and worker details.
+   - **Example Request:**
+     ```json
+     {
+       "job_id": "J12346",
+       "type": "Electrical",
+       "description": "Power outage in room 204.",
+       "urgency_level": "Critical",
+       "submission_timestamp": "2023-10-02T08:15:00Z",
+       "location": {
+         "hostel_name": "Hostel A",
+         "floor_number": 2,
+         "room_number": "204"
+       },
+       "workers": [
+         {
+           "worker_id": "W67890",
+           "department": "Electrical",
+           "current_workload": 3,
+           "availability_status": "Available",
+           "job_success_rate": 0.95,
+           "current_location": {
+             "hostel_name": "Hostel A",
+             "floor_number": 2,
+             "room_number": "210"
+           }
+         },
+         {
+           "worker_id": "W67891",
+           "department": "Mechanical",
+           "current_workload": 2,
+           "availability_status": "Available",
+           "job_success_rate": 0.90,
+           "current_location": {
+             "hostel_name": "Hostel A",
+             "floor_number": 2,
+             "room_number": "215"
+           }
+         }
+       ]
+     }
+     ```
+
+### **Training Data Requirements**
+
+- **Job Requests Dataset:**
+  - **Features:** Job ID, type, description, urgency level, location (floor, hostel), submission timestamp.
+  - **Example:**
+    ```json
+    {
+      "job_id": "J12345",
+      "type": "Electrical",
+      "description": "Fan not working in room 204.",
+      "urgency_level": "High",
+      "submission_timestamp": "2023-10-02T08:15:00Z",
+      "location": {
+        "hostel_name": "Hostel A",
+        "floor_number": 2,
+        "room_number": "204"
+      }
+    }
+    ```
+
+- **Worker Profiles Dataset:**
+  - **Features:** Worker ID, department, current workload, availability status, job success rates.
+  - **Example:**
+    ```json
+    {
+      "worker_id": "W67890",
+      "department": "Electrical",
+      "current_workload": 3,
+      "availability_status": "Available",
+      "job_success_rate": 0.95
+    }
+    ```
+
+- **Historical Assignments Dataset:**
+  - **Features:** Job ID, worker ID, assignment timestamp, resolution time, outcome, location.
+  - **Example:**
+    ```json
+    {
+      "job_id": "J12340",
+      "worker_id": "W67885",
+      "assignment_timestamp": "2023-09-25T09:00:00Z",
+      "resolution_time": "2 hours",
+      "outcome": "Resolved Successfully",
+      "location": {
+        "hostel_name": "Hostel A",
+        "floor_number": 1,
+        "room_number": "101"
+      }
+    }
+    ```
+
+- **Spatial Data Dataset:**
+  - **Features:** Worker locations, job locations, distance metrics.
+  - **Example:**
+    ```json
+    {
+      "worker_id": "W67890",
+      "current_location": {
+        "hostel_name": "Hostel A",
+        "floor_number": 2,
+        "room_number": "210"
+      },
+      "available_distance_radius": 50
+    }
+    ```
+
+### **Sample Input and Output**
+
+- **Sample Input:**
+  ```json
+  {
+    "job_id": "J12346",
+    "type": "Electrical",
+    "description": "Power outage in room 204.",
+    "urgency_level": "Critical",
+    "submission_timestamp": "2023-10-02T08:15:00Z",
+    "location": {
+      "hostel_name": "Hostel A",
+      "floor_number": 2,
+      "room_number": "204"
+    },
+    "workers": [
+      {
+        "worker_id": "W67890",
+        "department": "Electrical",
+        "current_workload": 3,
+        "availability_status": "Available",
+        "job_success_rate": 0.95,
+        "current_location": {
+          "hostel_name": "Hostel A",
+          "floor_number": 2,
+          "room_number": "210"
+        }
+      },
+      {
+        "worker_id": "W67891",
+        "department": "Mechanical",
+        "current_workload": 2,
+        "availability_status": "Available",
+        "job_success_rate": 0.90,
+        "current_location": {
+          "hostel_name": "Hostel A",
+          "floor_number": 2,
+          "room_number": "215"
+        }
+      }
+    ]
+  }
+  ```
+
+- **Sample Output:**
+  ```json
+  {
+    "job_id": "J12346",
+    "assigned_worker_id": "W67890",
+    "assignment_timestamp": "2023-10-02T08:16:00Z",
+    "expected_resolution_time": "1 hour",
+    "location": {
+      "hostel_name": "Hostel A",
+      "floor_number": 2,
+      "room_number": "204"
+    }
+  }
+  ```
+
+### **Additional Recommendation Factors**
+
+Beyond the factors provided, the following additional factors can enhance job recommendations:
+
+5. **Current Traffic Load:** The number of jobs currently assigned to nearby workers.
+6. **Department Specialization:** Specific expertise within general department categories (e.g., high-voltage electrical systems).
+7. **Worker's Past Performance in Similar Jobs:** Higher priority to workers who have successfully resolved similar issues efficiently.
+8. **Geographical Proximity:** Minimizing travel time by assigning jobs to the closest available worker.
+9. **Time of Day:** Allocating jobs considering workers' shift timings and peak activity periods.
+10. **Worker's Preferences:** Respecting workers' preferences for certain types of jobs or locations within their department.
+
+---
+
+# Conclusion
+
+Implementing these AI/ML functionalities will significantly enhance the efficiency and effectiveness of the Hostel Grievance Redressal System. By leveraging advanced technologies like reinforcement learning, transformer-based models, and anomaly detection algorithms, and by integrating them within a Flask API framework, the system will provide a more responsive, empathetic, and proactive approach to managing resident grievances. Proper data collection, preprocessing, model training, and continuous monitoring are crucial to the success of these implementations. Following the detailed steps outlined above will ensure a robust and scalable integration of AI/ML capabilities into the existing system.
+
+---
+
+# License
+
+This project is licensed under the [MIT License](LICENSE).
+
+# Contact
+
+For any questions or feedback, please contact [your-email@example.com](mailto:your-email@example.com).

docs/data_plan.md

@@ -0,0 +1,313 @@
+# Dataset Plan for AI/ML Models
+
+This document outlines the datasets required for implementing the AI/ML functionalities described in the ai_plan.md file. For each model, we'll provide the CSV structure and example records.
+
+## 1. Intelligent Routing and Workflow Automation
+
+### 1.1 Grievance Data (grievances.csv)
+
+Fields:
+- grievance_id (string)
+- category (string)
+- submission_timestamp (datetime)
+- student_room_no (string)
+- hostel_name (string)
+- floor_number (integer)
+
+Examples:
+```csv
+grievance_id,category,submission_timestamp,student_room_no,hostel_name,floor_number
+G12345,plumber,2023-10-01T10:30:00Z,204,bh1,2
+G12346,electricity,2023-10-02T08:15:00Z,101,bh2,1
+G12347,internet,2023-10-03T14:20:00Z,305,bh3,3
+G12348,water cooler,2023-10-04T09:45:00Z,102,ivh,1
+G12349,sweeper,2023-10-05T11:00:00Z,201,gh,2
+G12350,carpenter,2023-10-06T13:30:00Z,303,bh1,3
+```
+
+### 1.2 Staff Data (staff.csv)
+
+Fields:
+- staff_id (string)
+- department (string)
+- current_workload (integer)
+- availability_status (string)
+- past_resolution_rate (float)
+
+Examples:
+```csv
+staff_id,department,current_workload,availability_status,past_resolution_rate
+S67890,plumber,5,Available,0.95
+S67891,electricity,3,Available,0.92
+S67892,internet,4,Unavailable,0.88
+S67893,water cooler,2,Available,0.97
+S67894,sweeper,6,Available,0.91
+S67895,carpenter,1,Available,0.94
+```
+
+### 1.3 Historical Assignments (historical_assignments.csv)
+
+Fields:
+- grievance_id (string)
+- staff_id (string)
+- assignment_timestamp (datetime)
+- resolution_time (string)
+- outcome (string)
+- floor_number (integer)
+
+Examples:
+```csv
+grievance_id,staff_id,assignment_timestamp,resolution_time,outcome,floor_number
+G12340,S67890,2023-09-25T09:00:00Z,2 hours,Resolved Successfully,1
+G12341,S67891,2023-09-26T10:30:00Z,1 hour,Resolved Successfully,2
+G12342,S67892,2023-09-27T14:15:00Z,3 hours,Unresolved,3
+G12343,S67893,2023-09-28T11:45:00Z,30 minutes,Resolved Successfully,1
+G12344,S67894,2023-09-29T08:30:00Z,1 hour,Resolved Successfully,2
+G12345,S67895,2023-09-30T13:00:00Z,2 hours,Pending,3
+```
+
+### 1.4 Floor Metrics (floor_metrics.csv)
+
+Fields:
+- hostel_name (string)
+- floor_number (integer)
+- date (date)
+- number_of_requests (integer)
+- total_delays (integer)
+
+Examples:
+```csv
+hostel_name,floor_number,date,number_of_requests,total_delays
+bh1,2,2023-10-01,20,2
+bh2,1,2023-10-02,15,1
+bh3,3,2023-10-03,18,3
+ivh,1,2023-10-04,12,0
+gh,2,2023-10-05,22,4
+```
+
+### 1.5 Availability Data (availability.csv)
+
+Fields:
+- id (string)
+- type (string) # 'staff' or 'student'
+- date (date)
+- time_slot (string)
+- availability_status (string)
+
+Examples:
+```csv
+id,type,date,time_slot,availability_status
+S67890,staff,2023-10-02,09:00-12:00,Available
+S67891,staff,2023-10-02,14:00-17:00,Unavailable
+STU123,student,2023-10-02,10:00-12:00,Available
+STU124,student,2023-10-02,14:00-16:00,Unavailable
+S67892,staff,2023-10-03,08:00-11:00,Available
+STU125,student,2023-10-03,09:00-11:00,Available
+```
+
+## 2. Advanced Sentiment and Emotional Intelligence Analysis
+
+### 2.1 Grievance Sentiment Data (grievance_sentiment.csv)
+
+Fields:
+- grievance_id (string)
+- text (string)
+- emotional_label (string)
+
+Example:
+```csv
+grievance_id,text,emotional_label
+G12347,"I am extremely frustrated with the constant power outages in my room.",Frustration
+G12348,"Thank you for resolving my issue so quickly.",Satisfaction
+```
+
+## 3. Context-Aware Chatbots for Initial Grievance Handling
+
+### 3.1 Conversation Dataset (conversations.csv)
+
+Fields:
+- conversation_id (string)
+- user_message (string)
+- intent (string)
+- entities (string, JSON format)
+- bot_response (string)
+
+Example:
+```csv
+conversation_id,user_message,intent,entities,bot_response
+C12345,"I want to report a broken heater in my room.",submit_grievance,"{'grievance_type': 'Broken Heater', 'room_number': '305'}","I'm sorry to hear that. Could you please provide your room number?"
+```
+
+### 3.2 FAQs Dataset (faqs.csv)
+
+Fields:
+- question_id (string)
+- question (string)
+- answer (string)
+
+Example:
+```csv
+question_id,question,answer
+Q12345,"How can I check the status of my grievance?","You can check the status by logging into your dashboard and navigating to the 'My Grievances' section."
+```
+
+## 4. Anomaly Detection in Grievance Patterns
+
+### 4.1 Grievance Logs (grievance_logs.csv)
+
+Fields:
+- grievance_id (string)
+- category (string)
+- timestamp (datetime)
+- description (string)
+
+Example:
+```csv
+grievance_id,category,timestamp,description
+G12350,Plumbing,2023-10-03T14:20:00Z,"Clogged drain in the kitchen area."
+```
+
+### 4.2 Anomaly Indicators (anomaly_indicators.csv)
+
+Fields:
+- date (date)
+- category (string)
+- grievance_count (integer)
+- is_anomaly (boolean)
+
+Example:
+```csv
+date,category,grievance_count,is_anomaly
+2023-10-01,Electrical,50,false
+2023-10-02,Electrical,150,true
+```
+
+## 5. Multilingual Translation in Chatroom
+
+### 5.1 Translation Pairs (translation_pairs.csv)
+
+Fields:
+- pair_id (string)
+- source_language (string)
+- target_language (string)
+- source_sentence (string)
+- target_sentence (string)
+
+Example:
+```csv
+pair_id,source_language,target_language,source_sentence,target_sentence
+TP12345,Hindi,English,"toilet me paani nahi aa rha hain","There is no water coming in the toilet."
+```
+
+### 5.2 Language Preferences (language_preferences.csv)
+
+Fields:
+- user_id (string)
+- preferred_language (string)
+
+Example:
+```csv
+user_id,preferred_language
+U12345,Hindi
+W67890,English
+```
+
+## 6. Worker Job Recommendation
+
+### 6.1 Job Requests (job_requests.csv)
+
+Fields:
+- job_id (string)
+- type (string)
+- description (string)
+- urgency_level (string)
+- submission_timestamp (datetime)
+- hostel_name (string)
+- floor_number (integer)
+- room_number (string)
+
+Example:
+```csv
+job_id,type,description,urgency_level,submission_timestamp,hostel_name,floor_number,room_number
+J12345,Electrical,"Fan not working in room 204.",High,2023-10-02T08:15:00Z,Hostel A,2,204
+```
+
+### 6.2 Worker Profiles (worker_profiles.csv)
+
+Fields:
+- worker_id (string)
+- department (string)
+- current_workload (integer)
+- availability_status (string)
+- job_success_rate (float)
+
+Example:
+```csv
+worker_id,department,current_workload,availability_status,job_success_rate
+W67890,Electrical,3,Available,0.95
+```
+
+### 6.3 Historical Job Assignments (historical_job_assignments.csv)
+
+Fields:
+- job_id (string)
+- worker_id (string)
+- assignment_timestamp (datetime)
+- resolution_time (string)
+- outcome (string)
+- hostel_name (string)
+- floor_number (integer)
+- room_number (string)
+
+Example:
+```csv
+job_id,worker_id,assignment_timestamp,resolution_time,outcome,hostel_name,floor_number,room_number
+J12340,W67885,2023-09-25T09:00:00Z,2 hours,Resolved Successfully,Hostel A,1,101
+```
+
+### 6.4 Worker Locations (worker_locations.csv)
+
+Fields:
+- worker_id (string)
+- timestamp (datetime)
+- hostel_name (string)
+- floor_number (integer)
+- room_number (string)
+
+Example:
+```csv
+worker_id,timestamp,hostel_name,floor_number,room_number
+W67890,2023-10-02T08:00:00Z,Hostel A,2,210
+```
+```
+data/
+│
+├── intelligent_routing/
+│   ├── grievances.csv
+│   ├── staff.csv
+│   ├── historical_assignments.csv
+│   ├── floor_metrics.csv
+│   └── availability.csv
+│
+├── sentiment_analysis/
+│   └── grievance_sentiment.csv
+│
+├── chatbot/
+│   ├── conversations.csv
+│   └── faqs.csv
+│
+├── anomaly_detection/
+│   ├── grievance_logs.csv
+│   └── anomaly_indicators.csv
+│
+├── multilingual_translation/
+│   ├── translation_pairs.csv
+│   └── language_preferences.csv
+│
+└── job_recommendation/
+    ├── job_requests.csv
+    ├── worker_profiles.csv
+    ├── historical_job_assignments.csv
+    └── worker_locations.csv
+
+```

docs/plan.md

@@ -0,0 +1,864 @@
+# Project Plan for Hostel Grievance Redressal System
+
+## Table of Contents
+
+1. [Web Pages Design](#1-web-pages-design)
+    - [High-Level Design](#high-level-design)
+    - [Low-Level Design](#low-level-design)
+2. [Workflow and Event Flow](#2-workflow-and-event-flow)
+3. [Directory Structure and File Division](#3-directory-structure-and-file-division)
+4. [Backend and Frontend Separation](#4-backend-and-frontend-separation)
+5. [Performance Dashboard for Students](#5-performance-dashboard-for-students)
+
+---
+
+## 1. Web Pages Design
+
+### High-Level Design
+
+The Hostel Grievance Redressal System consists of several web pages tailored for different user roles: **Residents (Students)** and **Administrators (Wardens)**. Each page is designed to provide specific functionalities to enhance user experience and ensure efficient grievance management.
+
+#### Pages Overview
+
+1. **Authentication Pages**
+    - **Login Page**
+    - **Signup Page**
+
+2. **Resident Pages**
+    - **Student Dashboard**
+    - **Student Profile Information**
+    - **Submit Grievance**
+    - **View Submitted Grievances**
+    - **Grievance Details and Chatroom**
+
+3. **Administrator Pages**
+    - **Warden Dashboard**
+    - **Manage Grievances**
+    - **Resolve Grievance**
+    - **Performance Dashboard**
+
+4. **Common Components**
+    - **Navigation Bar**
+    - **Footer**
+    - **Notification System**
+
+### Low-Level Design
+
+#### 1. Authentication Pages
+
+##### Login Page
+- **Components:**
+    - **LoginForm**
+        - Email Input
+        - Password Input
+        - Submit Button
+    - **Forgot Password Link**
+    - **Signup Redirect Link**
+- **Functionality:**
+    - User enters credentials and submits to authenticate.
+    - Validation for input fields.
+    - Error handling for incorrect credentials.
+
+```markdown
+````react:src/frontend/components/LoginPage.js
+function LoginPage() {
+    return (
+        <div className="login-container">
+            <LoginForm />
+            <a href="/forgot-password">Forgot Password?</a>
+            <a href="/signup">Don't have an account? Sign Up</a>
+        </div>
+    );
+}
+```
+````
+
+##### Signup Page
+- **Components:**
+    - **SignupForm**
+        - Name Input
+        - Email Input
+        - Password Input
+        - Confirm Password Input
+        - Submit Button
+- **Functionality:**
+    - User registers by providing necessary details.
+    - Validation for input fields.
+    - Password strength indicator.
+
+```markdown
+````react:src/frontend/components/SignupPage.js
+function SignupPage() {
+    return (
+        <div className="signup-container">
+            <SignupForm />
+            <a href="/login">Already have an account? Login</a>
+        </div>
+    );
+}
+```
+````
+
+#### 2. Resident Pages
+
+##### Student Dashboard
+- **Components:**
+    - **Sidebar Navigation**
+    - **Recent Grievances**
+    - **Statistics Overview**
+    - **Quick Submit Button**
+- **Functionality:**
+    - Overview of submitted grievances.
+    - Quick access to submit new grievances.
+    - Visual statistics on grievance statuses.
+
+```markdown
+````react:src/frontend/pages/StudentDashboard.js
+function StudentDashboard() {
+    return (
+        <div className="dashboard-container">
+            <Sidebar />
+            <div className="dashboard-content">
+                <RecentGrievances />
+                <StatisticsOverview />
+                <QuickSubmitButton />
+            </div>
+        </div>
+    );
+}
+```
+````
+
+##### Student Profile Information
+- **Components:**
+    - **ProfileForm**
+        - Editable fields: Name, Email, Contact Number, Address
+        - Save Button
+    - **ProfilePictureUpload**
+- **Functionality:**
+    - View and edit personal information.
+    - Update profile picture.
+
+```markdown
+````react:src/frontend/pages/StudentProfile.js
+function StudentProfile() {
+    return (
+        <div className="profile-container">
+            <Sidebar />
+            <div className="profile-content">
+                <ProfileForm />
+                <ProfilePictureUpload />
+            </div>
+        </div>
+    );
+}
+```
+````
+
+##### Submit Grievance
+- **Components:**
+    - **GrievanceForm**
+        - Title Input
+        - Description Textarea
+        - Category Dropdown
+        - Attachments Upload
+        - Voice-to-Text Input
+        - Submit Button
+- **Functionality:**
+    - Allow residents to submit grievances with text or voice input.
+    - Attach relevant files if necessary.
+    - Categorize grievance for proper routing.
+
+```markdown
+````react:src/frontend/pages/SubmitGrievance.js
+function SubmitGrievance() {
+    return (
+        <div className="submit-grievance-container">
+            <Sidebar />
+            <div className="grievance-form-container">
+                <GrievanceForm />
+            </div>
+        </div>
+    );
+}
+```
+
+
+##### View Submitted Grievances
+- **Components:**
+    - **GrievanceList**
+        - List Item (GrievanceTitle, Status, Submission Date)
+    - **Filter and Search Bar**
+- **Functionality:**
+    - Display a list of grievances submitted by the student.
+    - Filter and search functionality for easy navigation.
+
+```markdown
+````react:src/frontend/pages/ViewGrievances.js
+function ViewGrievances() {
+    return (
+        <div className="view-grievances-container">
+            <Sidebar />
+            <div className="grievances-list-container">
+                <FilterSearchBar />
+                <GrievanceList />
+            </div>
+        </div>
+    );
+}
+```
+
+
+##### Grievance Details and Chatroom
+- **Components:**
+    - **GrievanceDetails**
+        - Grievance Information (Title, Description, Status, Assigned Warden)
+    - **Chatroom**
+        - Message List
+        - Input Box
+        - Send Button
+- **Functionality:**
+    - View detailed information about a specific grievance.
+    - Real-time chat with assigned warden for updates and communication.
+
+```markdown
+````react:src/frontend/pages/GrievanceDetails.js
+function GrievanceDetails({ grievanceId }) {
+    return (
+        <div className="grievance-details-container">
+            <Sidebar />
+            <div className="details-and-chat">
+                <GrievanceDetails />
+                <Chatroom grievanceId={grievanceId} />
+            </div>
+        </div>
+    );
+}
+```
+
+
+#### 3. Administrator Pages
+
+##### Warden Dashboard
+- **Components:**
+    - **Sidebar Navigation**
+    - **Grievances Overview**
+    - **Assigned Grievances**
+    - **Performance Metrics**
+- **Functionality:**
+    - Overview of all grievances.
+    - Manage assignments and track resolution progress.
+    - View performance metrics of handled grievances.
+
+```markdown
+````react:src/frontend/pages/WardenDashboard.js
+function WardenDashboard() {
+    return (
+        <div className="warden-dashboard-container">
+            <Sidebar />
+            <div className="warden-dashboard-content">
+                <GrievancesOverview />
+                <AssignedGrievances />
+                <PerformanceMetrics />
+            </div>
+        </div>
+    );
+}
+```
+
+
+##### Manage Grievances
+- **Components:**
+    - **GrievanceManagementList**
+        - Grievance Item (Title, Status, Assigned To, Actions)
+    - **Filter and Sort Options**
+- **Functionality:**
+    - View and manage all grievances.
+    - Assign grievances to appropriate personnel.
+    - Update grievance statuses.
+
+```markdown
+````react:src/frontend/pages/ManageGrievances.js
+function ManageGrievances() {
+    return (
+        <div className="manage-grievances-container">
+            <Sidebar />
+            <div className="management-content">
+                <FilterSortOptions />
+                <GrievanceManagementList />
+            </div>
+        </div>
+    );
+}
+```
+
+
+##### Resolve Grievance
+- **Components:**
+    - **ResolutionForm**
+        - Resolution Description
+        - Status Update Dropdown
+        - Attachments Upload
+        - Submit Resolution Button
+- **Functionality:**
+    - Provide resolution details for a grievance.
+    - Update the status to "Completed" or other relevant states.
+    - Notify the resident upon resolution.
+
+```markdown
+````react:src/frontend/pages/ResolveGrievance.js
+function ResolveGrievance({ grievanceId }) {
+    return (
+        <div className="resolve-grievance-container">
+            <Sidebar />
+            <div className="resolution-form-container">
+                <ResolutionForm grievanceId={grievanceId} />
+            </div>
+        </div>
+    );
+}
+```
+
+
+#### 4. Common Components
+
+##### Navigation Bar
+- **Components:**
+    - **Logo**
+    - **Navigation Links**
+    - **User Profile Dropdown**
+    - **Notifications Icon**
+- **Functionality:**
+    - Provide easy navigation across different pages.
+    - Access user profile and notifications.
+
+```markdown
+````react:src/frontend/components/NavigationBar.js
+function NavigationBar() {
+    return (
+        <nav className="navigation-bar">
+            <Logo />
+            <NavigationLinks />
+            <UserProfileDropdown />
+            <NotificationsIcon />
+        </nav>
+    );
+}
+```
+
+
+##### Footer
+- **Components:**
+    - **Links**
+    - **Contact Information**
+    - **Social Media Icons**
+- **Functionality:**
+    - Provide additional navigation and contact information.
+    - Enhance the overall aesthetics of the application.
+
+```markdown
+````react:src/frontend/components/Footer.js
+function Footer() {
+    return (
+        <footer className="footer">
+            <Links />
+            <ContactInfo />
+            <SocialMediaIcons />
+        </footer>
+    );
+}
+```
+
+
+##### Notification System
+- **Components:**
+    - **NotificationList**
+        - Individual Notification Items
+    - **Real-time Notification Badge**
+- **Functionality:**
+    - Display real-time notifications for updates on grievances.
+    - Alert users for new messages or status changes.
+
+```markdown
+````react:src/frontend/components/NotificationSystem.js
+function NotificationSystem() {
+    return (
+        <div className="notification-system">
+            <NotificationBadge />
+            <NotificationList />
+        </div>
+    );
+}
+```
+
+
+---
+
+## 2. Workflow and Event Flow
+
+### User Roles and Actions
+
+#### Resident (Student) Workflow
+
+1. **Registration and Authentication**
+    - **Events:**
+        - User navigates to Signup Page.
+        - Submits registration form.
+        - System validates and creates user account.
+        - User logs in via Login Page.
+
+2. **Submitting a Grievance**
+    - **Events:**
+        - User accesses Submit Grievance Page.
+        - Fills out grievance form or uses voice-to-text feature.
+        - Submits grievance.
+        - System categorizes and routes grievance using AI-powered routing.
+        - A chatroom is created for real-time communication.
+        - User receives confirmation and grievance status updates.
+
+3. **Tracking Grievances**
+    - **Events:**
+        - User views Student Dashboard.
+        - Navigates to View Grievances.
+        - Selects a grievance to view details and participate in chat.
+
+4. **Profile Management**
+    - **Events:**
+        - User accesses Profile Information page.
+        - Updates personal details or profile picture.
+        - Saves changes, and system updates the database.
+
+#### Administrator (Warden) Workflow
+
+1. **Authentication**
+    - **Events:**
+        - Warden logs in via Login Page.
+        - Accesses Warden Dashboard upon successful authentication.
+
+2. **Managing Grievances**
+    - **Events:**
+        - Warden views all grievances in Manage Grievances page.
+        - Assigns grievances to appropriate personnel.
+        - Updates grievance statuses as they progress.
+        - Resolves grievances by providing resolution details.
+
+3. **Performance Monitoring**
+    - **Events:**
+        - Warden accesses Performance Dashboard.
+        - Views metrics on grievance handling efficiency, resolution times, and staff performance.
+        - Generates reports for administrative review.
+
+4. **Real-time Communication**
+    - **Events:**
+        - Warden participates in chatrooms for assigned grievances.
+        - Sends and receives messages for updates and clarifications.
+
+### AI/ML Functionalities Integration
+
+1. **Automated Grievance Categorization**
+    - **Event Flow:**
+        - Upon grievance submission, text is processed by ML models.
+        - Category is automatically assigned.
+        - Grievance is routed based on the category.
+
+2. **Sentiment Analysis for Prioritization**
+    - **Event Flow:**
+        - Grievance text is analyzed for sentiment.
+        - Negative sentiments trigger higher priority assignments.
+        - Dashboard highlights high-priority grievances.
+
+3. **Predictive Resolution Time Estimation**
+    - **Event Flow:**
+        - System predicts resolution time based on historical data.
+        - Estimated time is displayed to the user and warden.
+        - Helps in managing expectations and resources.
+
+4. **Anomaly Detection in Grievance Patterns**
+    - **Event Flow:**
+        - System continuously monitors grievance submissions.
+        - Detects unusual spikes or patterns.
+        - Alerts administrators to investigate potential systemic issues.
+
+5. **Voice-to-Text Integration for Complaint Submission**
+    - **Event Flow:**
+        - User submits grievance via voice input.
+        - Voice data is transcribed to text using speech recognition.
+        - Transcribed text is processed for categorization and sentiment analysis.
+
+6. **Proactive Grievance Prediction and Prevention**
+    - **Event Flow:**
+        - System analyzes trends to predict potential future grievances.
+        - Suggests preventive measures to administrators.
+        - Helps in mitigating issues before they escalate.
+
+7. **Intelligent Routing and Workflow Automation**
+    - **Event Flow:**
+        - System assigns grievances to personnel based on AI-driven suggestions.
+        - Continuously learns and adapts routing based on outcomes.
+        - Ensures optimal workload distribution.
+
+8. **Advanced Sentiment and Emotional Intelligence Analysis**
+    - **Event Flow:**
+        - Grievance submissions are analyzed for complex emotional states.
+        - Responses are tailored based on detected emotions.
+        - Enhances empathetic communication.
+
+9. **Knowledge Graph Integration for Insight Generation**
+    - **Event Flow:**
+        - Grievances are integrated into a knowledge graph.
+        - Enables advanced querying and pattern detection.
+        - Provides actionable insights for improving the grievance resolution process.
+
+---
+
+## 3. Directory Structure and File Division
+
+### Frontend Directory Structure
+
+```markdown
+````language:frontend
+src/
+├── assets/
+│   ├── images/
+│   │   └── *.png
+│   └── styles/
+│       └── tailwind.css
+├── components/
+│   ├── Authentication/
+│   │   ├── LoginForm.js
+│   │   └── SignupForm.js
+│   ├── Common/
+│   │   ├── NavigationBar.js
+│   │   ├── Footer.js
+│   │   └── NotificationSystem.js
+│   ├── Dashboard/
+│   │   ├── RecentGrievances.js
+│   │   ├── StatisticsOverview.js
+│   │   └── QuickSubmitButton.js
+│   ├── Grievances/
+│   │   ├── GrievanceForm.js
+│   │   ├── GrievanceList.js
+│   │   └── GrievanceDetails.js
+│   ├── Profile/
+│   │   ├── ProfileForm.js
+│   │   └── ProfilePictureUpload.js
+│   └── Chat/
+│       └── Chatroom.js
+├── pages/
+│   ├── LoginPage.js
+│   ├── SignupPage.js
+│   ├── StudentDashboard.js
+│   ├── StudentProfile.js
+│   ├── SubmitGrievance.js
+│   ├── ViewGrievances.js
+│   ├── GrievanceDetails.js
+│   ├── WardenDashboard.js
+│   ├── ManageGrievances.js
+│   ├── ResolveGrievance.js
+│   └── PerformanceDashboard.js
+├── services/
+│   ├── api.js
+│   ├── authService.js
+│   ├── grievanceService.js
+│   └── chatService.js
+├── utils/
+│   ├── validation.js
+│   └── helpers.js
+├── App.js
+├── index.js
+└── routes.js
+```
+
+
+### Backend Directory Structure
+
+```markdown
+````language:backend
+src/
+├── config/
+│   ├── db.js
+│   └── config.js
+├── controllers/
+│   ├── authController.js
+│   ├── grievanceController.js
+│   ├── userController.js
+│   └── chatController.js
+├── models/
+│   ├── User.js
+│   ├── Grievance.js
+│   └── ChatMessage.js
+├── routes/
+│   ├── authRoutes.js
+│   ├── grievanceRoutes.js
+│   ├── userRoutes.js
+│   └── chatRoutes.js
+├── services/
+│   ├── sentimentAnalysisService.js
+│   ├── categorizationService.js
+│   ├── routingService.js
+│   └── knowledgeGraphService.js
+├── middleware/
+│   ├── authMiddleware.js
+│   ├── errorHandler.js
+│   └── validationMiddleware.js
+├── utils/
+│   ├── logger.js
+│   └── helpers.js
+├── app.js
+└── server.js
+```
+
+
+### Explanation
+
+- **Frontend (`src/frontend/`):**
+    - **assets/**: Static assets like images and styles.
+    - **components/**: Reusable React components categorized by functionality.
+    - **pages/**: Page-level components representing different routes.
+    - **services/**: API interaction logic.
+    - **utils/**: Utility functions and helpers.
+    - **App.js**: Root component.
+    - **index.js**: Entry point.
+    - **routes.js**: Application routing.
+
+- **Backend (`src/backend/`):**
+    - **config/**: Configuration files for database and environment variables.
+    - **controllers/**: Business logic handling requests and responses.
+    - **models/**: Database models using ORM (e.g., Sequelize for PostgreSQL).
+    - **routes/**: API route definitions.
+    - **services/**: AI/ML and other service integrations.
+    - **middleware/**: Express middleware for authentication, error handling, etc.
+    - **utils/**: Utility functions and helpers.
+    - **app.js**: Express app setup.
+    - **server.js**: Server initialization.
+
+---
+
+## 4. Backend and Frontend Separation
+
+### Frontend
+
+- **Technology Stack:**
+    - **Framework**: React.js
+    - **Styling**: Tailwind CSS
+    - **State Management**: Redux or Context API
+    - **Real-time Communication**: Socket.io-client
+
+- **Responsibilities:**
+    - User Interface and User Experience.
+    - Making API calls to the backend.
+    - Handling client-side routing.
+    - Managing user authentication state.
+    - Displaying real-time updates and notifications.
+
+- **Key Components:**
+    - **Pages**: Represent different routes/views.
+    - **Components**: Reusable UI elements.
+    - **Services**: Handle API communications.
+    - **Utilities**: Helper functions and validation.
+
+### Backend
+
+- **Technology Stack:**
+    - **Runtime Environment**: Node.js
+    - **Framework**: Express.js
+    - **Database**: PostgreSQL
+    - **Real-time Communication**: Socket.io
+    - **AI/ML Integration**: Python scripts or external services
+    - **Authentication**: JWT (JSON Web Tokens)
+
+- **Responsibilities:**
+    - API Endpoints for frontend communication.
+    - Business logic and data processing.
+    - Database interactions and ORM management.
+    - Authentication and authorization.
+    - AI/ML functionalities like sentiment analysis, categorization.
+    - Managing real-time chatrooms and notifications.
+
+- **Key Components:**
+    - **Controllers**: Handle incoming requests, interact with services.
+    - **Models**: Define database schemas and ORM models.
+    - **Routes**: Define API endpoints.
+    - **Services**: Business logic and AI/ML integrations.
+    - **Middleware**: Authentication, validation, error handling.
+
+### Communication Between Frontend and Backend
+
+- **RESTful APIs**: For standard CRUD operations and data retrieval.
+- **WebSockets (Socket.io)**: For real-time features like chatrooms and live notifications.
+- **Authentication**: JWT tokens stored in HTTP-only cookies or local storage for secure communication.
+
+---
+
+## 5. Performance Dashboard for Students
+
+### Overview
+
+The Performance Dashboard provides insights into the performance of different students regarding their grievance handling. This feature is accessible to administrators to monitor and improve the efficiency of the grievance redressal process.
+
+### Components
+
+1. **Dashboard Overview**
+    - **Total Grievances Handled**: Number of grievances each student has submitted and their current status.
+    - **Average Resolution Time**: Time taken to resolve grievances per student.
+    - **Success Rate**: Percentage of grievances successfully resolved.
+
+2. **Graphs and Charts**
+    - **Bar Chart**: Number of grievances submitted by each student.
+    - **Line Chart**: Resolution time trends over a period.
+    - **Pie Chart**: Distribution of grievance statuses (Resolved, Pending, In Progress).
+
+3. **Filters and Search**
+    - **Date Range Picker**: Filter data based on specific time frames.
+    - **Student Selector**: Choose specific students to view detailed performance.
+    - **Grievance Category Filter**: Analyze performance across different categories.
+
+4. **Detailed Tables**
+    - **Grievance List**: Detailed list of grievances with columns for Student Name, Grievance Title, Status, Submission Date, Resolution Date.
+    - **Export Options**: Export data in CSV or PDF formats for reporting.
+
+### Functionality
+
+- **Data Aggregation**: Fetch data from the backend to display aggregated statistics.
+- **Real-time Updates**: Reflect real-time changes in grievance statuses.
+- **Responsive Design**: Ensure the dashboard is accessible on various devices.
+- **User Interactions**: Allow administrators to interact with charts and tables for deeper insights.
+
+### Implementation
+
+```markdown
+react:src/frontend/pages/PerformanceDashboard.js
+function PerformanceDashboard() {
+    const [data, setData] = useState({});
+    const [filters, setFilters] = useState({
+        dateRange: { start: null, end: null },
+        student: '',
+        category: ''
+    });
+
+    useEffect(() => {
+        // Fetch dashboard data based on filters
+        fetchDashboardData(filters).then(response => setData(response));
+    }, [filters]);
+
+    return (
+        <div className="performance-dashboard-container">
+            <Sidebar />
+            <div className="dashboard-content">
+                <FiltersComponent filters={filters} setFilters={setFilters} />
+                <Graphs />
+                <DetailedTables data={data} />
+            </div>
+        </div>
+    );
+}
+```
+
+
+```markdown
+javascript:src/frontend/services/dashboardService.js:fetchDashboardData
+async function fetchDashboardData(filters) {
+    try {
+        const response = await axios.get('/api/dashboard', { params: filters });
+        return response.data;
+    } catch (error) {
+        console.error('Error fetching dashboard data:', error);
+        throw error;
+    }
+}
+```
+
+
+```markdown
+````javascript:src/backend/controllers/dashboardController.js:getDashboardData
+async function getDashboardData(req, res) {
+    const { dateRange, student, category } = req.query;
+    try {
+        const data = await DashboardService.aggregatePerformanceData({ dateRange, student, category });
+        res.status(200).json(data);
+    } catch (error) {
+        res.status(500).json({ message: 'Failed to fetch dashboard data.' });
+    }
+}
+```
+
+
+```markdown
+javascript:src/backend/services/dashboardService.js:aggregatePerformanceData
+async function aggregatePerformanceData(filters) {
+    const { dateRange, student, category } = filters;
+    // Build query based on filters
+    let query = { /* ... */ };
+
+    const grievances = await Grievance.findAll({ where: query });
+
+    // Aggregate data
+    const totalHandled = /* logic to calculate */;
+    const avgResolutionTime = /* logic to calculate */;
+    const successRate = /* logic to calculate */;
+    const perStudent = /* logic to calculate */;
+
+    return {
+        totalHandled,
+        avgResolutionTime,
+        successRate,
+        perStudent,
+        // Additional aggregated data
+    };
+}
+```
+
+
+### Backend API Endpoint
+
+```markdown
+````language:backend
+// src/backend/routes/dashboardRoutes.js
+
+const express = require('express');
+const router = express.Router();
+const dashboardController = require('../controllers/dashboardController');
+const authMiddleware = require('../middleware/authMiddleware');
+
+router.get('/dashboard', authMiddleware.verifyAdmin, dashboardController.getDashboardData);
+
+module.exports = router;
+```
+
+
+### Frontend API Integration
+
+```markdown
+````language:frontend
+// src/frontend/services/dashboardService.js
+
+import axios from 'axios';
+
+export async function fetchDashboardData(filters) {
+    try {
+        const response = await axios.get('/api/dashboard', { params: filters });
+        return response.data;
+    } catch (error) {
+        console.error('Error fetching dashboard data:', error);
+        throw error;
+    }
+}
+```
+
+
+### UI Implementation
+
+- **Graphs and Charts**: Utilize charting libraries like **Chart.js** or **Recharts** to create interactive and responsive charts.
+- **Filters Component**: Allows administrators to apply various filters to the data.
+- **Detailed Tables**: Implement sortable and searchable tables using libraries like **React Table**.
+
+### Security Considerations
+
+- **Authentication and Authorization**: Ensure that only authorized administrators can access the Performance Dashboard.
+- **Data Protection**: Secure sensitive performance data and ensure compliance with data protection regulations.
+
+---
+
+# Conclusion
+
+This comprehensive project plan outlines the detailed structure and workflow for the Hostel Grievance Redressal System. By following this plan, the development team can ensure a well-organized, efficient, and feature-rich application that effectively addresses the grievances of hostel residents. The integration of AI/ML functionalities will further enhance the system's capability to manage and resolve issues promptly and intelligently.

models/intelligent_routing/generate_data.py

@@ -0,0 +1,118 @@
+import random
+import json
+from datetime import datetime, timedelta
+import logging
+import os
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class IntelligentRoutingDataGenerator:
+    def __init__(self):
+        self.categories = ['electricity', 'internet', 'plumber', 'water_cooler', 'sweeper', 'carpenter']
+        self.availability_statuses = ['Available', 'Unavailable']
+        self.hostel_names = ['bh1', 'bh2', 'bh3', 'ivh', 'gh']
+        self.floor_numbers = [0, 1, 2, 3]
+        self.time_slots = [
+            "08:00-12:00", "12:00-16:00", "16:00-20:00"
+        ]
+
+    def generate_staff_members(self, category):
+        """Generate 2 staff members for a specific category"""
+        return [
+            {
+                "staff_id": f"S{random.randint(10000, 99999)}",
+                "department": category,  # Ensure staff department matches grievance category
+                "current_workload": random.randint(0, 5),
+                "availability_status": random.choice(self.availability_statuses),
+                "past_resolution_rate": round(random.uniform(0.85, 0.99), 2)
+            }
+            for _ in range(2)
+        ]
+
+    def generate_availability_data(self, staff_id, student_id):
+        return {
+            "staff_availability": [
+                {
+                    "staff_id": staff_id,
+                    "time_slot": random.choice(self.time_slots),
+                    "availability_status": random.choice(self.availability_statuses)
+                }
+            ],
+            "student_availability": [
+                {
+                    "student_id": student_id,
+                    "time_slot": random.choice(self.time_slots),
+                    "availability_status": random.choice(self.availability_statuses)
+                }
+            ]
+        }
+
+    def generate_sample(self, index):
+        grievance_id = f"G{67890 + index}"
+        student_id = f"STU{200 + index}"
+        
+        # First select category, then generate matching staff
+        selected_category = random.choice(self.categories)
+        staff_members = self.generate_staff_members(selected_category)
+        
+        # Generate base timestamp
+        base_time = datetime.utcnow()
+        submission_time = base_time - timedelta(minutes=random.randint(0, 60))
+        
+        # Generate sample data
+        sample = {
+            "grievance_id": grievance_id,
+            "category": selected_category,
+            "submission_timestamp": submission_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "student_room_no": str(random.randint(100, 499)),
+            "hostel_name": random.choice(self.hostel_names),
+            "floor_number": random.choice(self.floor_numbers),
+            "current_staff_status": staff_members,
+            "floor_metrics": {
+                "number_of_requests": random.randint(0, 30),
+                "total_delays": random.randint(0, 5)
+            },
+            "availability_data": self.generate_availability_data(
+                staff_members[0]["staff_id"], 
+                student_id
+            )
+        }
+        
+        return sample
+
+    def generate_dataset(self, num_samples, output_path):
+        dataset = []
+        for i in range(num_samples):
+            sample = self.generate_sample(i)
+            dataset.append(sample)
+        
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        # Save to JSON file
+        with open(output_path, 'w') as f:
+            json.dump(dataset, f, indent=2)
+        
+        logger.info(f"Generated {len(dataset)} samples and saved to {output_path}")
+        return dataset
+
+def main():
+    generator = IntelligentRoutingDataGenerator()
+    
+    # Generate training data
+    train_samples = generator.generate_dataset(
+        40000, 
+        'models/intelligent_routing/train_data/training_data.json'
+    )
+    
+    # Generate test data
+    test_samples = generator.generate_dataset(
+        8000, 
+        'models/intelligent_routing/test_data/test_data.json'
+    )
+    
+    print(f"Generated {len(train_samples)} training samples and {len(test_samples)} test samples")
+
+if __name__ == "__main__":
+    main()

models/intelligent_routing/model.py

@@ -0,0 +1,253 @@
+import tensorflow as tf
+import numpy as np
+from datetime import datetime
+import json
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class IntelligentRoutingModel:
+    def __init__(self):
+        self.model = None
+        self.feature_columns = [
+            'category_encoded',
+            'floor_number',
+            'current_workload',
+            'past_resolution_rate',
+            'number_of_requests',
+            'total_delays'
+        ]
+        
+        # Category encoding
+        self.categories = ['electricity', 'internet', 'plumber', 'water_cooler', 'sweeper', 'carpenter']
+        self.category_encoding = {cat: i for i, cat in enumerate(self.categories)}
+        logging.info(f"Initialized IntelligentRoutingModel with {len(self.categories)} categories")
+
+    def preprocess_data(self, data):
+        """Enhanced data preprocessing"""
+        features = []
+        labels = []
+        
+        for sample in data:
+            # Encode category
+            category_encoded = [0] * len(self.categories)
+            category_idx = self.category_encoding[sample['category']]
+            category_encoded[category_idx] = 1
+            
+            # Process each staff member
+            for staff in sample['current_staff_status']:
+                if staff['department'] == sample['category']:
+                    # Normalize numerical features
+                    normalized_workload = staff['current_workload'] / 5.0
+                    
+                    # Calculate time-based features
+                    submission_time = datetime.strptime(sample['submission_timestamp'], "%Y-%m-%dT%H:%M:%SZ")
+                    hour_of_day = submission_time.hour / 24.0
+                    
+                    # Calculate distance (simplified)
+                    distance = abs(int(staff.get('current_floor', 0)) - 
+                                 int(sample['floor_number'])) / 4.0
+                    
+                    # Create enhanced feature vector
+                    feature = np.array([
+                        *category_encoded,
+                        sample['floor_number'] / 4.0,  # Normalized floor number
+                        normalized_workload,
+                        staff['past_resolution_rate'],
+                        sample['floor_metrics']['number_of_requests'] / 30.0,
+                        sample['floor_metrics']['total_delays'] / 5.0,
+                        hour_of_day,
+                        1.0 if staff['availability_status'] == 'Available' else 0.0,
+                        distance  # Normalized distance
+                    ])
+                    
+                    features.append(feature)
+                    
+                    # Enhanced label creation
+                    is_good_match = (
+                        staff['availability_status'] == 'Available' and
+                        staff['current_workload'] < 4 and
+                        staff['past_resolution_rate'] > 0.85 and
+                        distance < 0.5  # Prefer closer staff
+                    )
+                    labels.append(1 if is_good_match else 0)
+        
+        if not features:
+            raise ValueError("No valid features found in the dataset")
+            
+        # Convert to numpy arrays
+        features = np.array(features)
+        labels = np.array(labels)
+        
+        # Log shapes for debugging
+        logging.info(f"Preprocessed data shapes - Features: {features.shape}, Labels: {labels.shape}")
+        
+        return features, labels
+
+    def build_model(self):
+        """Build an improved neural network model"""
+        # Calculate input dimension based on features
+        input_dim = (
+            len(self.categories) +  # One-hot encoded categories
+            8  # Additional features: floor_number, workload, resolution_rate, 
+               # requests, delays, hour_of_day, availability, distance
+        )
+        
+        logging.info(f"Building model with input dimension: {input_dim}")
+        
+        model = tf.keras.Sequential([
+            # Input layer with regularization
+            tf.keras.layers.Dense(128, activation='relu', input_shape=(input_dim,),
+                                kernel_regularizer=tf.keras.regularizers.l2(0.01)),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Dropout(0.3),
+            
+            # Hidden layers with skip connections
+            tf.keras.layers.Dense(64, activation='relu',
+                                kernel_regularizer=tf.keras.regularizers.l2(0.01)),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Dropout(0.2),
+            
+            tf.keras.layers.Dense(32, activation='relu',
+                                kernel_regularizer=tf.keras.regularizers.l2(0.01)),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Dropout(0.2),
+            
+            # Output layer
+            tf.keras.layers.Dense(1, activation='sigmoid')
+        ])
+        
+        # Use a more sophisticated optimizer with learning rate scheduling
+        initial_learning_rate = 0.001
+        lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
+            initial_learning_rate,
+            decay_steps=1000,
+            decay_rate=0.9,
+            staircase=True)
+        
+        optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
+        
+        model.compile(
+            optimizer=optimizer,
+            loss='binary_crossentropy',
+            metrics=['accuracy',
+                    tf.keras.metrics.Precision(),
+                    tf.keras.metrics.Recall(),
+                    tf.keras.metrics.AUC()]
+        )
+        
+        # Print model summary
+        model.summary()
+        
+        self.model = model
+        return model
+
+    def train(self, train_data_path, epochs=20, batch_size=32):
+        """Enhanced training process"""
+        logging.info(f"Starting model training with {epochs} epochs")
+        
+        # Load and preprocess data
+        with open(train_data_path) as f:
+            train_data = json.load(f)
+        
+        X, y = self.preprocess_data(train_data)
+        
+        # Create validation split
+        from sklearn.model_selection import train_test_split
+        X_train, X_val, y_train, y_val = train_test_split(
+            X, y, test_size=0.2, random_state=42, stratify=y
+        )
+        
+        # Handle class imbalance
+        from sklearn.utils.class_weight import compute_class_weight
+        class_weights = compute_class_weight(
+            'balanced',
+            classes=np.unique(y_train),
+            y=y_train
+        )
+        class_weight_dict = {i: weight for i, weight in enumerate(class_weights)}
+        
+        # Build model
+        self.build_model()
+        
+        # Add callbacks
+        callbacks = [
+            tf.keras.callbacks.EarlyStopping(
+                monitor='val_loss',
+                patience=5,
+                restore_best_weights=True
+            ),
+            tf.keras.callbacks.ReduceLROnPlateau(
+                monitor='val_loss',
+                factor=0.5,
+                patience=3,
+                min_lr=0.00001
+            )
+        ]
+        
+        # Train model
+        history = self.model.fit(
+            X_train, y_train,
+            epochs=epochs,
+            batch_size=batch_size,
+            validation_data=(X_val, y_val),
+            class_weight=class_weight_dict,
+            callbacks=callbacks,
+            verbose=1
+        )
+        
+        return history
+
+    def predict(self, input_data):
+        """Make predictions for input data"""
+        logging.info(f"Making prediction for grievance {input_data['grievance_id']}")
+        # Preprocess input
+        X = self.preprocess_data([input_data])
+        
+        # Make prediction
+        prediction = self.model.predict(X)[0][0]
+        logging.info(f"Raw prediction: {prediction}")
+        
+        # Find best matching staff
+        best_staff = None
+        highest_score = -1
+        
+        for staff in input_data['current_staff_status']:
+            if staff['department'] == input_data['category']:
+                score = prediction * staff['past_resolution_rate'] * (1 / (staff['current_workload'] + 1))
+                logging.debug(f"Staff {staff['staff_id']} score: {score}")
+                if score > highest_score:
+                    highest_score = score
+                    best_staff = staff
+        
+        if not best_staff:
+            logging.warning("No suitable staff found for the grievance")
+            return None
+            
+        # Generate response
+        assignment_time = datetime.utcnow()
+        
+        response = {
+            "grievance_id": input_data['grievance_id'],
+            "assigned_staff_id": best_staff['staff_id'],
+            "assignment_timestamp": assignment_time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "expected_resolution_time": "1 hour",
+            "floor_number": input_data['floor_number'],
+            "hostel_name": input_data['hostel_name'],
+            "student_room_no": input_data['student_room_no']
+        }
+        logging.info(f"Generated response: {response}")
+        return response
+
+    def save_model(self, path):
+        """Save the trained model"""
+        logging.info(f"Saving model to {path}")
+        self.model.save(path)
+        logging.info("Model saved successfully")
+
+    def load_model(self, path):
+        """Load a trained model"""
+        logging.info(f"Loading model from {path}")
+        self.model = tf.keras.models.load_model(path)
+        logging.info("Model loaded successfully")

models/intelligent_routing/saved_model/model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21096f35bb4c5aabc441e3e4d4d4804566ccd08c96ff922de0dfc444c1476941
+size 210119

models/intelligent_routing/test_model.py

@@ -0,0 +1,259 @@
+import json
+import logging
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+from model import IntelligentRoutingModel
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import os
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('testing.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class IntelligentRoutingTester:
+    def __init__(self, model_path, test_data_path):
+        self.model = IntelligentRoutingModel()
+        self.model.load_model(model_path)
+        self.test_data_path = test_data_path
+        
+        # Create results directory
+        self.results_dir = 'models/intelligent_routing/test_results'
+        os.makedirs(self.results_dir, exist_ok=True)
+
+    def load_test_data(self):
+        """Load test data from JSON file"""
+        try:
+            logger.info(f"Loading test data from {self.test_data_path}")
+            with open(self.test_data_path, 'r') as f:
+                data = json.load(f)
+            logger.info(f"Successfully loaded {len(data)} test samples")
+            return data
+        except Exception as e:
+            logger.error(f"Error loading test data: {str(e)}")
+            raise
+
+    def generate_test_cases(self):
+        """Generate specific test cases to evaluate model robustness"""
+        test_cases = []
+        
+        # Test case 1: Ideal scenario
+        test_cases.append({
+            "grievance_id": "G_TEST_1",
+            "category": "electricity",
+            "submission_timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "floor_number": 1,
+            "hostel_name": "bh1",
+            "student_room_no": "101",
+            "current_staff_status": [
+                {
+                    "staff_id": "S_TEST_1",
+                    "department": "electricity",
+                    "current_workload": 1,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.95,
+                    "current_floor": 1
+                }
+            ],
+            "floor_metrics": {
+                "number_of_requests": 5,
+                "total_delays": 1
+            }
+        })
+        
+        # Test case 2: High workload scenario
+        test_cases.append({
+            "grievance_id": "G_TEST_2",
+            "category": "plumber",
+            "submission_timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "floor_number": 2,
+            "hostel_name": "bh2",
+            "student_room_no": "201",
+            "current_staff_status": [
+                {
+                    "staff_id": "S_TEST_2",
+                    "department": "plumber",
+                    "current_workload": 4,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.90,
+                    "current_floor": 1
+                }
+            ],
+            "floor_metrics": {
+                "number_of_requests": 15,
+                "total_delays": 3
+            }
+        })
+        
+        # Test case 3: Multiple staff scenario
+        test_cases.append({
+            "grievance_id": "G_TEST_3",
+            "category": "carpenter",
+            "submission_timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "floor_number": 3,
+            "hostel_name": "bh3",
+            "student_room_no": "301",
+            "current_staff_status": [
+                {
+                    "staff_id": "S_TEST_3A",
+                    "department": "carpenter",
+                    "current_workload": 2,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.88,
+                    "current_floor": 3
+                },
+                {
+                    "staff_id": "S_TEST_3B",
+                    "department": "carpenter",
+                    "current_workload": 1,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.92,
+                    "current_floor": 2
+                }
+            ],
+            "floor_metrics": {
+                "number_of_requests": 8,
+                "total_delays": 2
+            }
+        })
+        
+        return test_cases
+
+    def evaluate_model(self):
+        """Evaluate model performance on test data"""
+        logger.info("Starting model evaluation")
+        
+        # Load test data
+        test_data = self.load_test_data()
+        X_test, y_test = self.model.preprocess_data(test_data)
+        
+        # Get predictions
+        logger.info("Making predictions on test data")
+        y_pred = self.model.model.predict(X_test)
+        y_pred_binary = (y_pred > 0.5).astype(int)
+        
+        # Calculate metrics
+        metrics = {
+            'accuracy': accuracy_score(y_test, y_pred_binary),
+            'precision': precision_score(y_test, y_pred_binary),
+            'recall': recall_score(y_test, y_pred_binary),
+            'f1': f1_score(y_test, y_pred_binary)
+        }
+        
+        # Generate confusion matrix
+        cm = confusion_matrix(y_test, y_pred_binary)
+        
+        # Plot confusion matrix
+        self.plot_confusion_matrix(cm)
+        
+        logger.info(f"Evaluation metrics: {metrics}")
+        return metrics, cm, y_test, y_pred
+
+    def plot_confusion_matrix(self, cm):
+        """Plot and save confusion matrix"""
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
+        plt.title('Confusion Matrix')
+        plt.ylabel('True Label')
+        plt.xlabel('Predicted Label')
+        plt.savefig(f'{self.results_dir}/confusion_matrix.png')
+        plt.close()
+
+    def test_specific_cases(self):
+        """Test model on specific test cases"""
+        test_cases = self.generate_test_cases()
+        results = []
+        
+        for case in test_cases:
+            prediction = self.model.predict(case)
+            results.append({
+                'case': case['grievance_id'],
+                'prediction': prediction,
+                'analysis': self.analyze_prediction(case, prediction)
+            })
+        
+        return results
+
+    def analyze_prediction(self, case, prediction):
+        """Analyze the prediction for a specific case"""
+        if not prediction:
+            return "No suitable staff found"
+            
+        analysis = {
+            'assigned_staff': prediction['assigned_staff_id'],
+            'response_time': (
+                datetime.strptime(prediction['assignment_timestamp'], "%Y-%m-%dT%H:%M:%SZ") -
+                datetime.strptime(case['submission_timestamp'], "%Y-%m-%dT%H:%M:%SZ")
+            ).total_seconds(),
+            'same_floor_assignment': 
+                any(staff['current_floor'] == case['floor_number'] 
+                    for staff in case['current_staff_status']
+                    if staff['staff_id'] == prediction['assigned_staff_id'])
+        }
+        
+        return analysis
+
+    def run_full_test(self):
+        """Run complete test suite and generate report"""
+        logger.info("Starting full model testing")
+        
+        # Evaluate model
+        metrics, cm, y_test, y_pred = self.evaluate_model()
+        
+        # Test specific cases
+        specific_case_results = self.test_specific_cases()
+        
+        # Generate test report
+        report = {
+            'metrics': metrics,
+            'specific_case_results': specific_case_results,
+            'test_timestamp': datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            'detailed_analysis': {
+                'false_positives': int(cm[0][1]),
+                'false_negatives': int(cm[1][0]),
+                'average_prediction_confidence': float(np.mean(y_pred))
+            }
+        }
+        
+        # Save report
+        with open(f'{self.results_dir}/test_report.json', 'w') as f:
+            json.dump(report, f, indent=2)
+        
+        logger.info("Testing completed. Results saved in test_results directory")
+        return report
+
+def main():
+    try:
+        model_path = 'models/intelligent_routing/saved_model/model.keras'
+        test_data_path = 'models/intelligent_routing/test_data/test_data.json'
+        
+        logger.info("Initializing tester")
+        tester = IntelligentRoutingTester(model_path, test_data_path)
+        
+        logger.info("Running full test suite")
+        report = tester.run_full_test()
+        
+        logger.info("\nTest Results Summary:")
+        logger.info(f"Accuracy: {report['metrics']['accuracy']:.4f}")
+        logger.info(f"Precision: {report['metrics']['precision']:.4f}")
+        logger.info(f"Recall: {report['metrics']['recall']:.4f}")
+        logger.info(f"F1 Score: {report['metrics']['f1']:.4f}")
+        logger.info("\nDetailed Analysis:")
+        logger.info(f"False Positives: {report['detailed_analysis']['false_positives']}")
+        logger.info(f"False Negatives: {report['detailed_analysis']['false_negatives']}")
+        logger.info(f"Avg Prediction Confidence: {report['detailed_analysis']['average_prediction_confidence']:.4f}")
+        
+    except Exception as e:
+        logger.error(f"Error during testing: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/intelligent_routing/train.py

@@ -0,0 +1,45 @@
+from model import IntelligentRoutingModel
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('training.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+def main():
+    try:
+        logger.info("Starting model training process")
+        
+        # Create model instance
+        logger.info("Initializing IntelligentRoutingModel")
+        model = IntelligentRoutingModel()
+        
+        # Train model
+        train_data_path = 'models/intelligent_routing/train_data/training_data.json'
+        logger.info(f"Training model with data from {train_data_path}")
+        history = model.train(train_data_path, epochs=10)
+        
+        # Create directory if it doesn't exist
+        os.makedirs('models/intelligent_routing/saved_model', exist_ok=True)
+        
+        # Save model with correct extension
+        model_path = 'models/intelligent_routing/saved_model/model.keras'
+        logger.info(f"Saving trained model to {model_path}")
+        model.save_model(model_path)
+        
+        logger.info("Model training completed and saved successfully")
+        
+    except Exception as e:
+        logger.error(f"Error during model training: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/job_recommendation/generate_data.py

@@ -0,0 +1,92 @@
+import random
+import json
+from datetime import datetime, timedelta
+import os
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class JobRecommendationDataGenerator:
+    def __init__(self):
+        self.job_types = ['Electrical', 'Mechanical', 'Plumbing', 'Carpentry', 'Cleaning', 'IT']
+        self.urgency_levels = ['Critical', 'High', 'Medium', 'Low']
+        self.hostel_names = ['Hostel A', 'Hostel B', 'Hostel C', 'Hostel D']
+        self.availability_statuses = ['Available', 'Busy', 'On Leave']
+
+    def generate_location(self):
+        return {
+            "hostel_name": random.choice(self.hostel_names),
+            "floor_number": random.randint(0, 4),
+            "room_number": f"{random.randint(1, 4)}{random.randint(0, 9)}{random.randint(0, 9)}"
+        }
+
+    def generate_worker(self, department=None):
+        if department is None:
+            department = random.choice(self.job_types)
+            
+        return {
+            "worker_id": f"W{random.randint(10000, 99999)}",
+            "department": department,
+            "current_workload": random.randint(0, 5),
+            "availability_status": random.choice(self.availability_statuses),
+            "job_success_rate": round(random.uniform(0.80, 0.99), 2),
+            "current_location": self.generate_location()
+        }
+
+    def generate_sample(self, index):
+        job_type = random.choice(self.job_types)
+        location = self.generate_location()
+        
+        # Generate workers list with at least one matching department
+        workers = [self.generate_worker(job_type)]  # Ensure one matching worker
+        workers.extend([self.generate_worker() for _ in range(random.randint(2, 4))])
+        
+        sample = {
+            "job_id": f"J{60000 + index}",
+            "type": job_type,
+            "description": f"{job_type} issue in room {location['room_number']}.",
+            "urgency_level": random.choice(self.urgency_levels),
+            "submission_timestamp": (datetime.utcnow() - timedelta(minutes=random.randint(0, 60))).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "location": location,
+            "workers": workers
+        }
+        
+        return sample
+
+    def generate_dataset(self, num_samples, output_path):
+        logger.info(f"Generating {num_samples} samples...")
+        dataset = []
+        for i in range(num_samples):
+            sample = self.generate_sample(i)
+            dataset.append(sample)
+        
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        # Save to JSON file
+        with open(output_path, 'w') as f:
+            json.dump(dataset, f, indent=2)
+        
+        logger.info(f"Generated {len(dataset)} samples and saved to {output_path}")
+        return dataset
+
+def main():
+    generator = JobRecommendationDataGenerator()
+    
+    # Generate training data
+    train_samples = generator.generate_dataset(
+        20000, 
+        'models/job_recommendation/train_data/training_data.json'
+    )
+    
+    # Generate test data
+    test_samples = generator.generate_dataset(
+        4000, 
+        'models/job_recommendation/test_data/test_data.json'
+    )
+    
+    logger.info(f"Generated {len(train_samples)} training samples and {len(test_samples)} test samples")
+
+if __name__ == "__main__":
+    main()

models/job_recommendation/model.py

@@ -0,0 +1,144 @@
+import tensorflow as tf
+import numpy as np
+from datetime import datetime
+import json
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class JobRecommendationModel:
+    def __init__(self):
+        self.model = None
+        self.job_types = ['Electrical', 'Mechanical', 'Plumbing', 'Carpentry', 'Cleaning', 'IT']
+        self.urgency_levels = ['Critical', 'High', 'Medium', 'Low']
+        
+        # Create encodings
+        self.job_type_encoding = {job: i for i, job in enumerate(self.job_types)}
+        self.urgency_encoding = {level: i for i, level in enumerate(self.urgency_levels)}
+
+    def preprocess_data(self, data):
+        """Preprocess input data for model"""
+        features = []
+        labels = []
+        
+        for sample in data:
+            # Encode job type
+            job_type_encoded = [0] * len(self.job_types)
+            job_type_idx = self.job_type_encoding[sample['type']]
+            job_type_encoded[job_type_idx] = 1
+            
+            # Encode urgency level
+            urgency_encoded = [0] * len(self.urgency_levels)
+            urgency_idx = self.urgency_encoding[sample['urgency_level']]
+            urgency_encoded[urgency_idx] = 1
+            
+            # Process each worker
+            for worker in sample['workers']:
+                if worker['department'] == sample['type']:  # Only process matching department workers
+                    # Create feature vector
+                    feature = np.array([
+                        *job_type_encoded,
+                        *urgency_encoded,
+                        worker['current_workload'],
+                        worker['job_success_rate'],
+                        1 if worker['availability_status'] == 'Available' else 0,
+                        sample['location']['floor_number']
+                    ])
+                    features.append(feature)
+                    
+                    # Create label (1 if worker was assigned)
+                    labels.append(1 if worker['availability_status'] == 'Available' and 
+                                worker['current_workload'] < 3 and 
+                                worker['job_success_rate'] > 0.85 else 0)
+        
+        if not features:
+            raise ValueError("No valid features found in the dataset")
+            
+        return np.array(features), np.array(labels)
+
+    def build_model(self):
+        """Build the neural network model"""
+        input_dim = len(self.job_types) + len(self.urgency_levels) + 4  # job_type + urgency + workload + success_rate + availability + floor
+        
+        model = tf.keras.Sequential([
+            tf.keras.layers.Dense(64, activation='relu', input_shape=(input_dim,)),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Dropout(0.3),
+            tf.keras.layers.Dense(32, activation='relu'),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Dropout(0.2),
+            tf.keras.layers.Dense(16, activation='relu'),
+            tf.keras.layers.Dense(1, activation='sigmoid')
+        ])
+        
+        model.compile(
+            optimizer='adam',
+            loss='binary_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        self.model = model
+        return model
+
+    def train(self, train_data_path, epochs=10, batch_size=32):
+        """Train the model"""
+        logger.info(f"Starting model training with {epochs} epochs")
+        
+        # Load training data
+        with open(train_data_path) as f:
+            train_data = json.load(f)
+        
+        # Preprocess data
+        X, y = self.preprocess_data(train_data)
+        
+        # Build and train model
+        self.build_model()
+        history = self.model.fit(
+            X, y,
+            epochs=epochs,
+            batch_size=batch_size,
+            validation_split=0.2,
+            verbose=1
+        )
+        
+        return history
+
+    def predict(self, input_data):
+        """Make predictions for input data"""
+        # Preprocess input
+        X, _ = self.preprocess_data([input_data])
+        
+        # Make prediction
+        predictions = self.model.predict(X)
+        
+        # Find best worker
+        best_worker = None
+        highest_score = -1
+        
+        for i, worker in enumerate(input_data['workers']):
+            if worker['department'] == input_data['type']:
+                score = predictions[i][0] * worker['job_success_rate'] * (1 / (worker['current_workload'] + 1))
+                if score > highest_score:
+                    highest_score = score
+                    best_worker = worker
+        
+        if not best_worker:
+            return None
+            
+        # Generate response
+        return {
+            "job_id": input_data['job_id'],
+            "assigned_worker_id": best_worker['worker_id'],
+            "assignment_timestamp": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "expected_resolution_time": "1 hour",
+            "location": input_data['location']
+        }
+
+    def save_model(self, path):
+        """Save the trained model"""
+        self.model.save(path)
+
+    def load_model(self, path):
+        """Load a trained model"""
+        self.model = tf.keras.models.load_model(path)

models/job_recommendation/saved_model/model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:950d3e03a2824a735893fb8789627df760f9d7ae6335a13b8c076af5e6292949
+size 92508

models/job_recommendation/test.py

@@ -0,0 +1,96 @@
+import json
+import logging
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix
+from model import JobRecommendationModel
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+import os
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('job_recommendation_testing.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class JobRecommendationTester:
+    def __init__(self, model_path, test_data_path):
+        self.model = JobRecommendationModel()
+        self.model.load_model(model_path)
+        self.test_data_path = test_data_path
+        
+        # Create results directory
+        self.results_dir = 'models/job_recommendation/test_results'
+        os.makedirs(self.results_dir, exist_ok=True)
+
+    def load_test_data(self):
+        """Load test data from JSON file"""
+        with open(self.test_data_path, 'r') as f:
+            return json.load(f)
+
+    def evaluate_model(self):
+        """Evaluate model performance on test data"""
+        test_data = self.load_test_data()
+        X_test, y_test = self.model.preprocess_data(test_data)
+        
+        # Get predictions
+        y_pred = self.model.model.predict(X_test)
+        y_pred_binary = (y_pred > 0.5).astype(int)
+        
+        # Calculate metrics
+        metrics = {
+            'accuracy': accuracy_score(y_test, y_pred_binary),
+            'precision': precision_score(y_test, y_pred_binary),
+            'recall': recall_score(y_test, y_pred_binary),
+            'f1': f1_score(y_test, y_pred_binary)
+        }
+        
+        cm = confusion_matrix(y_test, y_pred_binary)
+        
+        return metrics, cm, y_test, y_pred
+
+    def run_full_test(self):
+        """Run complete test suite"""
+        logger.info("Starting full model testing")
+        
+        metrics, cm, y_test, y_pred = self.evaluate_model()
+        
+        # Save results
+        report = {
+            'metrics': metrics,
+            'test_timestamp': datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+        }
+        
+        with open(f'{self.results_dir}/test_report.json', 'w') as f:
+            json.dump(report, f, indent=2)
+        
+        logger.info("Testing completed. Results saved in test_results directory")
+        return report
+
+def main():
+    try:
+        model_path = 'models/job_recommendation/saved_model/model.keras'
+        test_data_path = 'models/job_recommendation/test_data/test_data.json'
+        
+        tester = JobRecommendationTester(model_path, test_data_path)
+        report = tester.run_full_test()
+        
+        logger.info("\nTest Results Summary:")
+        logger.info(f"Accuracy: {report['metrics']['accuracy']:.4f}")
+        logger.info(f"Precision: {report['metrics']['precision']:.4f}")
+        logger.info(f"Recall: {report['metrics']['recall']:.4f}")
+        logger.info(f"F1 Score: {report['metrics']['f1']:.4f}")
+        
+    except Exception as e:
+        logger.error(f"Error during testing: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/job_recommendation/train.py

@@ -0,0 +1,41 @@
+from model import JobRecommendationModel
+import os
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('job_recommendation_training.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+def main():
+    try:
+        logger.info("Starting job recommendation model training")
+        
+        # Create model instance
+        model = JobRecommendationModel()
+        
+        # Train model
+        train_data_path = 'models/job_recommendation/train_data/training_data.json'
+        history = model.train(train_data_path, epochs=10)
+        
+        # Create directory if it doesn't exist
+        os.makedirs('models/job_recommendation/saved_model', exist_ok=True)
+        
+        # Save model
+        model_path = 'models/job_recommendation/saved_model/model.keras'
+        model.save_model(model_path)
+        
+        logger.info("Model training completed and saved successfully")
+        
+    except Exception as e:
+        logger.error(f"Error during model training: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/multilingual_translation/model.py

@@ -0,0 +1,184 @@
+import logging
+from typing import Dict
+from datetime import datetime
+from deep_translator import GoogleTranslator
+from langdetect import detect, DetectorFactory
+import time
+import re
+
+# Set seed for consistent language detection
+DetectorFactory.seed = 0
+
+logger = logging.getLogger(__name__)
+
+class MultilingualTranslationModel:
+    def __init__(self):
+        # Supported languages with codes
+        self.supported_languages = {
+            'en': 'English',
+            'hi': 'Hindi',
+            'bn': 'Bengali',
+            'te': 'Telugu',
+            'ta': 'Tamil',
+            'mr': 'Marathi',
+            'gu': 'Gujarati',
+            'kn': 'Kannada',
+            'ml': 'Malayalam',
+            'pa': 'Punjabi'
+        }
+        
+        # Common Hinglish patterns and their English equivalents
+        self.hinglish_patterns = {
+            r'\b(nahi|nhi)\b': 'not',
+            r'\b(hai|he)\b': 'is',
+            r'\bpaani\b': 'water',
+            r'\bkharab\b': 'broken',
+            r'\bgaya\b': 'gone',
+            r'\braha\b': 'staying',
+            r'\bho\b': 'happening',
+            r'\bme\b': 'in',
+            r'\bka\b': 'of',
+            r'\bki\b': 'of'
+        }
+
+    def is_hinglish(self, text: str) -> bool:
+        """Check if text is likely Hinglish"""
+        # Count Hinglish patterns
+        pattern_count = sum(1 for pattern in self.hinglish_patterns if re.search(pattern, text.lower()))
+        words = text.split()
+        
+        # If more than 30% of words match Hinglish patterns, consider it Hinglish
+        return pattern_count / len(words) > 0.3 if words else False
+
+    def convert_hinglish_to_english(self, text: str) -> str:
+        """Convert Hinglish text to proper English"""
+        try:
+            # First try direct translation
+            translator = GoogleTranslator(source='auto', target='en')
+            result = translator.translate(text)
+            
+            # If translation failed or returned same text, try pattern-based conversion
+            if not result or result.lower() == text.lower():
+                # Convert to proper English using patterns
+                processed_text = text.lower()
+                for pattern, replacement in self.hinglish_patterns.items():
+                    processed_text = re.sub(pattern, replacement, processed_text)
+                return processed_text
+                
+            return result
+            
+        except Exception as e:
+            logger.error(f"Hinglish conversion failed: {str(e)}")
+            return text
+
+    def detect_language(self, text: str, max_retries=3) -> str:
+        """Detect the language of input text with retry logic"""
+        # Check for Hinglish first
+        if self.is_hinglish(text):
+            logger.info("Detected Hinglish text")
+            return 'hi'
+
+        for attempt in range(max_retries):
+            try:
+                detected_lang = detect(text)
+                logger.info(f"Detected language: {detected_lang}")
+                return detected_lang
+                
+            except Exception as e:
+                logger.error(f"Language detection attempt {attempt + 1} failed: {str(e)}")
+                if attempt < max_retries - 1:
+                    time.sleep(1)
+
+        return 'en'  # Default to English
+
+    def translate(self, text: str, target_lang: str = 'en', max_retries=3) -> Dict:
+        """Translate text to target language with retry logic"""
+        for attempt in range(max_retries):
+            try:
+                source_lang = self.detect_language(text)
+                logger.info(f"Source language detected: {source_lang}")
+
+                # Handle Hinglish text specially
+                if self.is_hinglish(text) and target_lang == 'en':
+                    translated_text = self.convert_hinglish_to_english(text)
+                else:
+                    # If already in target language, return original text
+                    if source_lang == target_lang:
+                        return {
+                            'translated_text': text,
+                            'source_language': source_lang,
+                            'target_language': target_lang,
+                            'confidence': 1.0,
+                            'timestamp': datetime.utcnow().isoformat()
+                        }
+
+                    # Initialize translator
+                    translator = GoogleTranslator(
+                        source='auto',
+                        target=target_lang
+                    )
+
+                    # Perform translation
+                    translated_text = translator.translate(text)
+
+                logger.info(f"Translation result: {translated_text}")
+
+                return {
+                    'translated_text': translated_text,
+                    'source_language': source_lang,
+                    'target_language': target_lang,
+                    'confidence': 0.9,
+                    'timestamp': datetime.utcnow().isoformat()
+                }
+
+            except Exception as e:
+                logger.error(f"Translation attempt {attempt + 1} failed: {str(e)}")
+                if attempt < max_retries - 1:
+                    time.sleep(1)
+                continue
+
+        return {
+            'error': 'Translation failed after maximum retries',
+            'timestamp': datetime.utcnow().isoformat()
+        }
+
+    def process_message(self, message_data: Dict) -> Dict:
+        """Process a chat message and return translation"""
+        try:
+            if not message_data.get('user_message'):
+                return {
+                    'error': 'No message provided',
+                    'timestamp': datetime.utcnow().isoformat()
+                }
+
+            target_lang = message_data.get('target_language', 'en').lower()
+            
+            # Validate target language
+            if target_lang not in self.supported_languages:
+                return {
+                    'error': f'Unsupported target language: {target_lang}',
+                    'timestamp': datetime.utcnow().isoformat()
+                }
+
+            result = self.translate(
+                message_data['user_message'],
+                target_lang
+            )
+
+            return {
+                'original_message': message_data['user_message'],
+                'translated_message': result.get('translated_text', ''),
+                'source_language': result.get('source_language', ''),
+                'target_language': target_lang,
+                'language_name': self.supported_languages.get(target_lang, ''),
+                'confidence': result.get('confidence', 0.0),
+                'timestamp': result.get('timestamp', datetime.utcnow().isoformat()),
+                'error': result.get('error')
+            }
+
+        except Exception as e:
+            logger.error(f"Message processing error: {str(e)}")
+            return {
+                'error': str(e),
+                'timestamp': datetime.utcnow().isoformat()
+            }

models/multilingual_translation/test_data/test_data.json

@@ -0,0 +1,156 @@
+{
+  "translation_tests": [
+    {
+      "user_message": "toilet me paani nahi aa rha hain",
+      "target_language": "en",
+      "expected_contains": ["toilet", "water", "not", "coming"]
+    },
+    {
+      "user_message": "AC ka temperature control kharab ho gaya hai",
+      "target_language": "en",
+      "expected_contains": ["AC", "temperature", "control", "broken"]
+    },
+    {
+      "user_message": "fan ki speed kam ho gayi hai",
+      "target_language": "en",
+      "expected_contains": ["fan", "speed", "reduced"]
+    },
+    {
+      "user_message": "The water heater is not working",
+      "target_language": "hi",
+      "expected_contains": ["पानी", "हीटर", "काम"]
+    },
+    {
+      "user_message": "Light bulb needs to be replaced",
+      "target_language": "hi",
+      "expected_contains": ["लाइट", "बल्ब", "बदलना"]
+    },
+    {
+      "user_message": "ਪੱਖਾ ਕੰਮ ਨਹੀਂ ਕਰ ਰਿਹਾ",
+      "target_language": "en",
+      "expected_contains": ["fan", "not", "working"]
+    },
+    {
+      "user_message": "The sink is clogged",
+      "target_language": "pa",
+      "expected_contains": ["ਸਿੰਕ", "ਬੰਦ"]
+    },
+    {
+      "user_message": "বাথরুমে জল নেই",
+      "target_language": "en",
+      "expected_contains": ["bathroom", "no", "water"]
+    },
+    {
+      "user_message": "Electricity is not working",
+      "target_language": "bn",
+      "expected_contains": ["বিদ্যুৎ", "কাজ"]
+    },
+    {
+      "user_message": "వాష్ బేసిన్ లో నీరు పోవడం లేదు",
+      "target_language": "en",
+      "expected_contains": ["washbasin", "water", "not", "draining"]
+    },
+    {
+      "user_message": "Door lock is broken",
+      "target_language": "te",
+      "expected_contains": ["తలుపు", "తాళం", "పగిలిపోయింది"]
+    },
+    {
+      "user_message": "குளியலறையில் தண்ணீர் கசிகிறது",
+      "target_language": "en",
+      "expected_contains": ["bathroom", "water", "leaking"]
+    },
+    {
+      "user_message": "Window is stuck",
+      "target_language": "ta",
+      "expected_contains": ["ஜன்னல்", "சிக்கி"]
+    },
+    {
+      "user_message": "room me light nahi chal rahi hai",
+      "target_language": "en",
+      "expected_contains": ["room", "light", "not", "working"]
+    },
+    {
+      "user_message": "bathroom ka tap leak ho raha hai",
+      "target_language": "en",
+      "expected_contains": ["bathroom", "tap", "leaking"]
+    },
+    {
+      "user_message": "AC remote not working",
+      "target_language": "hi",
+      "expected_contains": ["एसी", "रिमोट", "काम"]
+    },
+    {
+      "user_message": "ਬਾਥਰੂਮ ਦਾ ਸ਼ਾਵਰ ਖਰਾਬ ਹੈ",
+      "target_language": "en",
+      "expected_contains": ["bathroom", "shower", "broken"]
+    },
+    {
+      "user_message": "Geyser is not heating properly",
+      "target_language": "pa",
+      "expected_contains": ["ਗੀਜ਼ਰ", "ਗਰਮ"]
+    },
+    {
+      "user_message": "এসি থেকে পানি পড়ছে",
+      "target_language": "en",
+      "expected_contains": ["AC", "water", "dripping"]
+    },
+    {
+      "user_message": "Ceiling fan making noise",
+      "target_language": "bn",
+      "expected_contains": ["সিলিং", "ফ্যান", "আওয়াজ"]
+    },
+    {
+      "user_message": "కిటికీ తెరవడం లేదు",
+      "target_language": "en",
+      "expected_contains": ["window", "not", "opening"]
+    },
+    {
+      "user_message": "Bed frame is broken",
+      "target_language": "te",
+      "expected_contains": ["మంచం", "ఫ్రేమ్", "విరిగింది"]
+    },
+    {
+      "user_message": "மின்விசிறி வேகம் குறைந்துள்ளது",
+      "target_language": "en",
+      "expected_contains": ["fan", "speed", "reduced"]
+    },
+    {
+      "user_message": "TV not turning on",
+      "target_language": "ta",
+      "expected_contains": ["டிவி", "ஆன்", "ஆகவில்லை"]
+    },
+    {
+      "user_message": "balcony ka darwaza band ho gaya hai",
+      "target_language": "en",
+      "expected_contains": ["balcony", "door", "stuck"]
+    }
+  ],
+  "language_detection_tests": [
+    {
+      "text": "This is English text",
+      "expected_language": "en"
+    },
+    {
+      "text": "यह हिंदी टेक्स्ट है",
+      "expected_language": "hi"
+    },
+    {
+      "text": "ਇਹ ਪੰਜਾਬੀ ਟੈਕਸਟ ਹੈ",
+      "expected_language": "pa"
+    },
+    {
+      "text": "এটি বাংলা টেক্সট",
+      "expected_language": "bn"
+    },
+    {
+      "text": "ఇది తెలుగు టెక్స్ట్",
+      "expected_language": "te"
+    },
+    {
+      "text": "இது தமிழ் உரை",
+      "expected_language": "ta"
+    }
+  ]
+}
+

models/multilingual_translation/test_model.py

@@ -0,0 +1,160 @@
+import json
+import logging
+from datetime import datetime
+import os
+from model import MultilingualTranslationModel
+import time
+
+# Configure logging with UTF-8 encoding
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('translation_testing.log', encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class TranslationTester:
+    def __init__(self):
+        self.model = MultilingualTranslationModel()
+        self.results_dir = 'models/multilingual_translation/test_results'
+        os.makedirs(self.results_dir, exist_ok=True)
+
+    def load_test_data(self):
+        """Load test data from JSON file"""
+        test_data_path = 'models/multilingual_translation/test_data/test_data.json'
+        try:
+            with open(test_data_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f"Error loading test data: {str(e)}")
+            raise
+
+    def test_translations(self):
+        """Test translation with sample messages"""
+        test_data = self.load_test_data()
+        test_cases = test_data['translation_tests']
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting translation:")
+            logger.info(f"Original: {case['user_message']}")
+            logger.info(f"Target Language: {case['target_language']}")
+            
+            result = self.model.process_message(case)
+            
+            # Add test-specific fields
+            result['expected_contains'] = case['expected_contains']
+            
+            # Check if translation contains expected words
+            translation = result.get('translated_message', '').lower()
+            contains_expected = all(
+                word.lower() in translation 
+                for word in case['expected_contains']
+            ) if not result.get('error') else False
+            
+            result['translation_quality'] = 'Good' if contains_expected else 'Check needed'
+            
+            # Log the result
+            logger.info(f"Translation: {result.get('translated_message', 'No translation')}")
+            logger.info(f"Quality: {result['translation_quality']}")
+            logger.info(f"Confidence: {result.get('confidence', 0.0):.2f}")
+            
+            if result.get('error'):
+                logger.warning(f"Error: {result['error']}")
+            
+            results.append(result)
+            time.sleep(1)  # Avoid rate limiting
+
+        return results
+
+    def test_language_detection(self):
+        """Test language detection"""
+        test_data = self.load_test_data()
+        test_cases = test_data['language_detection_tests']
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting language detection:")
+            logger.info(f"Text: {case['text']}")
+            
+            detected_lang = self.model.detect_language(case['text'])
+            
+            result = {
+                'text': case['text'],
+                'detected_language': detected_lang,
+                'expected_language': case['expected_language'],
+                'is_correct': detected_lang == case['expected_language']
+            }
+            
+            logger.info(f"Detected: {detected_lang}")
+            logger.info(f"Expected: {case['expected_language']}")
+            
+            results.append(result)
+            time.sleep(1)
+
+        return results
+
+    def run_full_test(self):
+        """Run complete test suite"""
+        logger.info("Starting translation testing")
+        
+        try:
+            # Test translations
+            translation_results = self.test_translations()
+            
+            # Test language detection
+            detection_results = self.test_language_detection()
+            
+            # Prepare report
+            report = {
+                'test_timestamp': datetime.utcnow().isoformat(),
+                'translation_tests': {
+                    'total': len(translation_results),
+                    'successful': sum(1 for r in translation_results if not r.get('error')),
+                    'good_quality': sum(1 for r in translation_results if r.get('translation_quality') == 'Good'),
+                    'detailed_results': translation_results
+                },
+                'detection_tests': {
+                    'total': len(detection_results),
+                    'successful': sum(1 for r in detection_results if r['is_correct']),
+                    'detailed_results': detection_results
+                }
+            }
+            
+            # Save report
+            report_path = f'{self.results_dir}/test_report.json'
+            with open(report_path, 'w', encoding='utf-8') as f:
+                json.dump(report, f, indent=2, ensure_ascii=False)
+            
+            logger.info(f"Testing completed. Results saved to {report_path}")
+            
+            return report
+            
+        except Exception as e:
+            logger.error(f"Error during testing: {str(e)}", exc_info=True)
+            raise
+
+def main():
+    try:
+        tester = TranslationTester()
+        report = tester.run_full_test()
+        
+        print("\nTest Results Summary:")
+        print("Translation Tests:")
+        print(f"Total: {report['translation_tests']['total']}")
+        print(f"Successful: {report['translation_tests']['successful']}")
+        print(f"Good Quality: {report['translation_tests']['good_quality']}")
+        print("\nLanguage Detection Tests:")
+        print(f"Total: {report['detection_tests']['total']}")
+        print(f"Successful: {report['detection_tests']['successful']}")
+        
+    except Exception as e:
+        logger.error(f"Error in main: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/multilingual_translation/train_data/training_data.json

@@ -0,0 +1,7 @@
+{
+    "data": [],
+    "metadata": {
+        "version": "1.0",
+        "created_at": "2024-03-20"
+    }
+}

models/sentiment_analysis/model.py

@@ -0,0 +1,118 @@
+import requests
+import logging
+from typing import Dict
+import os
+from datetime import datetime
+import time
+
+logger = logging.getLogger(__name__)
+
+class SentimentAnalysisModel:
+    def __init__(self):
+        # Hugging Face API configuration
+        self.api_url = "https://api-inference.huggingface.co/models/finiteautomata/bertweet-base-sentiment-analysis"
+        self.headers = {
+            "Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_TOKEN')}",
+            "Content-Type": "application/json"
+        }
+        
+        # Emotion mapping from the model's output to our categories
+        self.emotion_mapping = {
+            'POS': 'Satisfaction',
+            'NEU': 'Indifference',
+            'NEG': 'Frustration'
+        }
+
+    def predict(self, text: str, max_retries=3, retry_delay=5) -> Dict:
+        """
+        Get sentiment prediction from Hugging Face API with retry logic
+        """
+        for attempt in range(max_retries):
+            try:
+                response = requests.post(
+                    self.api_url,
+                    headers=self.headers,
+                    json={"inputs": text}
+                )
+                
+                if response.status_code == 503:
+                    # Model is loading, wait and retry
+                    wait_time = min(retry_delay * (attempt + 1), 20)
+                    logger.info(f"Model is loading, waiting {wait_time} seconds before retry...")
+                    time.sleep(wait_time)
+                    continue
+                    
+                if response.status_code != 200:
+                    logger.error(f"API request failed with status code: {response.status_code}")
+                    logger.error(f"Response content: {response.text}")
+                    continue
+                    
+                # Process response
+                result = response.json()
+                
+                if isinstance(result, list) and len(result) > 0:
+                    # Get the prediction with highest score
+                    prediction = max(result[0], key=lambda x: x['score'])
+                    
+                    # Map to our emotion categories
+                    mapped_emotion = self.emotion_mapping.get(
+                        prediction['label'], 
+                        'Indifference'
+                    )
+                    
+                    return {
+                        'emotional_label': mapped_emotion,
+                        'confidence': prediction['score'],
+                        'timestamp': datetime.utcnow().isoformat()
+                    }
+                
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1} failed: {str(e)}")
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                continue
+        
+        # If all retries failed, return default response
+        return {
+            'emotional_label': 'Indifference',
+            'confidence': 0.0,
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': "Failed after maximum retries"
+        }
+
+    def process_grievance(self, grievance_data: Dict) -> Dict:
+        """
+        Process a grievance and return sentiment analysis
+        """
+        try:
+            if not grievance_data.get('text'):
+                return {
+                    'grievance_id': grievance_data.get('grievance_id', 'unknown'),
+                    'emotional_label': 'Indifference',
+                    'confidence': 0.0,
+                    'analysis_timestamp': datetime.utcnow().isoformat(),
+                    'error': 'No text provided'
+                }
+            
+            # Add some context to help with sentiment analysis
+            context_text = f"In a hostel maintenance context: {grievance_data['text']}"
+            sentiment_result = self.predict(context_text)
+            
+            return {
+                'grievance_id': grievance_data.get('grievance_id', 'unknown'),
+                'text': grievance_data['text'],
+                'emotional_label': sentiment_result['emotional_label'],
+                'confidence': sentiment_result['confidence'],
+                'analysis_timestamp': sentiment_result['timestamp'],
+                'error': sentiment_result.get('error')
+            }
+            
+        except Exception as e:
+            logger.error(f"Error processing grievance: {str(e)}")
+            return {
+                'grievance_id': grievance_data.get('grievance_id', 'unknown'),
+                'emotional_label': 'Indifference',
+                'confidence': 0.0,
+                'analysis_timestamp': datetime.utcnow().isoformat(),
+                'error': str(e)
+            }

models/sentiment_analysis/test_data/test_data.json

@@ -0,0 +1,773 @@
+[
+    {
+        "grievance_id": "G12347",
+        "text": "I am extremely frustrated with the constant power outages in my room.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12348",
+        "text": "Thank you for resolving my issue so quickly! Great service!",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12349",
+        "text": "Why hasn't the maintenance team fixed the leaking roof yet? This is unacceptable!",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12350",
+        "text": "The water pressure is slightly low today.",
+        "expected_emotion": "Indifference"
+    },
+    {
+        "grievance_id": "G12351",
+        "text": "The geyser in the toilet is not working properly.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12352",
+        "text": "I am happy with the new cleaning schedule.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12353",
+        "text": "The food quality in the mess has improved significantly.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12354",
+        "text": "There is no AC in my room, and it's very uncomfortable.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12355",
+        "text": "The heater is not available in the hostel, and it's freezing.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12356",
+        "text": "The new warden is very approachable and helpful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12357",
+        "text": "The internet speed is too slow for my online classes.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12358",
+        "text": "The library hours have been extended, which is great!",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12359",
+        "text": "The water cooler is not dispensing cold water.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12360",
+        "text": "The maintenance team fixed the broken window quickly.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12361",
+        "text": "The noise from the construction is unbearable.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12362",
+        "text": "The new gym equipment is fantastic!",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12363",
+        "text": "The laundry service is often delayed.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12364",
+        "text": "The hostel garden is well-maintained and beautiful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12365",
+        "text": "The security staff is very vigilant and polite.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12366",
+        "text": "The room cleaning service is inconsistent.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12367",
+        "text": "The study room is too crowded during exam times.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12368",
+        "text": "The hostel management is very responsive to our needs.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12369",
+        "text": "The fire alarm went off without any reason.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12370",
+        "text": "The new recreational area is a great addition.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12371",
+        "text": "The water supply is often interrupted.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12372",
+        "text": "The hostel events are well-organized and fun.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12373",
+        "text": "The room furniture is old and needs replacement.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12374",
+        "text": "The hostel staff is very courteous and helpful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12375",
+        "text": "The parking area is too small for all residents.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12376",
+        "text": "The hostel is very clean and well-maintained.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12377",
+        "text": "The room keys are often misplaced by the staff.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12378",
+        "text": "The hostel location is very convenient for commuting.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12379",
+        "text": "The hostel rules are too strict and inflexible.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12380",
+        "text": "The hostel provides a very safe environment.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12381",
+        "text": "The room walls are too thin, and noise is a problem.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12382",
+        "text": "The hostel has a very friendly community.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12383",
+        "text": "The hostel Wi-Fi is often down during peak hours.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12384",
+        "text": "The hostel provides excellent study facilities.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12385",
+        "text": "The hostel's emergency response is very slow.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12386",
+        "text": "The hostel has a great view of the city.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12387",
+        "text": "The hostel's maintenance requests take too long to process.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12388",
+        "text": "The hostel's cultural events are very enriching.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12389",
+        "text": "The hostel's dining area is too small for all residents.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12390",
+        "text": "The hostel's sports facilities are top-notch.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12391",
+        "text": "The hostel's laundry machines are often out of order.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12392",
+        "text": "The hostel's location is very peaceful and quiet.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12393",
+        "text": "The hostel's fire drills are not conducted regularly.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12394",
+        "text": "The hostel's common areas are very well-decorated.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12395",
+        "text": "The hostel's check-in process is very cumbersome.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12396",
+        "text": "The hostel's staff is very efficient and friendly.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12397",
+        "text": "The hostel's maintenance team is not responsive.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12398",
+        "text": "The hostel's environment is very conducive to studying.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12399",
+        "text": "The hostel's food menu lacks variety.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12400",
+        "text": "The hostel's management is very proactive.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12401",
+        "text": "The hostel's water supply is often contaminated.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12402",
+        "text": "The hostel's cultural diversity is very enriching.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12403",
+        "text": "The hostel's room allocation process is very slow.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12404",
+        "text": "The hostel's community events are very engaging.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12405",
+        "text": "The hostel's maintenance requests are often ignored.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12406",
+        "text": "The hostel's location is very convenient for shopping.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12407",
+        "text": "The hostel's room cleaning is not thorough.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12408",
+        "text": "The hostel's staff is very attentive to our needs.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12409",
+        "text": "The hostel's Wi-Fi is often unreliable.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12410",
+        "text": "The hostel's facilities are very modern and up-to-date.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12411",
+        "text": "The hostel's maintenance team is very slow to respond.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12412",
+        "text": "The hostel's environment is very welcoming.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12413",
+        "text": "The hostel's dining area is often overcrowded.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12414",
+        "text": "The hostel's recreational facilities are excellent.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12415",
+        "text": "The hostel's laundry service is often delayed.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12416",
+        "text": "The hostel's location is very scenic.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12417",
+        "text": "The hostel's fire safety measures are inadequate.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12418",
+        "text": "The hostel's common areas are very spacious.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12419",
+        "text": "The hostel's check-out process is very tedious.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12420",
+        "text": "The hostel's staff is very professional.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12421",
+        "text": "The hostel's maintenance requests are often mishandled.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12422",
+        "text": "The hostel's environment is very conducive to relaxation.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12423",
+        "text": "The hostel's food quality is inconsistent.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12424",
+        "text": "The hostel's management is very supportive.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12425",
+        "text": "The hostel's water supply is often interrupted.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12426",
+        "text": "The hostel's cultural events are very inclusive.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12427",
+        "text": "The hostel's room allocation is often delayed.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12428",
+        "text": "The hostel's community is very vibrant.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12429",
+        "text": "The hostel's maintenance team is not efficient.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12430",
+        "text": "The hostel's location is very convenient for public transport.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12431",
+        "text": "The hostel's room cleaning is not up to standard.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12432",
+        "text": "The hostel's staff is very accommodating.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12433",
+        "text": "The hostel's Wi-Fi is often down.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12434",
+        "text": "The hostel's facilities are very well-maintained.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12435",
+        "text": "The hostel's maintenance team is very slow.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12436",
+        "text": "The hostel's environment is very peaceful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12437",
+        "text": "The hostel's dining area is too small.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12438",
+        "text": "The hostel's recreational facilities are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12439",
+        "text": "The hostel's laundry service is often late.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12440",
+        "text": "The hostel's location is very beautiful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12441",
+        "text": "The hostel's fire safety is not adequate.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12442",
+        "text": "The hostel's common areas are very nice.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12443",
+        "text": "The hostel's check-out process is very slow.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12444",
+        "text": "The hostel's staff is very helpful.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12445",
+        "text": "The hostel's maintenance requests are often ignored.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12446",
+        "text": "The hostel's environment is very relaxing.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12447",
+        "text": "The hostel's food is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12448",
+        "text": "The hostel's management is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12449",
+        "text": "The hostel's water supply is not reliable.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12450",
+        "text": "The hostel's cultural events are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12451",
+        "text": "The hostel's room allocation is not fast.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12452",
+        "text": "The hostel's community is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12453",
+        "text": "The hostel's maintenance team is not fast.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12454",
+        "text": "The hostel's location is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12455",
+        "text": "The hostel's room cleaning is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12456",
+        "text": "The hostel's staff is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12457",
+        "text": "The hostel's Wi-Fi is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12458",
+        "text": "The hostel's facilities are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12459",
+        "text": "The hostel's maintenance team is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12460",
+        "text": "The hostel's environment is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12461",
+        "text": "The hostel's dining area is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12462",
+        "text": "The hostel's recreational facilities are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12463",
+        "text": "The hostel's laundry service is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12464",
+        "text": "The hostel's location is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12465",
+        "text": "The hostel's fire safety is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12466",
+        "text": "The hostel's common areas are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12467",
+        "text": "The hostel's check-out process is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12468",
+        "text": "The hostel's staff is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12469",
+        "text": "The hostel's maintenance requests are not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12470",
+        "text": "The hostel's environment is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12471",
+        "text": "The hostel's food is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12472",
+        "text": "The hostel's management is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12473",
+        "text": "The hostel's water supply is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12474",
+        "text": "The hostel's cultural events are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12475",
+        "text": "The hostel's room allocation is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12476",
+        "text": "The hostel's community is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12477",
+        "text": "The hostel's maintenance team is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12478",
+        "text": "The hostel's location is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12479",
+        "text": "The hostel's room cleaning is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12480",
+        "text": "The hostel's staff is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12481",
+        "text": "The hostel's Wi-Fi is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12482",
+        "text": "The hostel's facilities are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12483",
+        "text": "The hostel's maintenance team is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12484",
+        "text": "The hostel's environment is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12485",
+        "text": "The hostel's dining area is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12486",
+        "text": "The hostel's recreational facilities are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12487",
+        "text": "The hostel's laundry service is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12488",
+        "text": "The hostel's location is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12489",
+        "text": "The hostel's fire safety is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12490",
+        "text": "The hostel's common areas are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12491",
+        "text": "The hostel's check-out process is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12492",
+        "text": "The hostel's staff is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12493",
+        "text": "The hostel's maintenance requests are not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12494",
+        "text": "The hostel's environment is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12495",
+        "text": "The hostel's food is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12496",
+        "text": "The hostel's management is very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12497",
+        "text": "The hostel's water supply is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12498",
+        "text": "The hostel's cultural events are very good.",
+        "expected_emotion": "Satisfaction"
+    },
+    {
+        "grievance_id": "G12499",
+        "text": "The hostel's room allocation is not good.",
+        "expected_emotion": "Frustration"
+    },
+    {
+        "grievance_id": "G12500",
+        "text": "The hostel's community is very good.",
+        "expected_emotion": "Satisfaction"
+    }
+]
+

models/sentiment_analysis/test_model.py

@@ -0,0 +1,125 @@
+import json
+import logging
+from datetime import datetime
+import os
+from model import SentimentAnalysisModel
+import time
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('sentiment_analysis_testing.log'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class SentimentAnalysisTester:
+    def __init__(self):
+        self.model = SentimentAnalysisModel()
+        self.results_dir = 'models/sentiment_analysis/test_results'
+        self.test_data_path = 'models/sentiment_analysis/test_data/test_data.json'
+        os.makedirs(self.results_dir, exist_ok=True)
+
+    def load_test_cases(self):
+        """Load test cases from JSON file"""
+        try:
+            with open(self.test_data_path, 'r') as f:
+                test_cases = json.load(f)
+            logger.info(f"Successfully loaded {len(test_cases)} test cases")
+            return test_cases
+        except Exception as e:
+            logger.error(f"Error loading test cases: {str(e)}", exc_info=True)
+            raise
+
+    def test_sample_grievances(self):
+        """Test model with sample grievances"""
+        test_cases = self.load_test_cases()
+        results = []
+
+        for case in test_cases:
+            logger.info(f"\nTesting grievance {case['grievance_id']}")
+            logger.info(f"Text: {case['text']}")
+            
+            result = self.model.process_grievance({
+                'grievance_id': case['grievance_id'],
+                'text': case['text']
+            })
+            
+            # Add test-specific fields
+            result['expected_emotion'] = case['expected_emotion']
+            result['matches_expected'] = (
+                result.get('emotional_label') == case['expected_emotion']
+            )
+            
+            # Log the result
+            logger.info(
+                f"Result: Expected={case['expected_emotion']}, "
+                f"Got={result.get('emotional_label', 'Unknown')}, "
+                f"Confidence={result.get('confidence', 0.0):.2f}"
+            )
+            
+            if result.get('error'):
+                logger.warning(f"Error in result: {result['error']}")
+            
+            results.append(result)
+            
+            # Add a small delay between requests to avoid rate limiting
+            time.sleep(1)
+
+        return results
+
+    def run_full_test(self):
+        """Run complete test suite"""
+        logger.info("Starting sentiment analysis testing")
+        
+        try:
+            # Test sample grievances
+            results = self.test_sample_grievances()
+            
+            # Calculate accuracy
+            correct = sum(1 for r in results if r.get('matches_expected', False))
+            accuracy = correct / len(results) if results else 0
+            
+            # Prepare report
+            report = {
+                'test_timestamp': datetime.utcnow().isoformat(),
+                'accuracy': accuracy,
+                'total_tests': len(results),
+                'correct_predictions': correct,
+                'detailed_results': results
+            }
+            
+            # Save report
+            report_path = f'{self.results_dir}/test_report.json'
+            with open(report_path, 'w') as f:
+                json.dump(report, f, indent=2)
+            
+            logger.info(f"Testing completed. Results saved to {report_path}")
+            logger.info(f"Accuracy: {accuracy:.2%}")
+            
+            return report
+            
+        except Exception as e:
+            logger.error(f"Error during testing: {str(e)}", exc_info=True)
+            raise
+
+def main():
+    try:
+        tester = SentimentAnalysisTester()
+        report = tester.run_full_test()
+        
+        print("\nTest Results Summary:")
+        print(f"Accuracy: {report['accuracy']:.2%}")
+        print(f"Total Tests: {report['total_tests']}")
+        print(f"Correct Predictions: {report['correct_predictions']}")
+        
+    except Exception as e:
+        logger.error(f"Error in main: {str(e)}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    main()

models/sentiment_analysis/train_data/training_data.json

@@ -0,0 +1,7 @@
+{
+    "data": [],
+    "metadata": {
+        "version": "1.0",
+        "created_at": "2024-03-20"
+    }
+}

requirements.txt

@@ -0,0 +1,37 @@
+# Web Framework
+flask
+flask-cors
+gunicorn
+uvicorn
+
+# ML & Data Science
+tensorflow
+torch
+transformers
+scikit-learn
+pandas
+numpy
+matplotlib
+seaborn
+
+# Translation
+deep-translator
+langdetect
+
+# Authentication & API
+python-jose
+python-multipart
+pydantic
+
+# Testing
+pytest
+requests
+
+# Environment & Utils
+python-dotenv
+
+# Additional from file_context_0
+gradio
+protobuf
+sentencepiece
+streamlit

routes.py

@@ -0,0 +1,21 @@
+from models.multilingual_translation.model import MultilingualTranslationModel
+from models.sentiment_analysis.model import SentimentAnalysisModel
+from models.intelligent_routing.model import IntelligentRoutingModel
+from models.job_recommendation.model import JobRecommendationModel
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# Initialize models
+translation_model = MultilingualTranslationModel()
+sentiment_model = SentimentAnalysisModel()
+routing_model = IntelligentRoutingModel()
+job_model = JobRecommendationModel()
+
+# Load models
+try:
+    routing_model.load_model('models/intelligent_routing/saved_model/model.keras')
+    job_model.load_model('models/job_recommendation/saved_model/model.keras')
+except Exception as e:
+    logger.error(f"Error loading models: {str(e)}")

space.yml

@@ -0,0 +1,7 @@
+title: Hostel Management System
+emoji: 🏨
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+app_file: app.py
+pinned: false

test_endpoints.py

@@ -0,0 +1,437 @@
+import requests
+import json
+import logging
+from datetime import datetime
+import time
+import os
+import sys
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('endpoint_testing.log', encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class EndpointTester:
+    def __init__(self, base_url='https://huggingface.co/spaces/ArchCoder/Hostel-Management-and-Greivance-Redressal-System'):
+        self.base_url = base_url
+        self.results_dir = 'test_results1'
+        # Create results directory if it doesn't exist
+        os.makedirs(self.results_dir, exist_ok=True)
+
+    def test_translation_endpoint(self):
+        """Test the translation endpoint"""
+        endpoint = f'{self.base_url}/translate'
+        test_cases = [
+            {
+                "user_message": "toilet me paani nahi aa rha hain",
+                "target_language": "en"
+            },
+            {
+                "user_message": "AC not working properly",
+                "target_language": "hi"
+            },
+            {
+                "user_message": "ਪੱਖਾ ਕੰਮ ਨਹੀਂ ਕਰ ਰਿਹਾ",
+                "target_language": "en"
+            }
+        ]
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting translation endpoint:")
+            logger.info(f"Input: {case}")
+            
+            try:
+                response = requests.post(endpoint, json=case)
+                result = response.json()
+                
+                logger.info(f"Status Code: {response.status_code}")
+                logger.info(f"Response: {result}")
+                
+                results.append({
+                    'test_case': case,
+                    'status_code': response.status_code,
+                    'response': result
+                })
+                
+            except Exception as e:
+                logger.error(f"Error testing translation: {str(e)}")
+                
+            time.sleep(1)  # Rate limiting
+            
+        return results
+
+    def test_sentiment_analysis_endpoint(self):
+        """Test the sentiment analysis endpoint"""
+        endpoint = f'{self.base_url}/analyze-sentiment'
+        test_cases = [
+            {
+                "grievance_id": "G12347",
+                "text": "I am extremely frustrated with the constant power outages in my room."
+            },
+            {
+                "grievance_id": "G12348",
+                "text": "Thank you for quickly fixing the water issue."
+            },
+            {
+                "grievance_id": "G12349",
+                "text": "The AC has been making strange noises all night."
+            }
+        ]
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting sentiment analysis endpoint:")
+            logger.info(f"Input: {case}")
+            
+            try:
+                response = requests.post(endpoint, json=case)
+                result = response.json()
+                
+                logger.info(f"Status Code: {response.status_code}")
+                logger.info(f"Response: {result}")
+                
+                results.append({
+                    'test_case': case,
+                    'status_code': response.status_code,
+                    'response': result
+                })
+                
+            except Exception as e:
+                logger.error(f"Error testing sentiment analysis: {str(e)}")
+                
+            time.sleep(1)
+            
+        return results
+
+    def test_routing_endpoint(self):
+        """Test the grievance routing endpoint"""
+        endpoint = f'{self.base_url}/route-grievance'
+        test_cases = [
+                {
+                "grievance_id": "G67890",
+                "category": "water_cooler",
+                "submission_timestamp": "2024-10-28T04:22:13Z",
+                "student_room_no": "148",
+                "hostel_name": "bh2",
+                "floor_number": 3,
+                "current_staff_status": [
+                {
+                    "staff_id": "S84148",
+                    "department": "water_cooler",
+                    "current_workload": 0,
+                    "availability_status": "Unavailable",
+                    "past_resolution_rate": 0.98
+                },
+                {
+                    "staff_id": "S57369",
+                    "department": "water_cooler",
+                    "current_workload": 0,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.96
+                }
+                ],
+                "floor_metrics": {
+                "number_of_requests": 0,
+                "total_delays": 4
+                },
+                "availability_data": {
+                "staff_availability": [
+                    {
+                    "staff_id": "S84148",
+                    "time_slot": "08:00-12:00",
+                    "availability_status": "Available"
+                    }
+                ],
+                "student_availability": [
+                    {
+                    "student_id": "STU200",
+                    "time_slot": "16:00-20:00",
+                    "availability_status": "Available"
+                    }
+                ]
+                }
+            },
+            {
+                "grievance_id": "G67891",
+                "category": "carpenter",
+                "submission_timestamp": "2024-10-28T04:18:13Z",
+                "student_room_no": "213",
+                "hostel_name": "bh1",
+                "floor_number": 2,
+                "current_staff_status": [
+                {
+                    "staff_id": "S52775",
+                    "department": "carpenter",
+                    "current_workload": 5,
+                    "availability_status": "Unavailable",
+                    "past_resolution_rate": 0.98
+                },
+                {
+                    "staff_id": "S24943",
+                    "department": "carpenter",
+                    "current_workload": 3,
+                    "availability_status": "Unavailable",
+                    "past_resolution_rate": 0.85
+                }
+                ],
+                "floor_metrics": {
+                "number_of_requests": 29,
+                "total_delays": 4
+                },
+                "availability_data": {
+                "staff_availability": [
+                    {
+                    "staff_id": "S52775",
+                    "time_slot": "12:00-16:00",
+                    "availability_status": "Unavailable"
+                    }
+                ],
+                "student_availability": [
+                    {
+                    "student_id": "STU201",
+                    "time_slot": "08:00-12:00",
+                    "availability_status": "Available"
+                    }
+                ]
+                }
+            },
+            {
+                "grievance_id": "G67892",
+                "category": "electricity",
+                "submission_timestamp": "2024-10-28T04:00:13Z",
+                "student_room_no": "275",
+                "hostel_name": "bh3",
+                "floor_number": 2,
+                "current_staff_status": [
+                {
+                    "staff_id": "S33368",
+                    "department": "electricity",
+                    "current_workload": 1,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.95
+                },
+                {
+                    "staff_id": "S20522",
+                    "department": "electricity",
+                    "current_workload": 5,
+                    "availability_status": "Available",
+                    "past_resolution_rate": 0.87
+                }
+                ],
+                "floor_metrics": {
+                "number_of_requests": 2,
+                "total_delays": 3
+                },
+                "availability_data": {
+                "staff_availability": [
+                    {
+                    "staff_id": "S33368",
+                    "time_slot": "12:00-16:00",
+                    "availability_status": "Unavailable"
+                    }
+                ],
+                "student_availability": [
+                    {
+                    "student_id": "STU202",
+                    "time_slot": "08:00-12:00",
+                    "availability_status": "Unavailable"
+                    }
+                ]
+                }
+            }
+        ]
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting routing endpoint:")
+            logger.info(f"Input: {case}")
+            
+            try:
+                response = requests.post(endpoint, json=case)
+                result = response.json()
+                
+                logger.info(f"Status Code: {response.status_code}")
+                logger.info(f"Response: {result}")
+                
+                results.append({
+                    'test_case': case,
+                    'status_code': response.status_code,
+                    'response': result
+                })
+                
+            except Exception as e:
+                logger.error(f"Error testing routing: {str(e)}")
+                
+            time.sleep(1)
+            
+        return results
+
+    def test_job_recommendation_endpoint(self):
+        """Test the job recommendation endpoint"""
+        endpoint = f'{self.base_url}/recommend-job'
+        test_cases = [
+            {
+                "job_id": "J60000",
+                "type": "IT",
+                "description": "IT issue in room 358.",
+                "urgency_level": "Low",
+                "location": {
+                    "hostel_name": "Hostel B",
+                    "floor_number": 3,
+                    "room_number": "358"
+                },
+                "workers": [
+                    {
+                        "worker_id": "W97053",
+                        "department": "IT",
+                        "current_workload": 3,
+                        "availability_status": "Available",
+                        "job_success_rate": 0.95,
+                        "current_location": {
+                            "hostel_name": "Hostel A",
+                            "floor_number": 3,
+                            "room_number": "468"
+                        }
+                    },
+                    {
+                        "worker_id": "W97054",
+                        "department": "IT",
+                        "current_workload": 1,
+                        "availability_status": "Available",
+                        "job_success_rate": 0.92,
+                        "current_location": {
+                            "hostel_name": "Hostel B",
+                            "floor_number": 3,
+                            "room_number": "360"
+                        }
+                    }
+                ]
+            }
+        ]
+
+        results = []
+        for case in test_cases:
+            logger.info(f"\nTesting job recommendation endpoint:")
+            logger.info(f"Input: {case}")
+            
+            try:
+                response = requests.post(endpoint, json=case)
+                result = response.json()
+                
+                logger.info(f"Status Code: {response.status_code}")
+                logger.info(f"Response: {result}")
+                
+                results.append({
+                    'test_case': case,
+                    'status_code': response.status_code,
+                    'response': result
+                })
+                
+            except Exception as e:
+                logger.error(f"Error testing job recommendation: {str(e)}")
+                
+            time.sleep(1)
+            
+        return results
+
+    def test_health_endpoint(self):
+        """Test the health check endpoint"""
+        endpoint = f'{self.base_url}/health'
+        
+        try:
+            response = requests.get(endpoint)
+            result = response.json()
+            
+            logger.info("\nTesting health endpoint:")
+            logger.info(f"Status Code: {response.status_code}")
+            logger.info(f"Response: {result}")
+            
+            return {
+                'status_code': response.status_code,
+                'response': result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error testing health endpoint: {str(e)}")
+            return None
+
+    def run_all_tests(self):
+        """Run all endpoint tests"""
+        try:
+            # Test health endpoint first
+            health_result = self.test_health_endpoint()
+            if not health_result or health_result['status_code'] != 200:
+                logger.error("Health check failed. Skipping other tests.")
+                return
+            
+            # Run all tests
+            results = {
+                'timestamp': datetime.utcnow().isoformat(),
+                'health_check': health_result,
+                'translation_tests': self.test_translation_endpoint(),
+                'sentiment_analysis_tests': self.test_sentiment_analysis_endpoint(),
+                'routing_tests': self.test_routing_endpoint(),
+                'job_recommendation_tests': self.test_job_recommendation_endpoint()
+            }
+            
+            # Save results
+            try:
+                results_file = os.path.join(self.results_dir, 'endpoint_test_results.json')
+                with open(results_file, 'w', encoding='utf-8') as f:
+                    json.dump(results, f, indent=2, ensure_ascii=False)
+                logger.info(f"Test results saved to {results_file}")
+            except Exception as e:
+                logger.error(f"Error saving results: {str(e)}")
+                # Continue execution even if saving fails
+            
+            logger.info("All tests completed successfully")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error running tests: {str(e)}")
+            return {
+                'timestamp': datetime.utcnow().isoformat(),
+                'error': str(e),
+                'completed_tests': []
+            }
+
+def main():
+    try:
+        tester = EndpointTester()
+        results = tester.run_all_tests()
+        
+        if not results:
+            logger.error("No test results available")
+            return
+            
+        # Print summary
+        print("\nTest Results Summary:")
+        for test_type, test_results in results.items():
+            if test_type in ['timestamp', 'error']:
+                continue
+                
+            print(f"\n{test_type.replace('_', ' ').title()}:")
+            if isinstance(test_results, list):
+                success = sum(1 for r in test_results if r['status_code'] == 200)
+                total = len(test_results)
+                print(f"Total: {total}")
+                print(f"Successful: {success}")
+                print(f"Failed: {total - success}")
+            else:
+                status = test_results.get('status_code') == 200 if test_results else False
+                print(f"Status: {'Success' if status else 'Failed'}")
+        
+    except Exception as e:
+        logger.error(f"Error in main: {str(e)}")
+        raise
+
+if __name__ == "__main__":
+    main()

test_results1/endpoint_test_results.json

@@ -0,0 +1,157 @@
+{
+  "timestamp": "2024-10-28T18:28:04.957085",
+  "health_check": {
+    "status_code": 200,
+    "response": {
+      "services": {
+        "intelligent_routing": "up",
+        "job_recommendation": "up",
+        "sentiment_analysis": "up",
+        "translation": "up"
+      },
+      "status": "healthy",
+      "timestamp": "2024-10-28T18:28:01.846113"
+    }
+  },
+  "translation_tests": [
+    {
+      "test_case": {
+        "user_message": "toilet me paani nahi aa rha hain",
+        "target_language": "en"
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.9,
+        "error": null,
+        "language_name": "English",
+        "original_message": "toilet me paani nahi aa rha hain",
+        "source_language": "hi",
+        "target_language": "en",
+        "timestamp": "2024-10-28T18:28:02.381673",
+        "translated_message": "There is no water coming in the toilet"
+      }
+    },
+    {
+      "test_case": {
+        "user_message": "AC not working properly",
+        "target_language": "hi"
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.9,
+        "error": null,
+        "language_name": "Hindi",
+        "original_message": "AC not working properly",
+        "source_language": "af",
+        "target_language": "hi",
+        "timestamp": "2024-10-28T18:28:09.334685",
+        "translated_message": "एसी ठीक से काम नहीं कर रहा है"
+      }
+    },
+    {
+      "test_case": {
+        "user_message": "ਪੱਖਾ ਕੰਮ ਨਹੀਂ ਕਰ ਰਿਹਾ",
+        "target_language": "en"
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.9,
+        "error": null,
+        "language_name": "English",
+        "original_message": "ਪੱਖਾ ਕੰਮ ਨਹੀਂ ਕਰ ਰਿਹਾ",
+        "source_language": "pa",
+        "target_language": "en",
+        "timestamp": "2024-10-28T18:28:10.832359",
+        "translated_message": "The fan is not working"
+      }
+    }
+  ],
+  "sentiment_analysis_tests": [
+    {
+      "test_case": {
+        "grievance_id": "G12347",
+        "text": "I am extremely frustrated with the constant power outages in my room."
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.98044353723526,
+        "emotional_label": "Frustration",
+        "grievance_id": "G12347",
+        "timestamp": "2024-10-28T18:28:12.376193"
+      }
+    },
+    {
+      "test_case": {
+        "grievance_id": "G12348",
+        "text": "Thank you for quickly fixing the water issue."
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.938926100730896,
+        "emotional_label": "Satisfaction",
+        "grievance_id": "G12348",
+        "timestamp": "2024-10-28T18:28:13.784609"
+      }
+    },
+    {
+      "test_case": {
+        "grievance_id": "G12349",
+        "text": "The AC has been making strange noises all night."
+      },
+      "status_code": 200,
+      "response": {
+        "confidence": 0.8782024383544922,
+        "emotional_label": "Frustration",
+        "grievance_id": "G12349",
+        "timestamp": "2024-10-28T18:28:15.172750"
+      }
+    }
+  ],
+  "routing_tests": [],
+  "job_recommendation_tests": [
+    {
+      "test_case": {
+        "job_id": "J60000",
+        "type": "IT",
+        "description": "IT issue in room 358.",
+        "urgency_level": "Low",
+        "location": {
+          "hostel_name": "Hostel B",
+          "floor_number": 3,
+          "room_number": "358"
+        },
+        "workers": [
+          {
+            "worker_id": "W97053",
+            "department": "IT",
+            "current_workload": 3,
+            "availability_status": "Available",
+            "job_success_rate": 0.95,
+            "current_location": {
+              "hostel_name": "Hostel A",
+              "floor_number": 3,
+              "room_number": "468"
+            }
+          },
+          {
+            "worker_id": "W97054",
+            "department": "IT",
+            "current_workload": 1,
+            "availability_status": "Available",
+            "job_success_rate": 0.92,
+            "current_location": {
+              "hostel_name": "Hostel B",
+              "floor_number": 3,
+              "room_number": "360"
+            }
+          }
+        ]
+      },
+      "status_code": 500,
+      "response": {
+        "details": "hour must be in 0..23",
+        "error": "Internal server error"
+      }
+    }
+  ]
+}

utils/__init__.py

@@ -0,0 +1,2 @@
+from .logger import setup_logger, get_logger
+

utils/dir_str_creater.py

@@ -0,0 +1,35 @@
+import os
+
+def print_directory_structure(startpath, exclude_dirs=None, indent=''):
+    if exclude_dirs is None:
+        exclude_dirs = ['myenv', '__pycache__']
+    
+    # Get list of items in directory
+    try:
+        items = os.listdir(startpath)
+    except PermissionError:
+        return
+
+    # Sort items to show directories first, then files
+    items.sort(key=lambda x: (not os.path.isdir(os.path.join(startpath, x)), x))
+    
+    for item in items:
+        path = os.path.join(startpath, item)
+        
+        # Skip excluded directories
+        if os.path.isdir(path) and item in exclude_dirs:
+            continue
+            
+        if os.path.isdir(path):
+            print(f'{indent}📁 {item}')
+            print_directory_structure(path, exclude_dirs, indent + '  ')
+        else:
+            print(f'{indent}📄 {item}')
+
+if __name__ == '__main__':
+    # You can modify the start path and excluded directories here
+    start_path = '.'  # Current directory
+    excluded_directories = ['myenv', 'node_modules', '__pycache__', '.git']  # Added .git
+    
+    print('Directory Structure:')
+    print_directory_structure(start_path, excluded_directories)

utils/logger.py

@@ -0,0 +1,30 @@
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+
+def setup_logger(log_level, log_format):
+    """Configure application logging"""
+    # Create logger
+    logger = logging.getLogger()
+    logger.setLevel(log_level)
+
+    # Create console handler with formatting
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(logging.Formatter(log_format))
+    logger.addHandler(console_handler)
+
+    # Create file handler with formatting
+    file_handler = RotatingFileHandler(
+        'app.log',
+        maxBytes=10000000,  # 10MB
+        backupCount=5
+    )
+    file_handler.setFormatter(logging.Formatter(log_format))
+    logger.addHandler(file_handler)
+
+    return logger
+
+def get_logger(name):
+    """Get logger instance for a specific module"""
+    return logging.getLogger(name)
+