Upload 62 files

.gitattributes

@@ -33,3 +33,5 @@ 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
+GS_Sales_Proposal/Client/__pycache__/client.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+GS_Sales_Proposal/Document_Upload_Vectordb/rfi2.pdf filter=lfs diff=lfs merge=lfs -text

GS_Sales_Proposal/.env

@@ -0,0 +1,3 @@
+GOOGLE_API_KEY=AIzaSyC_ojLXS1ysa83mUerhxxNMWIK10Z1MqjQ
+SERP_API_KEY = 0900f7a2f830083d80385bc46c1ff1f1e6626da3f568de640fe13759e9655450
+FILE_SAVE_PATH = "Document_Upload_Vectordb/Files"

GS_Sales_Proposal/.gitignore

@@ -0,0 +1,5 @@
+.env
+.pycache
+.pyc
+.ipynb
+.__pycache__

GS_Sales_Proposal/Client/__pycache__/client.cpython-313.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bcc0854139a4b9db9c029168978b5677fb1df4293bd788a31cbef0c5b5dfd83
+size 104585

GS_Sales_Proposal/Client/client_css.py

@@ -0,0 +1,448 @@
+client_css = """
+<style>
+    .client-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #667eea;
+        margin-bottom: 1rem;
+        color: #2a2a2a;
+    }
+    
+    .url-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #764ba2;
+        margin-bottom: 1rem;
+        color: #2a2a2a;
+    }
+    
+    .document-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border: 2px solid #5a9f9f;
+        margin-bottom: 1rem;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        color: #2a2a2a;
+    }
+    
+    .pain-points-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #ffc107;
+        color: #2a2a2a;
+    }
+    
+    .roles-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #2196f3;
+        color: #2a2a2a;
+    }
+    
+    .priorities-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #9c27b0;
+        color: #2a2a2a;
+    }
+    
+    .ai-suggestion-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #00bcd4;
+        color: #2a2a2a;
+    }
+    
+    .upload-section {
+        border: 2px dashed #667eea;
+        border-radius: 10px;
+        padding: 2rem;
+        text-align: center;
+        background: #f5f5f5;
+        color: #2a2a2a;
+    }
+    
+    /* Style section headers */
+    .section-header {
+        color: #2a2a2a;
+        font-size: 1.2rem;
+        font-weight: 600;
+        margin-bottom: 1rem;
+    }
+    
+    /* Mandatory field styling */
+    .mandatory-label {
+        color: #e74c3c;
+        font-weight: 600;
+    }
+    
+    .field-warning {
+        color: #e74c3c;
+        font-size: 0.85rem;
+        margin-top: 0.25rem;
+        font-weight: 500;
+        background: rgba(231, 76, 60, 0.1);
+        padding: 0.5rem;
+        border-radius: 4px;
+        border-left: 3px solid #e74c3c;
+    }
+    
+    .optional-label {
+        color: #666666;
+        font-size: 0.8rem;
+        font-style: italic;
+    }
+    
+    .ai-label {
+        color: #00bcd4;
+        font-size: 0.8rem;
+        font-style: italic;
+    }
+    
+    /* Custom styling for URL buttons */
+    .url-button-container {
+        display: flex;
+        gap: 5px;
+        align-items: center;
+    }
+    
+    .url-button {
+        background: #667eea;
+        color: white;
+        border: none;
+        padding: 8px 12px;
+        border-radius: 6px;
+        cursor: pointer;
+        font-size: 14px;
+        transition: background-color 0.3s;
+    }
+    
+    .url-button:hover {
+        background: #5a6fd8;
+    }
+    
+    /* Summary item styling */
+    .summary-item {
+        background: #f5f5f5;
+        border: 1px solid #5a9f9f;
+        border-radius: 8px;
+        padding: 12px;
+        margin-bottom: 8px;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        color: #2a2a2a;
+    }
+    
+    .summary-key {
+        font-weight: 600;
+        color: #667eea;
+    }
+    
+    .add-button {
+        background: #28a745;
+        color: white;
+        border: none;
+        padding: 6px 12px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 12px;
+        font-weight: bold;
+    }
+    
+    .add-button:hover {
+        background: #218838;
+    }
+    
+    .summary-buttons {
+        display: flex;
+        gap: 8px;
+        margin-bottom: 12px;
+    }
+    
+    .summary-control-btn {
+        background: #007bff;
+        color: white;
+        border: none;
+        padding: 6px 12px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 12px;
+    }
+    
+    .summary-control-btn:hover {
+        background: #0056b3;
+    }
+    
+    /* Fixed tooltip label alignment */
+    .tooltip-label {
+        font-size: 16px;
+        font-weight: bold;
+        margin-bottom: 8px;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        height: 24px;
+        line-height: 24px;
+        min-height: 32px;
+        display: flex;
+        align-items: flex-end;
+    }
+    
+    .tooltip-icon {
+        position: relative;
+        display: inline-block;
+        cursor: pointer;
+        margin-left: 0;
+    }
+    
+    .tooltip-icon::after {
+        content: attr(data-tooltip);
+        visibility: hidden;
+        width: 250px;
+        background-color: #555;
+        color: #fff;
+        text-align: left;
+        border-radius: 6px;
+        padding: 8px;
+        position: absolute;
+        z-index: 1;
+        bottom: 125%;
+        left: 50%;
+        margin-left: -125px;
+        opacity: 0;
+        transition: opacity 0.3s;
+    }
+    
+    .tooltip-icon:hover::after {
+        visibility: visible;
+        opacity: 1;
+    }
+    
+    /* Streamlit input elements styling - ALL INPUTS */
+    
+    /* Text Input */
+    .stTextInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Text Area */
+    .stTextArea > div > div > textarea {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Number Input */
+    .stNumberInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Select Box */
+    .stSelectbox > div > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Multiselect */
+    .stMultiSelect > div > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Date Input */
+    .stDateInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Time Input */
+    .stTimeInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* File Uploader */
+    .stFileUploader > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* REDUCED HEIGHT FOR UPLOADED FILE DISPLAY */
+    /* Target the uploaded file container */
+    .stFileUploader div[data-testid="stFileUploaderFileName"] {
+        min-height: 30px !important;
+        height: 30px !important;
+        padding: 4px 8px !important;
+        margin: 2px 0 !important;
+        display: flex !important;
+        align-items: center !important;
+        color: #999999 !important;
+        font-size: 12px !important;
+        line-height: 1.2 !important;
+    }
+    
+    /* Reduce height of the file uploader section after upload */
+    .stFileUploader section[data-testid="stFileUploaderDropzone"] {
+        min-height: 40px !important;
+        height: auto !important;
+        padding: 8px !important;
+        margin: 4px 0 !important;
+    }
+    
+    /* Target any uploaded file display elements */
+    .stFileUploader [data-testid="fileUploaderFileName"],
+    .stFileUploader [data-testid="stFileUploaderFileName"] > div,
+    .stFileUploader div[role="button"] {
+        min-height: 30px !important;
+        height: 30px !important;
+        padding: 4px 8px !important;
+        margin: 2px 0 !important;
+        line-height: 1.2 !important;
+        font-size: 12px !important;
+    }
+    
+    /* Compact the entire file uploader when files are uploaded */
+    .stFileUploader:has([data-testid="stFileUploaderFileName"]) {
+        min-height: 40px !important;
+    }
+    
+    .stFileUploader:has([data-testid="stFileUploaderFileName"]) > div {
+        min-height: 40px !important;
+        padding: 4px !important;
+    }
+    
+    /* File Uploader - Uploaded file display text (light grey) */
+    .stFileUploader div[data-testid="stFileUploaderFileName"],
+    .stFileUploader div[data-testid="fileUploaderDropzone"] span,
+    .stFileUploader div[data-testid="fileUploaderDropzone"] p,
+    .stFileUploader section span,
+    .stFileUploader section p,
+    .stFileUploader [data-testid="fileUploaderFileName"],
+    .stFileUploader small {
+        color: #999999 !important; /* Light grey for uploaded file names and text */
+        font-size: 12px !important;
+        line-height: 1.2 !important;
+    }
+    
+    /* File uploader drag and drop area */
+    .stFileUploader section {
+        background-color: #f5f5f5 !important;
+        border: 2px dashed #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* File uploader text content - making it light grey */
+    .stFileUploader section div,
+    .stFileUploader section span,
+    .stFileUploader section small {
+        color: #999999 !important; /* Light grey for all file uploader text */
+        font-size: 12px !important;
+        line-height: 1.2 !important;
+    }
+    
+    /* Color Picker */
+    .stColorPicker > div > div > input {
+        background-color: #f5f5f5 !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Focus states for all inputs */
+    .stTextInput > div > div > input:focus,
+    .stTextArea > div > div > textarea:focus,
+    .stNumberInput > div > div > input:focus,
+    .stDateInput > div > div > input:focus,
+    .stTimeInput > div > div > input:focus {
+        border-color: #667eea !important;
+        box-shadow: 0 0 0 2px rgba(102, 126, 234, 0.2) !important;
+        outline: none !important;
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+    }
+    
+    /* Active/typing states to ensure text stays visible */
+    .stTextInput > div > div > input:active,
+    .stTextArea > div > div > textarea:active,
+    .stNumberInput > div > div > input:active,
+    .stDateInput > div > div > input:active,
+    .stTimeInput > div > div > input:active {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+    }
+    
+    /* Placeholder text for all inputs */
+    .stTextInput > div > div > input::placeholder,
+    .stTextArea > div > div > textarea::placeholder,
+    .stNumberInput > div > div > input::placeholder,
+    .stDateInput > div > div > input::placeholder,
+    .stTimeInput > div > div > input::placeholder {
+        color: #666666 !important;
+        opacity: 0.7 !important;
+    }
+    
+    /* Labels for all input types */
+    .stTextInput > label,
+    .stTextArea > label,
+    .stNumberInput > label,
+    .stSelectbox > label,
+    .stMultiSelect > label,
+    .stDateInput > label,
+    .stTimeInput > label,
+    .stFileUploader > label,
+    .stColorPicker > label {
+        color: #2a2a2a !important;
+        font-weight: 600 !important;
+        margin-bottom: 8px !important;
+    }
+    
+    /* Dropdown options styling */
+    .stSelectbox div[data-baseweb="select"] > div > div,
+    .stMultiSelect div[data-baseweb="select"] > div > div {
+        background-color: #f5f5f5 !important;
+    }
+    
+input,
+textarea,
+select,
+.stSelectbox,
+.stMultiSelect {
+    color: #2a2a2a !important;
+}
+
+</style>
+"""

GS_Sales_Proposal/Client/client_dataclass.py

@@ -0,0 +1,210 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Set, Optional
+import streamlit as st
+
+@dataclass
+class ClientData:
+    """Centralized data structure for client information"""
+    
+    # Basic client information
+    enterprise_name: str = ""
+    website_url: str = ""
+    website_urls_list: List[str] = field(default_factory=list)
+    
+    # Client details and requirements
+    enterprise_details_content: str = ""
+    client_requirements_content: str = ""
+    client_additional_requirements_content: str = ""
+    
+    # SPOC information
+    spoc_name: str = ""
+    spoc_linkedin_profile: str = ""
+    linkedin_profiles: Dict[str, Dict] = field(default_factory=dict)
+    last_searched_spoc: str = ""
+    current_selected_profile_url: Optional[str] = None
+    
+    # File handling
+    uploaded_file_path: Optional[str] = None
+    document_analyzed: bool = False
+    
+    # Pain points and specifications
+    rfi_pain_points_items: Dict[str, str] = field(default_factory=dict)
+    selected_pain_points: Set[str] = field(default_factory=set)
+    pain_point_content_map: Dict[str, str] = field(default_factory=dict)
+    
+    # Additional specifications
+    additional_specs_items: Dict[str, str] = field(default_factory=dict)
+    selected_additional_specs: Set[str] = field(default_factory=set)
+    additional_specs_content_map: Dict[str, str] = field(default_factory=dict)
+    
+    # Role and priority management
+    selected_target_roles: List[str] = field(default_factory=list)
+    selected_business_priorities: List[str] = field(default_factory=list)
+    
+    # UI state management
+    show_validation: bool = False
+    processing_rfi: bool = False
+    scraping_in_progress: bool = False
+    pending_scrape_url: Optional[str] = None
+    css_applied: bool = False
+    last_analyzed_url: Optional[str] = None
+    debug_mode: bool = False
+    
+    def to_dict(self) -> dict:
+        """Convert dataclass to dictionary for session state storage"""
+        return {
+            'enterprise_name': self.enterprise_name,
+            'website_url': self.website_url,
+            'website_urls_list': self.website_urls_list,
+            'enterprise_details_content': self.enterprise_details_content,
+            'client_requirements_content': self.client_requirements_content,
+            'client_additional_requirements_content': self.client_additional_requirements_content,
+            'spoc_name': self.spoc_name,
+            'spoc_linkedin_profile': self.spoc_linkedin_profile,
+            'linkedin_profiles': self.linkedin_profiles,
+            'last_searched_spoc': self.last_searched_spoc,
+            'current_selected_profile_url': self.current_selected_profile_url,
+            'uploaded_file_path': self.uploaded_file_path,
+            'document_analyzed': self.document_analyzed,
+            'rfi_pain_points_items': self.rfi_pain_points_items,
+            'selected_pain_points': self.selected_pain_points,
+            'pain_point_content_map': self.pain_point_content_map,
+            'additional_specs_items': self.additional_specs_items,
+            'selected_additional_specs': self.selected_additional_specs,
+            'additional_specs_content_map': self.additional_specs_content_map,
+            'selected_target_roles': self.selected_target_roles,
+            'selected_business_priorities': self.selected_business_priorities,
+            'show_validation': self.show_validation,
+            'processing_rfi': self.processing_rfi,
+            'scraping_in_progress': self.scraping_in_progress,
+            'pending_scrape_url': self.pending_scrape_url,
+            'css_applied': self.css_applied,
+            'last_analyzed_url': self.last_analyzed_url,
+            'debug_mode': self.debug_mode
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ClientData':
+        """Create ClientData instance from dictionary"""
+        return cls(
+            enterprise_name=data.get('enterprise_name', ''),
+            website_url=data.get('website_url', ''),
+            website_urls_list=data.get('website_urls_list', []),
+            enterprise_details_content=data.get('enterprise_details_content', ''),
+            client_requirements_content=data.get('client_requirements_content', ''),
+            client_additional_requirements_content=data.get('client_additional_requirements_content', ''),
+            spoc_name=data.get('spoc_name', ''),
+            spoc_linkedin_profile=data.get('spoc_linkedin_profile', ''),
+            linkedin_profiles=data.get('linkedin_profiles', {}),
+            last_searched_spoc=data.get('last_searched_spoc', ''),
+            current_selected_profile_url=data.get('current_selected_profile_url'),
+            uploaded_file_path=data.get('uploaded_file_path'),
+            document_analyzed=data.get('document_analyzed', False),
+            rfi_pain_points_items=data.get('rfi_pain_points_items', {}),
+            selected_pain_points=set(data.get('selected_pain_points', [])),
+            pain_point_content_map=data.get('pain_point_content_map', {}),
+            additional_specs_items=data.get('additional_specs_items', {}),
+            selected_additional_specs=set(data.get('selected_additional_specs', [])),
+            additional_specs_content_map=data.get('additional_specs_content_map', {}),
+            selected_target_roles=data.get('selected_target_roles', []),
+            selected_business_priorities=data.get('selected_business_priorities', []),
+            show_validation=data.get('show_validation', False),
+            processing_rfi=data.get('processing_rfi', False),
+            scraping_in_progress=data.get('scraping_in_progress', False),
+            pending_scrape_url=data.get('pending_scrape_url'),
+            css_applied=data.get('css_applied', False),
+            last_analyzed_url=data.get('last_analyzed_url'),
+            debug_mode=data.get('debug_mode', False)
+        )
+    
+    def validate_mandatory_fields(self) -> bool:
+        """Validate mandatory fields"""
+        client_name = self.enterprise_name.strip()
+        client_requirement = self.client_requirements_content.strip()
+        
+        if self.debug_mode:
+            print(f"DEBUG - Client Name: '{client_name}'")
+            print(f"DEBUG - Client Requirement: '{client_requirement}'")
+            print(f"DEBUG - Validation Result: {bool(client_name) and bool(client_requirement)}")
+        
+        return bool(client_name) and bool(client_requirement)
+    
+    def clear_data(self):
+        """Clear all client data"""
+        self.__init__()
+    
+    def update_from_ui_inputs(self, **kwargs):
+        """Update dataclass fields from UI inputs"""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+
+
+class ClientDataManager:
+    """Manager class for handling ClientData persistence in Streamlit session state"""
+    
+    SESSION_KEY = 'client_data'
+    
+    @classmethod
+    def get_client_data(cls) -> ClientData:
+        """Get ClientData from session state or create new instance"""
+        if cls.SESSION_KEY not in st.session_state:
+            st.session_state[cls.SESSION_KEY] = ClientData()
+        return st.session_state[cls.SESSION_KEY]
+    
+    @classmethod
+    def save_client_data(cls, client_data: ClientData):
+        """Save ClientData to session state"""
+        st.session_state[cls.SESSION_KEY] = client_data
+    
+    @classmethod
+    def update_client_data(cls, **kwargs):
+        """Update specific fields in ClientData"""
+        client_data = cls.get_client_data()
+        client_data.update_from_ui_inputs(**kwargs)
+        cls.save_client_data(client_data)
+    
+    @classmethod
+    def clear_client_data(cls):
+        """Clear all client data"""
+        if cls.SESSION_KEY in st.session_state:
+            del st.session_state[cls.SESSION_KEY]
+    
+    @classmethod
+    def export_to_dict(cls) -> dict:
+        """Export client data as dictionary"""
+        client_data = cls.get_client_data()
+        return client_data.to_dict()
+    
+    @classmethod
+    def import_from_dict(cls, data: dict):
+        """Import client data from dictionary"""
+        client_data = ClientData.from_dict(data)
+        cls.save_client_data(client_data)
+
+
+# Utility functions for backwards compatibility
+def validate_client_mandatory_fields() -> bool:
+    """Validate client mandatory fields using dataclass"""
+    client_data = ClientDataManager.get_client_data()
+    return client_data.validate_mandatory_fields()
+
+def get_client_enterprise_name() -> str:
+    """Get client enterprise name"""
+    client_data = ClientDataManager.get_client_data()
+    return client_data.enterprise_name
+
+def set_client_enterprise_name(name: str):
+    """Set client enterprise name"""
+    ClientDataManager.update_client_data(enterprise_name=name)
+
+def get_client_requirements() -> str:
+    """Get client requirements"""
+    client_data = ClientDataManager.get_client_data()
+    return client_data.client_requirements_content
+
+def set_client_requirements(requirements: str):
+    """Set client requirements"""
+    ClientDataManager.update_client_data(client_requirements_content=requirements)
+
+# Add more utility functions as needed...

GS_Sales_Proposal/Client/client_utils.py

@@ -0,0 +1,140 @@
+import streamlit as st
+import pandas as pd
+from typing import List
+import os
+
+from WebsiteUrl_Agent.agent_runner import get_urls
+import asyncio 
+from Document_Upload_Vectordb.pain_points_extractor import *
+# Function to get URLs (placeholder function)
+
+def get_urls_list(company_name) -> List[str]:
+    """
+    Placeholder function that returns a list of URLs
+    Replace this with your actual function that fetches URLs
+    """
+    return asyncio.run(get_urls(company_name))
+
+# Function to get LinkedIn profiles (NEW)
+
+
+# Function to get roles list
+def get_roles_list() -> List[str]:
+    """
+    Function that returns a list of executive roles
+    """
+    return [
+        "CEO (Chief Executive Officer)",
+        "CMO (Chief Marketing Officer)",
+        "CTO (Chief Technology Officer)",
+        "CFO (Chief Financial Officer)",
+        "COO (Chief Operating Officer)",
+        "CHRO (Chief Human Resources Officer)",
+        "CDO (Chief Data Officer)",
+        "CPO (Chief Product Officer)",
+        "CRO (Chief Revenue Officer)",
+        "CIO (Chief Information Officer)"
+    ]
+
+
+from WebScraper.scrape import get_data
+
+def get_url_details(url:str):
+    """Use this if you want to run async function synchronously"""
+    try:
+        # Run the async function synchronously
+        website_details = asyncio.run(get_data(url))
+        return website_details
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+def get_priority_suggestions() -> List[dict]:
+    """
+    Function that returns a list of priority suggestions with titles and descriptions
+    Replace this with your actual function that fetches priority suggestions
+    """
+    return [
+        {
+            "title": "Digital Transformation Initiative",
+            "description": "Modernize systems and processes for improved efficiency",
+            "icon": "🚀"
+        },
+        {
+            "title": "Data Analytics & Business Intelligence",
+            "description": "Implement advanced analytics for better decision making",
+            "icon": "📊"
+        },
+        {
+            "title": "Process Optimization & Automation",
+            "description": "Streamline workflows and reduce manual tasks",
+            "icon": "🔧"
+        }
+    ]
+
+def get_editable_content() -> str:
+    """
+    Placeholder function that returns editable content
+    Replace this with your actual function that fetches editable content
+    """
+    return """This is editable content from the function:
+
+- Project requirements and specifications
+- Current implementation status
+- Key stakeholder feedback
+- Next steps and action items
+- Additional notes and observations
+
+You can modify this content as needed."""
+
+
+# Function to get summary items (NEW)
+# from Rag.rag import get_pain_points
+
+
+
+
+def get_pain_items(file,company_name):
+    print("-----------------------------------------------------------")
+    return get_pain_points(file,company_name)
+
+
+
+
+def check_field_validation(field_name: str, field_value: str, is_mandatory: bool = False) -> bool:
+    """Check if field validation should show warning"""
+    if is_mandatory and not field_value.strip():
+        return True
+    return False
+
+def show_field_warning(field_name: str):
+    """Show warning message for mandatory fields"""
+    st.markdown(f'<div class="field-warning">⚠️ {field_name} is mandatory and cannot be empty!</div>', unsafe_allow_html=True)
+
+
+def save_uploaded_file(uploaded_file, save_dir="uploaded_rf_is"):
+    os.makedirs(save_dir, exist_ok=True)
+    save_path = os.path.join(save_dir, uploaded_file.name)
+
+    with open(save_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+
+    return save_path
+
+def save_uploaded_file_and_get_path(uploaded_file):
+    """Save uploaded file to a temporary directory and return the file path"""
+    if uploaded_file is not None:
+        # Create uploads directory if it doesn't exist
+        upload_dir = "uploads"
+        if not os.path.exists(upload_dir):
+            os.makedirs(upload_dir)
+        
+        # Create file path
+        file_path = os.path.join(upload_dir, uploaded_file.name)
+        
+        # Save the file
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        return file_path
+    return None

GS_Sales_Proposal/Document_Upload_Vectordb/doc_vectorizer.py

@@ -0,0 +1,564 @@
+import os
+import base64
+from io import BytesIO
+import filetype
+from pdf2image import convert_from_path
+from datetime import datetime
+import hashlib
+
+# New imports for PPT and DOC support
+from pptx import Presentation
+from docx import Document
+import docx2txt
+from langchain_community.document_loaders import UnstructuredPowerPointLoader, Docx2txtLoader
+from langchain_community.document_loaders import UnstructuredWordDocumentLoader
+
+from langchain_core.messages import HumanMessage
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_chroma import Chroma
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from .prompts import image_prompt  # Make sure this exists
+
+# --- Utility Functions ---
+
+def get_filename(file_path):
+    return os.path.splitext(os.path.basename(file_path))[0]
+
+def get_file_hash(file_path):
+    """Generate SHA-256 hash of file for duplicate detection"""
+    try:
+        with open(file_path, 'rb') as f:
+            return hashlib.sha256(f.read()).hexdigest()
+    except:
+        return None
+
+def get_file_size(file_path):
+    """Get file size in bytes"""
+    try:
+        return os.path.getsize(file_path)
+    except:
+        return None
+
+def create_base_metadata(file_path, company_name, file_type):
+    """Create base metadata common to all file types"""
+    timestamp = datetime.now().isoformat()
+    
+    metadata = {
+        'company_name': company_name,
+        'file_type': file_type,
+        'filename': os.path.basename(file_path) if isinstance(file_path, str) else 'uploaded_image',
+        'file_path': file_path if isinstance(file_path, str) else None,
+        'processed_timestamp': timestamp,
+        'processing_date': datetime.now().strftime('%Y-%m-%d'),
+        'processing_time': datetime.now().strftime('%H:%M:%S'),
+        'chunk_strategy': 'recursive_character_text_splitter',
+        'embedding_model': 'huggingface_default'
+    }
+    
+    # Add file-specific metadata if it's a file path
+    if isinstance(file_path, str) and os.path.exists(file_path):
+        metadata.update({
+            'file_hash': get_file_hash(file_path),
+            'file_size_bytes': get_file_size(file_path),
+            'file_extension': os.path.splitext(file_path)[1].lower()
+        })
+    
+    return metadata
+
+def file_router(file):
+    """Enhanced file router with PPT and DOC support"""
+    try:
+        # Get file extension first
+        file_extension = os.path.splitext(file)[1].lower()
+        
+        # Handle specific extensions
+        if file_extension in ['.ppt', '.pptx']:
+            return 'powerpoint'
+        elif file_extension in ['.doc', '.docx']:
+            return 'word_document'
+        
+        # Use filetype for other formats
+        kind = filetype.guess(file)
+        if kind is None:
+            return "Unknown"
+
+        file_type = kind.mime
+
+        if file_type.startswith("image/"):
+            return 'imagesingle'
+
+        # Check if it's a PDF with text or images
+        if file_type == 'application/pdf' or file_extension == '.pdf':
+            loader = PyPDFLoader(file)
+            docs = loader.load()
+
+            if not len(docs[0].page_content.strip()):
+                return 'imagepdf'
+            else:
+                return 'pdf'
+                
+        return 'pdf'  # Default fallback
+        
+    except Exception as e:
+        print(f"Error in file_router: {e}")
+        return 'pdf'  # Default fallback
+
+def encode_image(image) -> str:
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+# --- LLM Setup ---
+
+model = ChatGoogleGenerativeAI(model='gemini-2.0-flash')
+
+def image_summarize(model, base64_image: str, prompt: str) -> str:
+    msg = model.invoke([
+        HumanMessage(
+            content=[
+                {"type": "text", "text": prompt},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{base64_image}"},
+                },
+            ]
+        )
+    ])
+    return msg.content
+
+# --- Image Handlers ---
+
+def image_handler(image):
+    base64_img = encode_image(image)
+    summary = image_summarize(model, base64_img, prompt=image_prompt)
+    with open('example.txt', 'w') as f:
+        f.write(summary)
+    return summary
+
+def image_handler_append(image):
+    base64_img = encode_image(image)
+    summary = image_summarize(model, base64_img, prompt=image_prompt)
+    with open('example.txt', 'a') as f:
+        f.write(summary + '\n')
+    return summary
+
+# --- PowerPoint Handler ---
+
+def extract_ppt_content(filepath: str):
+    """Extract text content from PowerPoint files"""
+    try:
+        prs = Presentation(filepath)
+        full_text = []
+        slide_count = 0
+        
+        for slide_num, slide in enumerate(prs.slides, 1):
+            slide_text = f"=== Slide {slide_num} ===\n"
+            
+            for shape in slide.shapes:
+                if hasattr(shape, "text") and shape.text.strip():
+                    slide_text += shape.text + "\n"
+                    
+                # Handle tables in slides
+                if shape.has_table:
+                    table = shape.table
+                    for row in table.rows:
+                        row_text = []
+                        for cell in row.cells:
+                            if cell.text.strip():
+                                row_text.append(cell.text.strip())
+                        if row_text:
+                            slide_text += " | ".join(row_text) + "\n"
+            
+            if slide_text.strip() != f"=== Slide {slide_num} ===":
+                full_text.append(slide_text)
+                slide_count += 1
+        
+        return "\n\n".join(full_text), slide_count
+        
+    except Exception as e:
+        print(f"Error extracting PowerPoint content with python-pptx: {e}")
+        # Fallback to langchain loader
+        try:
+            loader = UnstructuredPowerPointLoader(filepath)
+            docs = loader.load()
+            content = "\n\n".join([doc.page_content for doc in docs])
+            return content, len(docs)
+        except Exception as fallback_error:
+            print(f"Fallback PowerPoint loader failed: {fallback_error}")
+            return f"Error processing PowerPoint file: {str(e)}", 0
+
+# --- Word Document Handler ---
+
+def extract_word_content(filepath: str):
+    """Extract text content from Word documents"""
+    try:
+        file_extension = os.path.splitext(filepath)[1].lower()
+        
+        if file_extension == '.docx':
+            # Use python-docx for .docx files
+            doc = Document(filepath)
+            full_text = []
+            
+            # Extract paragraphs
+            for para in doc.paragraphs:
+                if para.text.strip():
+                    full_text.append(para.text)
+            
+            # Extract tables
+            for table in doc.tables:
+                for row in table.rows:
+                    row_text = []
+                    for cell in row.cells:
+                        if cell.text.strip():
+                            row_text.append(cell.text.strip())
+                    if row_text:
+                        full_text.append(" | ".join(row_text))
+            
+            content = "\n\n".join(full_text)
+            return content, len(doc.paragraphs)
+            
+        elif file_extension == '.doc':
+            # Use python-docx2txt for .doc files
+            content = docx2txt.process(filepath)
+            return content, len(content.split('\n'))
+            
+    except Exception as e:
+        print(f"Error extracting Word content: {e}")
+        # Fallback to langchain loaders
+        try:
+            if filepath.endswith('.docx'):
+                loader = Docx2txtLoader(filepath)
+            else:
+                loader = UnstructuredWordDocumentLoader(filepath)
+            
+            docs = loader.load()
+            content = "\n\n".join([doc.page_content for doc in docs])
+            return content, len(docs)
+            
+        except Exception as fallback_error:
+            print(f"Fallback Word loader failed: {fallback_error}")
+            return f"Error processing Word document: {str(e)}", 0
+
+# --- Enhanced Vectorization Functions ---
+
+def vectorize_text(text: str, company_name: str, filename: str = "text_input", base_metadata: dict = None):
+    """Vectorize text content with metadata"""
+    try:
+        splitter = RecursiveCharacterTextSplitter(chunk_size=600, chunk_overlap=50)
+        docs = splitter.split_text(text)
+        
+        # Create persist directory
+        persist_directory = os.path.join("chroma_store", company_name, filename)
+        os.makedirs(persist_directory, exist_ok=True)
+        
+        # Create collection name (sanitize company name)
+        collection_name = f"{company_name}_{filename}".replace(" ", "_").replace("-", "_").lower()
+        
+        # Create metadata for each chunk
+        metadatas = []
+        for i, chunk in enumerate(docs):
+            chunk_metadata = base_metadata.copy() if base_metadata else {}
+            chunk_metadata.update({
+                'chunk_index': i,
+                'chunk_size': len(chunk),
+                'total_chunks': len(docs),
+                'content_type': 'text',
+                'source_document': filename
+            })
+            metadatas.append(chunk_metadata)
+        
+        vectorstore = Chroma.from_texts(
+            texts=docs,
+            embedding=HuggingFaceEmbeddings(),
+            metadatas=metadatas,
+            persist_directory=persist_directory,
+            collection_name=collection_name
+        )
+        return vectorstore
+        
+    except Exception as e:
+        print(f"Error in vectorize_text: {e}")
+        # Fallback to in-memory store
+        metadatas = [{'error': str(e), 'fallback': True} for _ in docs]
+        vectorstore = Chroma.from_texts(
+            texts=docs,
+            embedding=HuggingFaceEmbeddings(),
+            metadatas=metadatas,
+            collection_name=f"fallback_{collection_name}"
+        )
+        return vectorstore
+
+def vectorize_powerpoint(filepath: str, company_name: str):
+    """Vectorize PowerPoint presentations"""
+    try:
+        content, slide_count = extract_ppt_content(filepath)
+        filename = get_filename(filepath)
+        
+        # Create base metadata
+        base_metadata = create_base_metadata(filepath, company_name, 'powerpoint')
+        base_metadata.update({
+            'total_slides': slide_count,
+            'content_source': 'powerpoint_extraction',
+            'extraction_method': 'python_pptx_with_langchain_fallback',
+            'supports_tables': True,
+            'supports_shapes': True
+        })
+        
+        return vectorize_text(content, company_name, filename, base_metadata)
+        
+    except Exception as e:
+        print(f"Error in vectorize_powerpoint: {e}")
+        error_metadata = {
+            'error': str(e), 
+            'file_type': 'powerpoint',
+            'extraction_failed': True
+        }
+        return vectorize_text("Error processing PowerPoint file", company_name, "error_ppt", error_metadata)
+
+def vectorize_word_document(filepath: str, company_name: str):
+    """Vectorize Word documents"""
+    try:
+        content, paragraph_count = extract_word_content(filepath)
+        filename = get_filename(filepath)
+        
+        # Create base metadata
+        base_metadata = create_base_metadata(filepath, company_name, 'word_document')
+        base_metadata.update({
+            'paragraph_count': paragraph_count,
+            'content_source': 'word_extraction',
+            'extraction_method': 'python_docx_with_langchain_fallback',
+            'supports_tables': True,
+            'supports_formatting': True
+        })
+        
+        return vectorize_text(content, company_name, filename, base_metadata)
+        
+    except Exception as e:
+        print(f"Error in vectorize_word_document: {e}")
+        error_metadata = {
+            'error': str(e), 
+            'file_type': 'word_document',
+            'extraction_failed': True
+        }
+        return vectorize_text("Error processing Word document", company_name, "error_doc", error_metadata)
+
+def vectorize_single_image(image, company_name: str):
+    """Vectorize single images"""
+    try:
+        # Create base metadata for image
+        base_metadata = create_base_metadata(image, company_name, 'single_image')
+        base_metadata.update({
+            'content_source': 'ai_image_summary',
+            'ai_model_used': 'gemini-2.0-flash',
+            'processing_method': 'image_to_text_summary'
+        })
+        
+        summary = image_handler(image)
+        filename = "image_single"
+        return vectorize_text(summary, company_name, filename, base_metadata)
+    except Exception as e:
+        print(f"Error in vectorize_single_image: {e}")
+        error_metadata = {'error': str(e), 'file_type': 'single_image'}
+        return vectorize_text("Error processing image", company_name, "error_image", error_metadata)
+
+def vectorize_multiple_images(image_path: str, company_name: str):
+    """Vectorize PDF with images"""
+    try:
+        images = convert_from_path(image_path)
+        filename = get_filename(image_path)
+        
+        # Create base metadata
+        base_metadata = create_base_metadata(image_path, company_name, 'pdf_images')
+        base_metadata.update({
+            'total_pages': len(images),
+            'content_source': 'ai_image_summary',
+            'ai_model_used': 'gemini-2.0-flash',
+            'processing_method': 'pdf_to_images_to_text',
+            'conversion_tool': 'pdf2image'
+        })
+        
+        summary = ''
+        for i, image in enumerate(images):
+            if i == 0:
+                summary = image_handler(image)
+            else:
+                summary += image_handler_append(image)
+
+        return vectorize_text(summary, company_name, filename, base_metadata)
+    except Exception as e:
+        print(f"Error in vectorize_multiple_images: {e}")
+        error_metadata = {'error': str(e), 'file_type': 'pdf_images'}
+        return vectorize_text("Error processing PDF images", company_name, "error_pdf_images", error_metadata)
+
+def vectorize_docs(filepath: str, company_name: str):
+    """Vectorize PDF documents"""
+    try:
+        loader = PyPDFLoader(filepath)
+        docs = loader.load()
+        splitter = RecursiveCharacterTextSplitter(chunk_size=600, chunk_overlap=80)
+        chunks = splitter.split_documents(docs)
+        filename = get_filename(filepath)
+        
+        # Create base metadata
+        base_metadata = create_base_metadata(filepath, company_name, 'pdf_document')
+        base_metadata.update({
+            'total_pages': len(docs),
+            'total_chunks_created': len(chunks),
+            'chunk_size': 600,
+            'chunk_overlap': 80,
+            'content_source': 'direct_pdf_text',
+            'loader_used': 'PyPDFLoader'
+        })
+        
+        # Create persist directory
+        persist_directory = os.path.join("chroma_store", company_name, filename)
+        os.makedirs(persist_directory, exist_ok=True)
+        
+        # Create collection name (sanitize)
+        collection_name = f"{company_name}_{filename}".replace(" ", "_").replace("-", "_").lower()
+        
+        # Add metadata to each chunk
+        for i, chunk in enumerate(chunks):
+            chunk.metadata.update(base_metadata)
+            chunk.metadata.update({
+                'chunk_index': i,
+                'page_number': chunk.metadata.get('page', 'unknown'),
+                'chunk_char_count': len(chunk.page_content)
+            })
+        
+        vectorstore = Chroma.from_documents(
+            documents=chunks,
+            embedding=HuggingFaceEmbeddings(),
+            persist_directory=persist_directory,
+            collection_name=collection_name
+        )
+        return vectorstore
+        
+    except Exception as e:
+        print(f"Error in vectorize_docs: {e}")
+        # Fallback to in-memory store
+        try:
+            loader = PyPDFLoader(filepath)
+            docs = loader.load()
+            splitter = RecursiveCharacterTextSplitter(chunk_size=600, chunk_overlap=80)
+            chunks = splitter.split_documents(docs)
+            
+            # Add error metadata to fallback
+            error_metadata = {'error': str(e), 'fallback': True, 'file_type': 'pdf_document'}
+            for chunk in chunks:
+                chunk.metadata.update(error_metadata)
+            
+            vectorstore = Chroma.from_documents(
+                documents=chunks,
+                embedding=HuggingFaceEmbeddings(),
+                collection_name=f"fallback_{company_name}_{filename}".replace(" ", "_").lower()
+            )
+            return vectorstore
+        except Exception as fallback_error:
+            print(f"Fallback also failed: {fallback_error}")
+            # Return minimal vectorstore
+            return Chroma.from_texts(
+                texts=["Error loading document"],
+                embedding=HuggingFaceEmbeddings(),
+                metadatas=[{'error': str(fallback_error), 'critical_failure': True}],
+                collection_name="error_fallback"
+            )
+
+# --- Entry Point for Routing ---
+
+def vectorize(filepath: str, company_name: str):
+    """Main vectorization function with enhanced file type support"""
+    try:
+        file_type = file_router(filepath)
+        print(f"Detected file type: {file_type}")
+
+        if file_type == 'imagesingle':
+            return vectorize_single_image(filepath, company_name)
+        elif file_type == 'imagepdf':
+            return vectorize_multiple_images(filepath, company_name)
+        elif file_type == 'powerpoint':
+            return vectorize_powerpoint(filepath, company_name)
+        elif file_type == 'word_document':
+            return vectorize_word_document(filepath, company_name)
+        else:
+            return vectorize_docs(filepath, company_name)
+            
+    except Exception as e:
+        print(f"Error in vectorize main function: {e}")
+        # Ultimate fallback with comprehensive error metadata
+        error_metadata = {
+            'error': str(e),
+            'critical_failure': True,
+            'processed_timestamp': datetime.now().isoformat(),
+            'company_name': company_name,
+            'attempted_file': filepath
+        }
+        return Chroma.from_texts(
+            texts=[f"Error processing file: {str(e)}"],
+            embedding=HuggingFaceEmbeddings(),
+            metadatas=[error_metadata],
+            collection_name="ultimate_fallback"
+        )
+
+# --- Utility Functions for Metadata Queries ---
+
+def search_by_metadata(vectorstore, metadata_filter: dict, query: str = None, k: int = 5):
+    """Search documents using metadata filters"""
+    try:
+        if query:
+            # Similarity search with metadata filter
+            results = vectorstore.similarity_search(
+                query=query, 
+                k=k, 
+                filter=metadata_filter
+            )
+        else:
+            # Get all documents matching metadata filter
+            results = vectorstore.get(where=metadata_filter, limit=k)
+        return results
+    except Exception as e:
+        print(f"Error in metadata search: {e}")
+        return []
+
+def get_document_metadata_summary(vectorstore):
+    """Get a summary of all metadata in the vectorstore"""
+    try:
+        # This would need to be implemented based on your specific Chroma setup
+        # You might need to query the underlying collection directly
+        collection = vectorstore._collection
+        all_data = collection.get()
+        
+        if all_data and 'metadatas' in all_data:
+            return {
+                'total_documents': len(all_data['metadatas']),
+                'unique_companies': set(meta.get('company_name') for meta in all_data['metadatas'] if meta.get('company_name')),
+                'file_types': set(meta.get('file_type') for meta in all_data['metadatas'] if meta.get('file_type')),
+                'processing_dates': set(meta.get('processing_date') for meta in all_data['metadatas'] if meta.get('processing_date'))
+            }
+    except Exception as e:
+        print(f"Error getting metadata summary: {e}")
+        return None
+
+# --- Additional utility functions for specific file types ---
+
+def get_supported_file_types():
+    """Return list of supported file types"""
+    return {
+        'pdf': ['.pdf'],
+        'powerpoint': ['.ppt', '.pptx'],
+        'word_document': ['.doc', '.docx'],
+        'images': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp']
+    }
+
+def validate_file_type(filepath: str):
+    """Validate if file type is supported"""
+    supported_types = get_supported_file_types()
+    file_extension = os.path.splitext(filepath)[1].lower()
+    
+    for file_type, extensions in supported_types.items():
+        if file_extension in extensions:
+            return True, file_type
+    
+    return False, "unsupported"

GS_Sales_Proposal/Document_Upload_Vectordb/doc_xtraction_utils.py

@@ -0,0 +1,14 @@
+def format_docs(docs):
+    return '\n\n'.join(doc.page_content for doc in docs)
+
+def clean_to_list(result:str) :
+    result = result.strip()
+    if result.startswith('```python'):
+        result = result[len('```python'):].strip()
+    elif result.startswith('```json'):
+        result = result[len('```json'):].strip()
+    elif result.startswith('```'):
+        result = result[len('```'):].strip()
+    if result.endswith('```'):
+        result = result[:-3].strip()
+    return result

GS_Sales_Proposal/Document_Upload_Vectordb/pain_points_extractor.py

@@ -0,0 +1,44 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+from dotenv import load_dotenv
+from langchain_core.output_parsers import StrOutputParser
+from langchain.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnableLambda
+load_dotenv()
+import json
+
+llm = ChatGoogleGenerativeAI(model = 'gemini-1.5-flash')
+
+from .prompts import *
+
+from langchain_core.prompts import ChatPromptTemplate
+
+from .doc_vectorizer import vectorize
+
+from .doc_xtraction_utils import *
+
+def get_pain_points(file: str, company_name: str):
+    # Use a different variable name to avoid conflict with imported prompt
+    pain_point_template = ChatPromptTemplate.from_template(rfi_painpoint_prompt)
+    retriever = vectorize(file, company_name).as_retriever()
+
+    # Extract the query string from input and pass to retriever
+    context_chain = (
+        RunnableLambda(lambda x: x["query"])  # Extract just the query string
+        | retriever
+        | RunnableLambda(format_docs)
+    )
+
+    rag_chain = (
+        {"context": context_chain}
+        | pain_point_template  # Use the renamed variable
+        | llm
+        | StrOutputParser()
+    )
+    
+    try:
+        result = rag_chain.invoke({"query": "Extract key business concerns and pain points from this RFI."})
+        print(type(json.loads(clean_to_list(result))))
+        return json.loads(clean_to_list(result))
+    except Exception as e:
+        print(f"Error in get_pain_points: {e}")
+        return []

GS_Sales_Proposal/Document_Upload_Vectordb/prompts.py

@@ -0,0 +1,39 @@
+image_prompt = """You are a highly meticulous AI assistant that extracts and summarizes every possible piece of visual information from an image without omitting any detail.  
+    Your task is to generate an exhaustive, structured summary of the image that captures all the text, visual elements, layout, colors (if relevant), numbers, figures, and any context or formatting that might be useful.  
+    Do not generalize or paraphrase — capture the content exactly as it appears. Use bullet points, lists, or structured sections (e.g., titles, tables, headers, footnotes) to organize your summary.  
+
+    Be especially attentive to:
+    - All visible text, including headers, footnotes, and marginal notes  
+    - Tables: Capture each row and column verbatim including headers and cell values  
+    - Graphs/Charts: Explain all axes, labels, legends, data points, patterns, and conclusions  
+    - Visual layout and structure: Describe how content is arranged (e.g., two-column layout, centered title, left-aligned figure)  
+    - Icons, logos, or images embedded within the image: Describe them accurately  
+    - Fonts, colors, and emphasis (e.g., bold, italic, underlined) if they seem meaningful  
+    - Dates, numbers, symbols, or special formatting exactly as shown  
+    - If the image is a document or scanned page, preserve hierarchy and document structure  
+
+    Output the result in structured markdown with clear section headers (e.g., "Header", "Table 1", "Figure Description", "Text Body", "Footnotes").  
+    Your goal is to allow someone to fully understand the image without seeing it, preserving maximum detail for use in downstream AI models or search systems."""
+
+
+
+
+rfi_painpoint_prompt = """
+You are a highly capable business analyst AI with deep expertise in sales, technology, and market research. Your task is to analyze an RFI (Request for Information) document from a client who is seeking digital or technology solutions.
+
+From this document, extract and synthesize **three key insights or business pain points** that the client organization is implicitly or explicitly concerned about. Each pain point should be labeled under a relevant category, followed by a brief, insightful summary.
+
+Here is the context of the sales proposal:
+{context}
+
+Respond with **only** a valid JSON dictionary using the following format:
+
+{{
+    "Category 1": "Insightful and concise pain point summary.",
+    "Category 2": "Another brief and relevant pain point summary.",
+    "Category 3": "A third valuable insight from the RFI."
+}}
+
+❌ Do **not** add any explanation, text before or after the dictionary, markdown, comments, or labels.  
+✅ Return **only** the raw JSON dictionary — nothing else.
+"""

GS_Sales_Proposal/Document_Upload_Vectordb/rfi2.pdf

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

GS_Sales_Proposal/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Amrutha-git-hub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

GS_Sales_Proposal/Recommendation/prompts.py

@@ -0,0 +1,107 @@
+ai_suggetion_for_additional_req_prompt = '''You are a B2B Sales manager and innovation strategist.
+
+Your role is to review and enrich client requirements based on the following inputs:
+
+**Enterprise Details**:
+{enterprise_details}
+
+**Current Client Requirements**:
+{client_requirements}
+
+Your tasks:
+
+1. Based on the selected client_requirements suggest any additional points to be included in terms of in terms of payment , time , budget etc 
+
+Respond in this format:
+
+---
+### ✅ Refined Client Requirements
+[Improved version of the client requirements]
+
+---
+
+### 💡 Innovative Suggestions
+- [Idea 1 with rationale]
+- [Idea 2 with rationale]
+
+---
+
+### 📌 Best Practice Recommendations
+- [What’s missing or could be enhanced]
+- [Formatting, phrasing, or process suggestions]
+
+---
+
+Ensure your language is professional, client-facing, and strategic.
+'''
+# ai_suggetion_for_additional_req_prompt = '''You are a senior solution consultant and innovation strategist.
+
+# Your role is to review and enrich client requirements based on the following inputs:
+
+# **Enterprise Details**:
+# {enterprise_details}
+
+# **Current Client Requirements**:
+# {client_requirements}
+
+# Your tasks:
+
+# 1. **Assess Alignment**: 
+#    - Evaluate if the client requirements are aligned with the enterprise’s offerings and capabilities.
+#    - Identify gaps, redundancies, or missing technical/business aspects.
+
+# 2. **Recommend Improvements**:
+#    - Rewrite the client requirements for better clarity, completeness, and strategic fit.
+#    - Ensure inclusion of key components such as scope, deliverables, timelines, and measurable outcomes.
+
+# 3. **Suggest Innovations**:
+#    - Propose at least **2 innovative or differentiating additions** that could delight the client or increase project value.
+#    - These could be technology enhancements, automation opportunities, personalization, integrations, or unique service models.
+
+# 4. **Highlight Best Practices**:
+#    - Mention if anything is outdated, vague, or can be made more professional or efficient.
+#    - Share **best practices** relevant to the industry or solution area.
+
+# Respond in this format:
+
+# ---
+# ### ✅ Refined Client Requirements
+# [Improved version of the client requirements]
+
+# ---
+
+# ### 💡 Innovative Suggestions
+# - [Idea 1 with rationale]
+# - [Idea 2 with rationale]
+
+# ---
+
+# ### 📌 Best Practice Recommendations
+# - [What’s missing or could be enhanced]
+# - [Formatting, phrasing, or process suggestions]
+
+# ---
+
+# Ensure your language is professional, client-facing, and strategic.
+# '''
+
+business_priotiiry_recommendation_prompt = '''You are a B2B business strategy expert.
+
+Your task is to identify the top 3 current business priorities for a client stakeholder based on their role.
+
+**Client SPOC Role**: {client_spoc_role}
+
+Guidelines:
+- Focus on strategic goals and KPIs relevant to that role.
+- Consider current trends and business environments (e.g., digital transformation, efficiency, AI adoption, cost control).
+- Keep the priorities concise, professional, and relevant to decision-making.
+
+Respond in the following format:
+
+[
+    {{"title": "Strategic Growth and Vision", "icon": "📈"}},
+    {{"title": "Operational Efficiency", "icon": "⚙️"}},
+    {{"title": "Customer Experience", "icon": "💡"}}
+]
+
+'''

GS_Sales_Proposal/Recommendation/recommendation_utils.py

@@ -0,0 +1,26 @@
+from langchain_core.prompts import ChatPromptTemplate
+from .prompts import *
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.output_parsers import JsonOutputParser,StrOutputParser
+from dotenv import load_dotenv
+from Document_Upload_Vectordb.doc_xtraction_utils import clean_to_list
+load_dotenv()
+import json
+
+llm = ChatGoogleGenerativeAI(model = 'gemini-1.5-flash')
+
+
+
+
+def get_ai_client_requirements(enterprise_details,client_requirements):
+    template = ChatPromptTemplate.from_template(ai_suggetion_for_additional_req_prompt)
+    chain = template | llm | StrOutputParser()
+    result = chain.invoke({'enterprise_details':enterprise_details,'client_requirements':client_requirements})
+    return result
+
+def get_ai_business_priorities(spoc_role="CEO"):
+    template = ChatPromptTemplate.from_template(business_priotiiry_recommendation_prompt)
+    chain = template | llm | JsonOutputParser()
+    result = chain.invoke({'client_spoc_role':spoc_role})
+    print(result)
+    return result

GS_Sales_Proposal/Search/Linkedin/linkedin_agent_runner_unused.py

@@ -0,0 +1,66 @@
+from google.adk.agents import Agent
+from google.adk.tools import google_search
+from pydantic import BaseModel,Field
+from dotenv import load_dotenv
+from google.adk.sessions import InMemorySessionService
+from google.adk.runners import Runner
+from google.genai import types
+import ast 
+import re
+from Search.LinkedIN.linkedin_agent_unused import *
+
+
+# Setup session and runner
+session_service = InMemorySessionService()
+SESSION_ID = 'sess'
+USER_ID = 'user'
+
+session = session_service.create_session(
+    app_name="APP",
+    user_id=USER_ID,
+    session_id=SESSION_ID
+)
+
+runner = Runner(
+    app_name="APP",
+    session_service=session_service,
+    agent=search_agent
+)
+def extract_list_from_string(s):
+    # Remove any prefix like 'json' and extract the JSON array part
+    match = re.search(r"\[.*\]", s, re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group())
+        except json.JSONDecodeError:
+            print("Failed to parse list.")
+    else:
+        print("No list found.")
+    return None
+
+
+import json
+async def get_linkedin(user_name: str, runner=runner, user_id=USER_ID, session_id=SESSION_ID):
+    content = types.Content(role='user', parts=[types.Part(text=user_name)])
+    final_msg = ""
+    
+    async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=content):
+        if event.is_final_response():
+            if event.content and event.content.parts:
+                final_msg = event.content.parts[0].text
+            elif event.actions and event.actions.escalate:
+                final_msg = event.error_message
+    result = final_msg
+    result = result.strip()
+    if result.startswith('```python'):
+        result = result[len('```python'):].strip()
+    elif result.startswith('```json'):
+        result = result[len('```json'):].strip()
+    elif result.startswith('```'):
+        result = result[len('```'):].strip()
+    if result.endswith('```'):
+        result = result[:-3].strip()
+    final_msg = result
+    print(final_msg)
+    return json.loads(final_msg)
+

GS_Sales_Proposal/Search/Linkedin/linkedin_agent_unused.py

@@ -0,0 +1,63 @@
+from google.adk.agents import Agent
+from google.adk.tools import google_search
+from pydantic import BaseModel,Field
+from dotenv import load_dotenv
+from google.adk.sessions import InMemorySessionService
+from google.adk.runners import Runner
+from google.genai import types
+import ast 
+import re
+
+
+load_dotenv()
+class WebSite(BaseModel):
+    website_name : str = Field(description="Website name")
+    website_url : str = Field(description="Website url")
+
+
+search_agent = Agent(
+    model='gemini-2.0-flash-001',
+    name='linkedin_profile_agent',
+    description=(
+        "You are an intelligent assistant that finds the most accurate and official LinkedIn profiles "
+        "of people and analyzes their current job roles to generate sales insights."
+    ),
+    instruction='''
+Given the name of a person, your task is to find and return **exactly 5 people** for whom:
+
+- A valid and official **LinkedIn profile URL** (`linkedin.com/in/...`) can be found.
+- The **current job title/role** is either extracted from search preview or inferred based on their LinkedIn snippet.
+- You can intelligently infer the **top 3 job priorities** relevant to a sales proposal (i.e., what matters to this person in a B2B sale).
+
+⚠️ STRICT RULES:
+- DO NOT return any result without a valid LinkedIn URL.
+- DO NOT invent or guess URLs — only use actual `linkedin.com/in/...` links found via search.
+- Use `site:linkedin.com/in "Full Name"` on Google to identify results.
+- Skip people for whom no real LinkedIn result is found.
+- Return fewer than 5 results if necessary, but never include fake or placeholder data.
+
+📌 Response format MUST be a Python-style list of JSON objects like this:
+
+[
+  {
+    "name": "Shreyank Isiri",
+    "linkedin_url": "https://www.linkedin.com/in/shreyankisiri/",
+    "role": "Solutions Architect at XYZ Corp",
+    "top_3_priorities": [
+      "Understanding client infrastructure needs",
+      "Designing scalable and secure systems",
+      "Supporting sales through technical expertise"
+    ]
+  },
+  ...
+]
+
+IMPORTANT:
+- Use temperature = 0
+- DO NOT include explanations or markdown. Just return the list.
+- Always ensure the LinkedIn URL is real and not hallucinated.
+''',
+    tools=[google_search],
+)
+
+

GS_Sales_Proposal/Search/Linkedin/linkedin_serp.py

@@ -0,0 +1,40 @@
+
+import requests
+from dotenv import load_dotenv
+load_dotenv()
+import os
+import streamlit as st
+
+def infer_priorities(title):
+    # Placeholder function: replace with your actual priority inference logic
+    return [" Scalability & Risk Mitigation","Operational Efficiency","Scalability & Risk Mitigation"]
+
+def search_linkedin_serpapi(name):
+    params = {
+        "q": f'site:linkedin.com/in "{name}"',
+        "api_key": os.getenv("SERP_API_KEY"),
+        "engine": "google",
+        "num": 5
+    }
+    
+    try:
+        response = requests.get("https://serpapi.com/search", params=params).json()
+        results = {}
+        
+        for res in response.get("organic_results", []):
+            link = res.get("link", "")
+            title = res.get("title", "")
+            if "linkedin.com/in" in link:
+                results[link] = {
+                    "name": name,
+                    "role": title,
+                    "top_3_priorities": infer_priorities(title)
+                }
+            if len(results) == 5:
+                break
+        
+        print(results)
+        return results
+    except Exception as e:
+        st.error(f"Error searching LinkedIn profiles: {e}")
+        return {}

GS_Sales_Proposal/Search/WebsiteUrl_Agent/agent.py

@@ -0,0 +1,67 @@
+from google.adk.agents import Agent
+from google.adk.tools import google_search
+from pydantic import BaseModel,Field
+from dotenv import load_dotenv
+from google.adk.sessions import InMemorySessionService
+from google.adk.runners import Runner
+from google.genai import types
+import ast 
+import re
+
+
+load_dotenv()
+class WebSite(BaseModel):
+    website_name : str = Field(description="Website name")
+    website_url : str = Field(description="Website url")
+
+
+search_agent = Agent(
+    model='gemini-2.0-flash-001',
+    name='url_agent',
+    description = (
+    "You are an intelligent assistant specialized in finding official and relevant websites "
+    "associated with a given organization or company name. Your goal is to retrieve high-quality, "
+    "credible links that accurately represent the digital presence of the organization."
+),
+   instruction = '''
+    Given the name of a company or organization, your task is to search and return the top 7 most relevant and credible website URLs associated with it.
+
+    These can include:
+    - The official company website try fetching this and if there are multiple then show all 7
+
+
+    Your response must be a clean Python-style list of strings, where each string is a valid URL.
+
+    Format your response exactly like this:
+
+    [
+    "https://google.com/",
+    "https://cloud.google.com",
+    "https://accounts.google.com"
+    ]
+
+    Like this any 10 urls that are related to the given organization name
+
+    Do not include explanations, only return the list of URLs.
+
+    IMPORTANT : Just return me list of urls no additional text
+
+    return like 
+   
+    
+    ----
+        [
+    "https://google.com/",
+    "https://cloud.google.com",
+    "https://accounts.google.com"
+    ]
+
+    ----
+
+    VERY IMPORTANT : TEMPERATURE OF THE MODEL BE ZEROOOO AND remember dont give me like the links of youtube or linkedin or any other platforms
+    THE LINK SHOULD BE OFFICIAL LINK OF THE ORGANIZATION
+    ''',
+
+    tools = [google_search],
+)
+

GS_Sales_Proposal/Search/WebsiteUrl_Agent/agent_runner.py

@@ -0,0 +1,68 @@
+from google.adk.agents import Agent
+from google.adk.tools import google_search
+from pydantic import BaseModel,Field
+from dotenv import load_dotenv
+from google.adk.sessions import InMemorySessionService
+from google.adk.runners import Runner
+from google.genai import types
+import ast 
+import re
+from WebsiteUrl_Agent.agent import *
+
+
+# Setup session and runner
+session_service = InMemorySessionService()
+SESSION_ID = 'sess'
+USER_ID = 'user'
+
+session = session_service.create_session(
+    app_name="APP",
+    user_id=USER_ID,
+    session_id=SESSION_ID
+)
+
+runner = Runner(
+    app_name="APP",
+    session_service=session_service,
+    agent=search_agent
+)
+def extract_list_from_string(s):
+    # Remove any prefix like 'json' and extract the JSON array part
+    match = re.search(r"\[.*\]", s, re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group())
+        except json.JSONDecodeError:
+            print("Failed to parse list.")
+    else:
+        print("No list found.")
+    return None
+
+
+import json
+async def get_urls(company_name: str, runner=runner, user_id=USER_ID, session_id=SESSION_ID):
+    content = types.Content(role='user', parts=[types.Part(text=company_name)])
+    final_msg = ""
+    
+    async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=content):
+        if event.is_final_response():
+            if event.content and event.content.parts:
+                final_msg = event.content.parts[0].text
+            elif event.actions and event.actions.escalate:
+                final_msg = event.error_message
+    result = final_msg
+    result = result.strip()
+    if result.startswith('```python'):
+        result = result[len('```python'):].strip()
+    elif result.startswith('```json'):
+        result = result[len('```json'):].strip()
+    elif result.startswith('```'):
+        result = result[len('```'):].strip()
+    if result.endswith('```'):
+        result = result[:-3].strip()
+    final_msg = result
+    print(final_msg)
+    return json.loads(final_msg)
+
+import asyncio
+asyncio.run(get_urls("growth sutra"))

GS_Sales_Proposal/Seller/seller.py

@@ -0,0 +1,463 @@
+import streamlit as st
+from .seller_css import seller_css
+from .seller_utils import *
+from Search.Linkedin.linkedin_serp import *
+from Recommendation.recommendation_utils import *
+from t import *
+
+def seller_tab():
+    # Re-apply CSS after every rerun to ensure persistence
+    st.markdown(seller_css, unsafe_allow_html=True)
+    
+    # Initialize validation trigger
+    if 'show_validation' not in st.session_state:
+        st.session_state.show_validation = False
+    
+    # Initialize enterprise details content in session state
+    if 'seller_enterprise_details_content' not in st.session_state:
+        st.session_state.seller_enterprise_details_content = ""
+    
+    # Initialize seller requirements content in session state
+    if 'seller_requirements_content' not in st.session_state:
+        st.session_state.seller_requirements_content = ""
+    
+    # Initialize URLs list in session state
+    if 'seller_website_urls_list' not in st.session_state:
+        st.session_state['seller_website_urls_list'] = []
+    
+    # Initialize last company name to track changes
+    if 'last_seller_company_name' not in st.session_state:
+        st.session_state['last_seller_company_name'] = ""
+    
+    # Initialize uploaded file path in session state
+    if 'seller_uploaded_file_path' not in st.session_state:
+        st.session_state['seller_uploaded_file_path'] = None
+    
+    # Initialize RFI pain points items in session state
+    if 'seller_rfi_pain_points_items' not in st.session_state:
+        st.session_state['seller_rfi_pain_points_items'] = {}
+    
+    # Initialize document analysis status
+    if 'seller_document_analyzed' not in st.session_state:
+        st.session_state['seller_document_analyzed'] = False
+    
+    if 'seller_linkedin_profiles' not in st.session_state:
+        st.session_state['seller_linkedin_profiles'] = {}
+    if 'last_searched_seller_spoc' not in st.session_state:
+        st.session_state['last_searched_seller_spoc'] = ""
+    
+    # Initialize scraping states
+    if 'seller_scraping_in_progress' not in st.session_state:
+        st.session_state['seller_scraping_in_progress'] = False
+    if 'seller_pending_scrape_url' not in st.session_state:
+        st.session_state['seller_pending_scrape_url'] = None
+
+    # Top section with seller name and URLs
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.markdown("""
+            <div class="tooltip-label">
+                Seller Enterprise Name <span style="color:red;">*</span>
+                <div class="tooltip-icon" data-tooltip="Enter the full legal name of the seller organization. This is the primary identifier for the seller in all documentation and communications. This field is mandatory for creating the seller profile.">ⓘ</div>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Create a sub-column layout for name input and find URLs button
+        name_col, button_col = st.columns([3, 1])
+        
+        with name_col:
+            seller_enterprise_name = st.text_input(
+                label="Seller Enterprise Name", 
+                placeholder="Enter seller enterprise name...", 
+                key="seller_enterprise_name_input",
+                label_visibility="collapsed"
+            )
+        
+        with button_col:
+            # Find URLs button - only enabled when seller name has more than 2 characters
+            find_urls_disabled = not (seller_enterprise_name and len(seller_enterprise_name.strip()) > 2)
+            
+            if st.button("🔍 Find Website",
+                        disabled=find_urls_disabled,
+                        help="Find website URLs for this company",
+                        key="find_seller_urls_button"):
+                # Add spinner while fetching URLs
+                with st.spinner(f"Finding Websites for '{seller_enterprise_name.strip()}'..."):
+                    try:
+                        st.session_state['seller_website_urls_list'] = get_urls_list(seller_enterprise_name.strip())
+                        st.session_state['last_seller_company_name'] = seller_enterprise_name
+                    except Exception as e:
+                        st.session_state['seller_website_urls_list'] = []
+                        st.error(f"Error finding URLs: {str(e)}")
+        
+        # Clear URLs if company name is cleared
+        if not seller_enterprise_name and st.session_state['last_seller_company_name']:
+            st.session_state['seller_website_urls_list'] = []
+            st.session_state['last_seller_company_name'] = ""
+        
+        # Show validation warning if triggered and field is empty
+        if st.session_state.show_validation and check_field_validation("Seller Enterprise Name", seller_enterprise_name, True):
+            show_field_warning("Seller Enterprise Name")
+    
+    with col2:
+        # Label row with inline emoji and tooltip
+        st.markdown('''
+        <div class="tooltip-label" style="display: flex; align-items: center; gap: 8px;">
+            <span>Seller Website URL</span>
+            <div class="tooltip-icon" data-tooltip="Enter or select the seller's official website URL. The system will automatically analyze the website to extract company information, services, and business details to help understand the seller's capabilities and offerings.">ⓘ</div>
+        </div>
+        ''', unsafe_allow_html=True)
+        
+        # Create columns for dropdown and buttons - dropdown takes most space, buttons share remaining space
+        url_col, btn1_col, btn2_col, btn3_col = st.columns([7, 1, 1, 1])
+        
+        with url_col:
+            # URL selection logic - Always show normal dropdown, just disable when no seller name
+            seller_name_provided = bool(seller_enterprise_name and seller_enterprise_name.strip())
+            
+            if not st.session_state.get('seller_website_urls_list'):
+                # No URLs available - show default option
+                url_options = ["Select seller website URL"]
+            else:
+                # URLs available - show them in dropdown
+                url_options = ["Select seller website URL"] + st.session_state['seller_website_urls_list']
+            
+            seller_website_url = st.selectbox(
+                label="Seller Website URL",
+                options=url_options,
+                key="seller_website_url_selector",
+                label_visibility="collapsed",
+                disabled=not seller_name_provided,
+                accept_new_options=True
+            )
+            
+            # Reset to empty string if default option is selected
+            if seller_website_url == "Select seller website URL":
+                seller_website_url = ""
+        
+        # Each button in its own column for horizontal alignment
+        with btn1_col:
+            if seller_website_url:
+                st.link_button("🌐", seller_website_url, help="Visit website",use_container_width=True)
+            else:
+                st.button("🌐", help="Visit website", disabled=True,use_container_width=True)
+        with btn2_col:
+            # Button 2: Refresh URL List
+            refresh_clicked = st.button("🔄", help="Refresh website URLs list", key="refresh_seller_urls_btn",use_container_width=True,disabled=not seller_website_url)
+        
+        with btn3_col:
+            # Button 3: Scrape Website - Set up pending scrape instead of immediate execution
+            scrape_clicked = st.button("📑", help="Get enterprise details", key="scrape_seller_website_btn",use_container_width=True, disabled=not seller_website_url)
+            
+            # Handle scrape button click by setting up pending operation
+            if scrape_clicked and seller_website_url:
+                st.session_state['seller_pending_scrape_url'] = seller_website_url
+                st.session_state['seller_scraping_in_progress'] = True
+                st.rerun()
+
+        # Handle refresh action outside columns for better UX
+        if refresh_clicked and seller_name_provided:
+            try:
+                with st.spinner("Refreshing website URLs..."):
+                    st.session_state['seller_website_urls_list'] = get_urls_list(seller_enterprise_name)
+                    st.success("Website URLs refreshed!")
+                    st.rerun()  # Refresh the page to show updated URLs
+            except Exception as e:
+                st.error(f"Error refreshing URLs: {str(e)}")
+
+        # Handle pending scraping operation OUTSIDE of columns to prevent UI blocking
+        if st.session_state.get('seller_scraping_in_progress') and st.session_state.get('seller_pending_scrape_url'):
+            # Show full-width spinner
+            with st.spinner(f"Scraping website details from {st.session_state['seller_pending_scrape_url']}..."):
+                try:
+                    # Perform the scraping operation
+                    website_details = get_url_details(st.session_state['seller_pending_scrape_url'])
+                    st.session_state.seller_enterprise_details_content = website_details
+                    st.session_state['last_analyzed_seller_url'] = st.session_state['seller_pending_scrape_url']
+                    
+                    # Clear pending operation
+                    st.session_state['seller_scraping_in_progress'] = False
+                    st.session_state['seller_pending_scrape_url'] = None
+                    
+                    st.success("Website details extracted successfully!")
+                    st.rerun()  # Refresh to show updated details
+                    
+                except Exception as e:
+                    # Clear pending operation on error
+                    st.session_state['seller_scraping_in_progress'] = False
+                    st.session_state['seller_pending_scrape_url'] = None
+                    st.error(f"Error scraping website: {str(e)}")
+
+    # Show validation warning if triggered and field is empty (optional)
+    if st.session_state.show_validation and check_field_validation("Seller Website URL", seller_website_url, False):
+        show_field_warning("Seller Website URL")
+
+
+#-------------------------------------------------------------------------------
+
+    st.markdown('''
+    <div class="tooltip-label">
+        Upload Seller Document
+        <div class="tooltip-icon" data-tooltip="Upload seller-related documents such as company profiles, service catalogs, capabilities documents, or proposals in PDF, DOCX, TXT, or CSV format. The system will automatically analyze and extract key capabilities, services, and business strengths to help understand the seller's offerings.">ⓘ</div>
+    </div>
+    ''', unsafe_allow_html=True)
+    
+    # Add custom CSS for file uploader and animations
+    st.markdown("""
+    <style>
+    .stFileUploader > div > div > div {
+        padding: 0.5rem !important;
+        min-height: 2rem !important;
+    }
+    .stFileUploader > div > div {
+        min-height: 2rem !important;
+    }
+    [data-testid="stFileUploader"] {
+        height: auto !important;
+    }
+    [data-testid="stFileUploader"] > div {
+        padding: 0.25rem 0.5rem !important;
+        min-height: 2rem !important;
+    }
+    
+    /* Animation for processing file */
+    .processing-file {
+        animation: pulse 1.5s ease-in-out infinite;
+        background: linear-gradient(90deg, #e3f2fd, #bbdefb, #e3f2fd);
+        background-size: 200% 100%;
+        animation: shimmer 2s linear infinite;
+        border-radius: 4px;
+        padding: 2px 4px;
+    }
+    
+    @keyframes pulse {
+        0% { opacity: 0.6; }
+        50% { opacity: 1; }
+        100% { opacity: 0.6; }
+    }
+    
+    @keyframes shimmer {
+        0% { background-position: -200% 0; }
+        100% { background-position: 200% 0; }
+    }
+    
+    .analyzing-text {
+        color: #1976d2;
+        font-weight: 500;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    # FILE UPLOAD - Always enabled, independent of seller name (multiple files)
+    seller_documents_upload = st.file_uploader(
+        label="Upload Seller Documents", 
+        type=['pdf', 'docx', 'txt', 'csv','png','jpg','jpeg'], 
+        key="seller_documents_uploader",
+        label_visibility="collapsed",
+        accept_multiple_files=True
+    )
+    
+    # Initialize processing states and file tracking
+    if 'processing_all_seller_documents' not in st.session_state:
+        st.session_state['processing_all_seller_documents'] = False
+    if 'seller_uploaded_files_paths' not in st.session_state:
+        st.session_state['seller_uploaded_files_paths'] = {}
+    if 'seller_services_by_file' not in st.session_state:
+        st.session_state['seller_services_by_file'] = {}
+    
+    # Show file info and single analyze button for all files
+    if seller_documents_upload is not None and len(seller_documents_upload) > 0:
+        st.markdown("**Uploaded Documents:**")
+        
+        # Display all uploaded files
+        for idx, uploaded_file in enumerate(seller_documents_upload):
+            file_key = f"{uploaded_file.name}_{uploaded_file.size}"  # Unique key for each file
+            
+            # Very compact single line display
+            file_size_kb = round(uploaded_file.size / 1024, 1)
+            file_size_display = f"{file_size_kb}KB" if file_size_kb < 1024 else f"{round(file_size_kb/1024, 1)}MB"
+            
+            # Check if this file has been processed
+            is_processed = file_key in st.session_state.get('seller_services_by_file', {})
+            is_processing = st.session_state.get('processing_all_seller_documents', False)
+            
+            if is_processing:
+                # Show animated processing state
+                st.markdown(f"""
+                <div class="processing-file">
+                    <span style='font-size:0.8em' class="analyzing-text">
+                        🔄 {uploaded_file.name[:25]}{'...' if len(uploaded_file.name) > 25 else ''} (Analyzing...)
+                    </span>
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                # Show normal file info with status
+                status_icon = "✅" if is_processed else "📄"
+                st.markdown(f"<span style='font-size:0.8em'>{status_icon} {uploaded_file.name[:30]}{'...' if len(uploaded_file.name) > 30 else ''} ({file_size_display})</span>", 
+                        unsafe_allow_html=True)
+        
+        # Single button to process all files
+        st.markdown("---")  # Separator line
+        
+        # Check if all files are already processed
+        all_processed = all(
+            f"{file.name}_{file.size}" in st.session_state.get('seller_services_by_file', {})
+            for file in seller_documents_upload
+        )
+        
+        is_processing = st.session_state.get('processing_all_seller_documents', False)
+        
+        # Button styling
+        if all_processed:
+            button_color = "#28a745"  # Green for all processed
+            button_text = "All Documents Processed"
+            button_disabled = True
+        elif is_processing:
+            button_color = "#FF6B6B"  # Red for processing
+            button_text = "Analyzing All Documents..."
+            button_disabled = True
+        else:
+            button_color = "#4CAF50"  # Blue for ready to process
+            button_text = f"Get Services from All Documents ({len(seller_documents_upload)} files)"
+            button_disabled = False
+
+        st.markdown(f"""
+        <style>
+        div.stButton > button:first-child {{
+            background-color: {button_color};
+            color: white;
+            border: none;
+            font-weight: bold;
+        }}
+        </style>
+        """, unsafe_allow_html=True)
+
+        # Single analyze button for all files
+        analyze_all_clicked = st.button(
+            button_text,
+            key="analyze_all_seller_documents_btn",
+            help="Process all seller documents" if not button_disabled else "All documents processed" if all_processed else "Processing in progress...",
+            type="secondary",
+            disabled=button_disabled,
+            use_container_width=True
+        )
+        
+        # Handle analyze button click for all files
+        if analyze_all_clicked and not button_disabled:
+            if not seller_enterprise_name:
+                st.error("❌ Please enter the Seller Enterprise Name first")
+            else:
+                # Set processing flag for all files
+                st.session_state['processing_all_seller_documents'] = True
+                st.rerun()  # Refresh to show processing state
+        
+        # Handle processing for all files when button is clicked
+        if st.session_state.get('processing_all_seller_documents', False):
+            # Show overall processing indicator
+            with st.container():
+                st.markdown("**🔍 Processing all documents and extracting services...**")
+                
+                # Process each file
+                all_services = {}
+                processed_count = 0
+                total_files = len(seller_documents_upload)
+                
+                for idx, uploaded_file in enumerate(seller_documents_upload):
+                    file_key = f"{uploaded_file.name}_{uploaded_file.size}"
+                    
+                    # Show progress for current file
+                    progress_text = f"Processing {uploaded_file.name} ({idx + 1}/{total_files})..."
+                    with st.spinner(progress_text):
+                        try:
+                            # Save the file and get the path
+                            file_path = save_uploaded_file_and_get_path(uploaded_file)
+                            st.session_state['seller_uploaded_files_paths'][file_key] = file_path
+                            
+                            if file_path and seller_enterprise_name:
+                                # Extract services using the file path and company name
+                                file_services = get_seller_services(file_path, seller_enterprise_name)
+                                
+                                # Store services data for this specific file
+                                st.session_state['seller_services_by_file'][file_key] = {
+                                    'filename': uploaded_file.name,
+                                    'services': file_services,
+                                    'file_path': file_path
+                                }
+                                
+                                # Combine services from this file
+                                if isinstance(file_services, dict):
+                                    all_services.update(file_services)
+                                
+                                processed_count += 1
+                                st.success(f"✅ {uploaded_file.name} processed successfully!")
+                                
+                            else:
+                                st.error(f"❌ Error saving {uploaded_file.name}")
+                                
+                        except Exception as e:
+                            st.error(f"❌ Error processing {uploaded_file.name}: {str(e)}")
+                
+                # Update combined services and reset processing flag
+                st.session_state['seller_services_items'] = all_services
+                st.session_state['seller_document_analyzed'] = True if processed_count > 0 else False
+                st.session_state['processing_all_seller_documents'] = False
+                
+                # Show final summary
+                if processed_count == total_files:
+                    st.success(f"🎉 All {total_files} documents processed successfully!")
+                elif processed_count > 0:
+                    st.warning(f"⚠️ {processed_count} out of {total_files} documents processed successfully.")
+                else:
+                    st.error("❌ No documents could be processed.")
+                
+                st.rerun()  # Refresh to update UI
+    
+    # Function call for Seller Services Offered selection
+    seller_enterprise_details, seller_enterprise_details_provided = render_three_column_selector_unified(
+        # Column configuration - Made wider to fill screen
+        column_ratio=(2, 2, 2),  # Equal wider columns
+        column_gap="large",  # Increased gap for better spacing
+        
+        # Left column (text area) configuration
+        left_title="Seller Enterprise Details",
+        left_tooltip="Define your enterprise details, services offered, company capabilities, core competencies, and business portfolio. This information helps clients understand your organizational strengths and service offerings.",
+        left_required=True,
+        textarea_height=200,  # Increased height for better visibility
+        textarea_placeholder="Enter seller enterprise name first to enable this field",
+        textarea_session_key="seller_enterprise_content",
+        textarea_widget_key="seller_enterprise_textarea",
+        
+        # Unified right section (middle + right columns) configuration
+        unified_section_title="Available Services & Capabilities",
+        unified_section_tooltip="Select from available services and capabilities that represent your enterprise offerings. These can include technical services, consulting, products, or specialized business solutions.",
+        
+        # Session state keys for both sides
+        middle_selected_items_key="selected_services_offered",
+        middle_content_map_key="services_content_map",
+        right_selected_items_key="selected_additional_capabilities",
+        right_content_map_key="capabilities_content_map",
+        
+        # Single data source that will be displayed in both columns
+        default_data=None,  # You would pass your services data dictionary here
+        split_ratio=(3, 3),  # How many items go to middle vs right column
+        
+        # Enable/disable conditions
+        client_enabled_condition=True,
+        client_name_provided=True,
+        
+        # Styling configuration
+        button_column_width=2.5,  # Button width within each column
+        content_column_width=6.5,   # Content area width within each column
+        show_success_messages=False,
+        selected_color="#2e7d32",  # Green color
+        selected_border_color="#4caf50",  # Green border
+        unselected_color="#404040",
+        unselected_border_color="#404040",
+        text_color="#ffffff",
+        
+        # Title styling - Made normal size like left title
+        title_font_size="18px",  # Same as other titles
+        title_color="#ffffff",
+        title_margin_bottom="10px"  # Reduced margin
+    )

GS_Sales_Proposal/Seller/seller_css.py

@@ -0,0 +1,430 @@
+seller_css = """
+<style>
+    .client-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #667eea;
+        margin-bottom: 1rem;
+        color: #2a2a2a;
+    }
+    
+    .url-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #764ba2;
+        margin-bottom: 1rem;
+        color: #2a2a2a;
+    }
+    
+    .document-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border: 2px solid #5a9f9f;
+        margin-bottom: 1rem;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        color: #2a2a2a;
+    }
+    
+    .pain-points-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #ffc107;
+        color: #2a2a2a;
+    }
+    
+    .roles-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #2196f3;
+        color: #2a2a2a;
+    }
+    
+    .priorities-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #9c27b0;
+        color: #2a2a2a;
+    }
+    
+    .ai-suggestion-section {
+        background: #f5f5f5;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #00bcd4;
+        color: #2a2a2a;
+    }
+    
+    .upload-section {
+        border: 2px dashed #667eea;
+        border-radius: 10px;
+        padding: 2rem;
+        text-align: center;
+        background: #f5f5f5;
+        color: #2a2a2a;
+    }
+    
+    /* Style section headers */
+    .section-header {
+        color: #2a2a2a;
+        font-size: 1.2rem;
+        font-weight: 600;
+        margin-bottom: 1rem;
+    }
+    
+    /* Mandatory field styling */
+    .mandatory-label {
+        color: #e74c3c;
+        font-weight: 600;
+    }
+    
+    .field-warning {
+        color: #e74c3c;
+        font-size: 0.85rem;
+        margin-top: 0.25rem;
+        font-weight: 500;
+        background: rgba(231, 76, 60, 0.1);
+        padding: 0.5rem;
+        border-radius: 4px;
+        border-left: 3px solid #e74c3c;
+    }
+    
+    .optional-label {
+        color: #666666;
+        font-size: 0.8rem;
+        font-style: italic;
+    }
+    
+    .ai-label {
+        color: #00bcd4;
+        font-size: 0.8rem;
+        font-style: italic;
+    }
+    
+    /* Custom styling for URL buttons */
+    .url-button-container {
+        display: flex;
+        gap: 5px;
+        align-items: center;
+    }
+    
+    .url-button {
+        background: #667eea;
+        color: white;
+        border: none;
+        padding: 8px 12px;
+        border-radius: 6px;
+        cursor: pointer;
+        font-size: 14px;
+        transition: background-color 0.3s;
+    }
+    
+    .url-button:hover {
+        background: #5a6fd8;
+    }
+    
+    /* Summary item styling */
+    .summary-item {
+        background: #f5f5f5;
+        border: 1px solid #5a9f9f;
+        border-radius: 8px;
+        padding: 12px;
+        margin-bottom: 8px;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        color: #2a2a2a;
+    }
+    
+    .summary-key {
+        font-weight: 600;
+        color: #667eea;
+    }
+    
+    .add-button {
+        background: #28a745;
+        color: white;
+        border: none;
+        padding: 6px 12px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 12px;
+        font-weight: bold;
+    }
+    
+    .add-button:hover {
+        background: #218838;
+    }
+    
+    .summary-buttons {
+        display: flex;
+        gap: 8px;
+        margin-bottom: 12px;
+    }
+    
+    .summary-control-btn {
+        background: #007bff;
+        color: white;
+        border: none;
+        padding: 6px 12px;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 12px;
+    }
+    
+    .summary-control-btn:hover {
+        background: #0056b3;
+    }
+    
+    /* Fixed tooltip label alignment */
+    .tooltip-label {
+        font-size: 16px;
+        font-weight: bold;
+        margin-bottom: 8px;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        height: 24px;
+        line-height: 24px;
+        min-height: 32px;
+        display: flex;
+        align-items: flex-end;
+    }
+    
+    .tooltip-icon {
+        position: relative;
+        display: inline-block;
+        cursor: pointer;
+        margin-left: 0;
+    }
+    
+    .tooltip-icon::after {
+        content: attr(data-tooltip);
+        visibility: hidden;
+        width: 250px;
+        background-color: #555;
+        color: #fff;
+        text-align: left;
+        border-radius: 6px;
+        padding: 8px;
+        position: absolute;
+        z-index: 1;
+        bottom: 125%;
+        left: 50%;
+        margin-left: -125px;
+        opacity: 0;
+        transition: opacity 0.3s;
+    }
+    
+    .tooltip-icon:hover::after {
+        visibility: visible;
+        opacity: 1;
+    }
+    
+    /* Streamlit input elements styling - ALL INPUTS */
+    
+    /* Text Input */
+    .stTextInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Text Area */
+    .stTextArea > div > div > textarea {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Number Input */
+    .stNumberInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Select Box */
+    .stSelectbox > div > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Multiselect */
+    .stMultiSelect > div > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Date Input */
+    .stDateInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* Time Input */
+    .stTimeInput > div > div > input {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+        padding: 12px !important;
+        font-size: 14px !important;
+    }
+    
+    /* File Uploader */
+    .stFileUploader > div > div {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Color Picker */
+    .stColorPicker > div > div > input {
+        background-color: #f5f5f5 !important;
+        border: 2px solid #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+    
+    /* Focus states for all inputs */
+    .stTextInput > div > div > input:focus,
+    .stTextArea > div > div > textarea:focus,
+    .stNumberInput > div > div > input:focus,
+    .stDateInput > div > div > input:focus,
+    .stTimeInput > div > div > input:focus {
+        border-color: #667eea !important;
+        box-shadow: 0 0 0 2px rgba(102, 126, 234, 0.2) !important;
+        outline: none !important;
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+    }
+    
+    /* Active/typing states to ensure text stays visible */
+    .stTextInput > div > div > input:active,
+    .stTextArea > div > div > textarea:active,
+    .stNumberInput > div > div > input:active,
+    .stDateInput > div > div > input:active,
+    .stTimeInput > div > div > input:active {
+        background-color: #f5f5f5 !important;
+        color: #2a2a2a !important;
+    }
+    
+    /* Placeholder text for all inputs */
+    .stTextInput > div > div > input::placeholder,
+    .stTextArea > div > div > textarea::placeholder,
+    .stNumberInput > div > div > input::placeholder,
+    .stDateInput > div > div > input::placeholder,
+    .stTimeInput > div > div > input::placeholder {
+        color: #666666 !important;
+        opacity: 0.7 !important;
+    }
+    
+    /* Labels for all input types */
+    .stTextInput > label,
+    .stTextArea > label,
+    .stNumberInput > label,
+    .stSelectbox > label,
+    .stMultiSelect > label,
+    .stDateInput > label,
+    .stTimeInput > label,
+    .stFileUploader > label,
+    .stColorPicker > label {
+        color: #2a2a2a !important;
+        font-weight: 600 !important;
+        margin-bottom: 8px !important;
+    }
+    
+    /* Dropdown options styling */
+    .stSelectbox div[data-baseweb="select"] > div > div,
+    .stMultiSelect div[data-baseweb="select"] > div > div {
+        background-color: #f5f5f5 !important;
+    }
+    
+    /* File uploader drag and drop area */
+    .stFileUploader section {
+        background-color: #f5f5f5 !important;
+        border: 2px dashed #5a9f9f !important;
+        border-radius: 8px !important;
+    }
+input,
+textarea,
+select,
+.stSelectbox,
+.stMultiSelect {
+    color: #2a2a2a !important;
+}
+
+   /* Force override all button styling */
+                    button[kind="secondary"] {
+                        height: 48px !important;
+                        border: 2.2px solid #618f8f !important;
+                        border-radius: 4px !important;
+                        margin-top: -5px !important;  /* Move button up */
+                        transform: translateY(-3px) !important;  /* Additional upward adjustment */
+                        background-color: #4a4a4a !important;  /* Dark greyish background */
+                        color: white !important;  /* White text */
+                    }
+                     
+                    button[kind="secondary"]:hover {
+                        border: 2.2px solid #618f8f !important;
+                        transform: translateY(-3px) !important;  /* Keep position on hover */
+                        background-color: #5a5a5a !important;  /* Slightly lighter on hover */
+                        color: white !important;  /* Keep white text on hover */
+                    }
+                     
+                    button[kind="secondary"]:focus {
+                        border: 2.2px solid #618f8f !important;
+                        outline: 2px solid #618f8f !important;
+                        transform: translateY(-3px) !important;  /* Keep position on focus */
+                        background-color: #4a4a4a !important;  /* Keep dark background on focus */
+                        color: white !important;  /* Keep white text on focus */
+                    }
+                     
+                    /* Try targeting by data attributes */
+                    [data-testid] button {
+                        border: 2.2px solid #618f8f !important;
+                        height: 48px !important;
+                        margin-top: -5px !important;  /* Move button up */
+                        transform: translateY(-3px) !important;  /* Additional upward adjustment */
+                        background-color: #4a4a4a !important;  /* Dark greyish background */
+                        color: white !important;  /* White text */
+                    }
+                    
+                    /* Additional targeting for button text specifically */
+                    button[kind="secondary"] p,
+                    button[kind="secondary"] span,
+                    button[kind="secondary"] div {
+                        color: white !important;
+                    }
+                    
+                    [data-testid] button p,
+                    [data-testid] button span,
+                    [data-testid] button div {
+                        color: white !important;
+                    }
+
+</style>
+"""

GS_Sales_Proposal/Seller/seller_utils.py

@@ -0,0 +1,46 @@
+import streamlit as st
+import pandas as pd
+from typing import List
+import os
+
+from WebsiteUrl_Agent.agent_runner import get_urls
+import asyncio 
+from Document_Upload_Vectordb.pain_points_extractor import *
+from WebScraper.scrape import get_data
+
+
+# Function to get URLs (placeholder function)
+
+def get_urls_list(company_name) -> List[str]:
+    """
+    Placeholder function that returns a list of URLs
+    Replace this with your actual function that fetches URLs
+    """
+    return asyncio.run(get_urls(company_name))
+
+def check_field_validation(field_name: str, field_value: str, is_mandatory: bool = False) -> bool:
+    """Check if field validation should show warning"""
+    if is_mandatory and not field_value.strip():
+        return True
+    return False
+
+def show_field_warning(field_name: str):
+    """Show warning message for mandatory fields"""
+    st.markdown(f'<div class="field-warning">⚠️ {field_name} is mandatory and cannot be empty!</div>', unsafe_allow_html=True)
+
+def get_url_details(url:str):
+    """Use this if you want to run async function synchronously"""
+    try:
+        # Run the async function synchronously
+        website_details = asyncio.run(get_data(url))
+        return website_details
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+    
+def save_uploaded_file_and_get_path(file):
+    return "saved"
+
+
+def get_seller_services(filename , filepath):
+    return "pain points"

GS_Sales_Proposal/WebScraper/main.py

@@ -0,0 +1,8 @@
+import asyncio
+from scrape import get_data
+async def main():
+    result = await get_data('https://www.whatsapp.com/')
+    print(result.extracted_content)
+
+if __name__ == '__main__':
+    asyncio.run(main())

GS_Sales_Proposal/WebScraper/scrape.py

@@ -0,0 +1,122 @@
+from typing import List
+import json
+
+from WebScraper.state import User
+
+
+
+from crawl4ai import LLMConfig,AsyncWebCrawler,CacheMode,CrawlerRunConfig,BrowserConfig
+from crawl4ai.extraction_strategy import LLMExtractionStrategy
+import os 
+from dotenv import load_dotenv
+load_dotenv()
+
+llm_strategy = LLMExtractionStrategy(
+    llm_config=LLMConfig(
+        provider="gemini/gemini-1.5-flash",
+        api_token=os.getenv("GOOGLE_API_KEY"),
+    ),
+    schema=User.model_json_schema(),
+    extraction_type="schema",
+        instruction="""
+You are analyzing a webpage to extract structured information about the organization behind it.
+
+Your goal is to extract the following:
+
+1. **Name**: The name of the organization or company.
+2. **Logo**: The URL of the primary logo image (typically found in the header or near the company name).
+3. **Detailed Description**: A clear and informative summary of what the organization does. 
+   - This should come from the section of the page typically labeled or titled "About", "Who We Are", "Our Story", or similar.
+   - If the page does not have a heading, look for paragraphs or text blocks that describe the company's purpose, mission, background, or offerings.
+   - Do not include text that is clearly part of blog posts, testimonials, products, or contact details.
+
+Tips:
+- Focus on sections that describe the identity, mission, background, or goals of the organization.
+- If multiple descriptive sections exist, prioritize the one closest to the top of the page or under an "About"-like heading.
+- Avoid generic filler content like navigation menus, service listings, or unrelated calls to action.
+
+Return the data in the format defined by the schema.
+"""
+,    chunk_token_threshold=1000,
+    overlap_rate=0.0,
+    apply_chunking=True,
+    input_format="markdown",   # or "html", "fit_markdown"
+    extra_args={"temperature": 0.0, "max_tokens": 800}
+)
+
+crawl_config = CrawlerRunConfig(
+    extraction_strategy=llm_strategy,
+    cache_mode=CacheMode.BYPASS
+)
+
+
+browser_cfg = BrowserConfig(headless=True)
+
+import re 
+
+import re
+from collections import Counter
+from typing import List
+
+
+
+
+def aggregate_users(users: List[dict]) -> User:
+    print("🔍 Starting aggregation of users...")
+
+    # Filter out users with error=True
+    valid_users = [u for u in users if not u.get('error', False)]
+
+
+    # Most frequent name (non-empty and non-None)
+    names = [u.get('name', '') or '' for u in valid_users if u.get('name')]
+    name_counter = Counter(names)
+    name = name_counter.most_common(1)[0][0] if name_counter else (valid_users[0].get('name') or "Unknown")
+    logo = next(
+        (
+            logo for u in valid_users
+            if (logo := u.get('logo')) and isinstance(logo, str) and re.search(r'logo', logo, re.IGNORECASE)
+        ),
+        ""
+    )
+
+
+    # Longest non-empty description
+    descriptions = [u.get('description', '') or '' for u in valid_users]
+    description = max(descriptions, key=len, default="")
+
+    # Services list from user with the longest list (non-None)
+    all_service_lists = [
+        (u.get('name', 'Unknown'), u.get('services') or []) for u in valid_users
+    ]
+    services = max((s for _, s in all_service_lists), key=len, default=[])
+    return User(
+        name=name,
+        logo=logo,
+        description=description,
+        services=services
+    )
+
+def format_enterprise_details(details_obj: User):
+    return f"""Name: {details_obj.name}
+Description: {details_obj.description}
+Services:
+- {'\n- '.join(details_obj.services)}
+"""
+
+async def get_data(url:str):
+
+    async with AsyncWebCrawler(config= browser_cfg) as crawler:
+        result = await crawler.arun(
+            url = url,
+            config = crawl_config)
+    
+    if result.success:
+        print(f"Successfully scraped : '\n\n\n {result.extracted_content}")    
+        lists = json.loads(result.extracted_content)  # here instead of returning the last we may refine the one we need
+        #print(lists)
+        print(aggregate_users(lists))
+        return format_enterprise_details(aggregate_users(lists))
+    
+    else:
+        print(f"The code exited with eroor {result.error_message}")

GS_Sales_Proposal/WebScraper/scrape_utils.py

@@ -0,0 +1,32 @@
+import re
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+
+def extract_hex_colors(url: str, limit: int = 5) -> list:
+    try:
+        response = requests.get(url, timeout=10)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find inline styles
+        inline_styles = [tag.get('style', '') for tag in soup.find_all(style=True)]
+        css_text = ' '.join(inline_styles)
+
+        # Find linked stylesheets
+        css_links = [link['href'] for link in soup.find_all('link', rel='stylesheet') if 'href' in link.attrs]
+
+        for href in css_links:
+            full_url = urljoin(url, href)
+            try:
+                css_response = requests.get(full_url, timeout=5)
+                css_text += ' ' + css_response.text
+            except:
+                continue
+
+        # Extract hex codes
+        hex_colors = re.findall(r'#[0-9a-fA-F]{3,6}', css_text)
+        hex_colors = list(dict.fromkeys(hex_colors))  # remove duplicates, preserve order
+        return hex_colors[:limit]  # return top `limit` hex codes
+    except Exception as e:
+        print(f"Error extracting hex colors: {e}")
+        return []

GS_Sales_Proposal/WebScraper/state.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel,Field
+from typing import List
+
+class User(BaseModel):
+    name : str 
+    logo : str 
+    description : str
+    services: List[str]