Upload 8 files

app.py

@@ -0,0 +1,582 @@
+import streamlit as st
+from PIL import Image, ImageFile
+import sys
+import os
+import json
+from huggingface_hub import hf_hub_download
+from io import BytesIO
+from datetime import datetime
+HF_USERNAME = "palakmathur"
+# sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from domain_validator import DomainValidator
+from description_extractor import DescriptionExtractor
+from defect_matcher import DefectMatcher
+from condition_grader import ConditionGrader
+from predictor.price_predictor import PricePredictor
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+st.set_page_config(
+    page_title="Device Defect Diagnosis System",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+st.markdown("""
+<style>
+            
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #1f77b4;
+        text-align: center;
+        padding: 1rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 0.5rem 0;
+    }
+    .success-box {
+        background: linear-gradient(135deg, #1e7e34 0%, #28a745 100%);
+        border-left: 5px solid #4cff4c;
+        padding: 1rem;
+        margin: 1rem 0;
+        border-radius: 5px;
+        color: white;
+        font-weight: 500;
+        box-shadow: 0 2px 8px rgba(40, 167, 69, 0.3);
+    }
+    .warning-box {
+        background: linear-gradient(135deg, #c43a00 0%, #dc3545 100%);
+        border-left: 5px solid #ffcc00;
+        padding: 1rem;
+        margin: 1rem 0;
+        border-radius: 5px;
+        color: white;
+        font-weight: 500;
+        box-shadow: 0 2px 8px rgba(220, 53, 69, 0.3);
+    }
+    .error-box {
+        background-color: #f8d7da;
+        border-left: 5px solid #dc3545;
+        padding: 1rem;
+        margin: 1rem 0;
+        border-radius: 5px;
+    }
+    .defect-name {
+        font-size: 1.5rem;
+        font-weight: bold;
+        color: white;
+        padding: 0.5rem 0;
+        margin: 0.5rem 0;
+    }
+    .defect-info {
+        background: linear-gradient(135deg, #1a5490 0%, #1f77b4 100%);
+        padding: 1.2rem;
+        border-radius: 8px;
+        border-left: 4px solid #5dade2;
+        margin: 1rem 0;
+        box-shadow: 0 2px 8px rgba(31, 119, 180, 0.3);
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+@st.cache_resource
+def load_system():
+    """Load the diagnosis system (cached)"""
+    with st.spinner(" Loading models... This may take a minute..."):
+        validator = DomainValidator()
+        extractor = DescriptionExtractor()
+        matcher = DefectMatcher(use_finetuned=True) 
+        grader = ConditionGrader()
+        try:
+            predictor = PricePredictor()
+            predictor.load_model()
+        except:
+            predictor = None
+        
+        return validator, extractor, matcher, grader, predictor
+
+
+def main():
+    st.markdown('<div class="main-header"> Device Defect Diagnosis System</div>', unsafe_allow_html=True)
+    st.markdown('<div class="sub-header">Upload a device image to detect defects and estimate resale value</div>', unsafe_allow_html=True)
+    
+    validator, extractor, matcher, grader, predictor = load_system()
+    
+    with st.sidebar:
+        st.header("Instructions:-")
+        st.markdown("""
+        1. **Upload** a device image (phone/laptop)
+        2. **Describe** the issue (optional)
+        3. **Enter** device details for pricing
+        4. **Click** Diagnose to get results
+        
+        ---
+        
+        ###  Supported Devices
+        -  Smartphones
+        -  Laptops
+        -  Desktop computers
+        
+        ---
+        
+        ###  Understanding Results
+        
+        **Confidence Score**  
+        How certain the model is about its detection (0-100%)
+        - 90%+ : High confidence
+        - 70-90% : Good confidence
+        - <70% : Review needed
+        
+        **Severity Score** (0-10)  
+        Impact of the defect on device functionality
+        - 8-10 : Critical (needs repair)
+        - 5-7 : Moderate (affects usage)
+        - 0-4 : Minor (cosmetic)
+        
+        **Condition Score** (0-10)  
+        Overall device condition after inspection
+        - 9-10 : Excellent (Grade A)
+        - 7-9 : Good (Grade B)
+        - 5-7 : Fair (Grade C)
+        - 3-5 : Poor (Grade D)
+        - 0-3 : Bad (Grade F)
+        
+        ---
+        
+        ###  Detected Issues:-
+        - Screen damage
+        - Physical defects
+        - Component failures
+        - And more...
+        """)
+        
+        st.markdown("---")
+        st.markdown("### System Stats :-")
+        st.metric("Models Loaded", "5/5")
+        st.metric("Defect Types", "15+")
+        st.metric("Avg Response Time", "8.2s")
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.header(" Upload & Configure")
+        
+        uploaded_file = st.file_uploader(
+            "Choose a device image",
+            type=['jpg', 'jpeg', 'png'],
+            help="Upload a clear image of your device"
+        )
+        
+        if uploaded_file:
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_container_width=False)
+        
+        description = st.text_area(
+            "Describe the issue (optional)",
+            placeholder="e.g., My phone screen cracked after I dropped it. Touch is not working properly.",
+            height=100,
+            help="Providing a description improves accuracy"
+        )
+        
+        st.subheader(" Device Information (for price prediction)")
+        
+        col_a, col_b = st.columns(2)
+        
+        with col_a:
+            brand = st.selectbox(
+                "Brand",
+                ["Apple", "Samsung", "OnePlus", "Dell", "HP", "Lenovo", "Other"]
+            )
+            
+            device_type = st.selectbox(
+                "Device Type",
+                ["Phone", "Laptop"]
+            )
+        
+        model_options = {
+                "Apple": {
+                    "Phone": ["iPhone 15 Pro Max", "iPhone 15 Pro", "iPhone 15", "iPhone 14 Pro Max", "iPhone 14 Pro", "iPhone 14", "iPhone 13 Pro Max", "iPhone 13 Pro", "iPhone 13", "iPhone 12 Pro Max", "iPhone 12 Pro", "iPhone 12", "iPhone 11 Pro Max", "iPhone 11 Pro", "iPhone 11", "iPhone XS Max", "iPhone XS", "iPhone XR", "iPhone X", "iPhone 8 Plus", "iPhone 8"],
+                    "Laptop": ["MacBook Pro 16\" M3 Max", "MacBook Pro 14\" M3 Pro", "MacBook Pro 16\" M2 Max", "MacBook Pro 14\" M2 Pro", "MacBook Air M3", "MacBook Air M2", "MacBook Air M1", "MacBook Pro 13\" M1"]
+                },
+                "Samsung": {
+                    "Phone": ["Galaxy S24 Ultra", "Galaxy S24+", "Galaxy S24", "Galaxy S23 Ultra", "Galaxy S23+", "Galaxy S23", "Galaxy S22 Ultra", "Galaxy S22+", "Galaxy S22", "Galaxy Z Fold 5", "Galaxy Z Flip 5", "Galaxy Z Fold 4", "Galaxy Z Flip 4", "Galaxy A54", "Galaxy A34"],
+                    "Laptop": ["Galaxy Book4 Pro", "Galaxy Book3 Ultra", "Galaxy Book3 Pro 360", "Galaxy Book2 Pro", "Galaxy Book2"]
+                },
+                "OnePlus": {
+                    "Phone": ["OnePlus 12", "OnePlus 11", "OnePlus 10 Pro", "OnePlus 9 Pro", "OnePlus 9", "OnePlus 8T", "OnePlus Nord 3", "OnePlus Nord 2"],
+                    "Laptop": []
+                },
+                "Dell": {
+                    "Phone": [],
+                    "Laptop": ["XPS 15", "XPS 13", "XPS 17", "Inspiron 15", "Inspiron 14", "Latitude 5430", "Latitude 7430", "Alienware m15", "Alienware x15", "Vostro 15"]
+                },
+                "HP": {
+                    "Phone": [],
+                    "Laptop": ["Pavilion 15", "Pavilion 14", "Envy 15", "Envy 13", "Spectre x360 14", "Spectre x360 16", "EliteBook 840", "EliteBook 850", "ProBook 450", "Omen 15"]
+                },
+                "Lenovo": {
+                    "Phone": [],
+                    "Laptop": ["ThinkPad X1 Carbon", "ThinkPad X1 Yoga", "ThinkPad T14", "ThinkPad T16", "IdeaPad Slim 5", "IdeaPad Gaming 3", "Yoga 9i", "Yoga 7i", "Legion 5 Pro"]
+                },
+                "Other": {
+                    "Phone": ["Other Model"],
+                    "Laptop": ["Other Model"]
+                }
+        }
+        
+        available_models = model_options.get(brand, {}).get(device_type, ["Other Model"])
+        
+        with col_b:
+            if available_models:
+                model = st.selectbox("Model", available_models)
+            else:
+                st.warning(f"No {device_type} models available for {brand}")
+                model = st.text_input("Model (enter manually)", "")
+            
+            original_price = st.number_input("Original Price (₹)", min_value=0, value=79900, step=1000)
+        
+        age_months = st.slider("Age (months)", 0, 60, 18, help="How old is the device?")
+    
+    with col2:
+        st.header("Diagnosis Results :- ")
+        
+        if uploaded_file:
+            if st.button(" Diagnose Device", type="primary", use_container_width=False):
+                
+                temp_path = "temp_upload.jpg"
+                if image.mode == 'RGBA':
+                    image = image.convert('RGB')
+                image.save(temp_path)
+                
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                try:
+                    status_text.text("Stage 1/5: Validating device...")
+                    progress_bar.progress(20)
+                    
+                    validation = validator.validate(temp_path)
+                    
+                    if not validation['is_valid']:
+                        st.markdown(f'<div class="error-box"> <b>Invalid Image</b><br>{validation["reason"]}</div>', unsafe_allow_html=True)
+                        os.remove(temp_path)
+                        return
+                    
+                    status_text.text("Stage 2/5: Processing description...")
+                    progress_bar.progress(40)
+                    
+                    if description:
+                        desc_info = extractor.extract(description)
+                        search_text = extractor.create_search_text(desc_info)
+                    else:
+                        search_text = None
+                    
+                    status_text.text(" Stage 3/5: Detecting defects...")
+                    progress_bar.progress(60)
+                    
+                    match_result = matcher.match(temp_path, search_text, top_k=3)
+                    defect = match_result['top_match']
+                    
+                    status_text.text("Stage 4/5: Grading condition...")
+                    progress_bar.progress(80)
+                    
+                    grading = grader.assign_grade([defect])
+                    
+                    status_text.text("Stage 5/5: Predicting price...")
+                    progress_bar.progress(90)
+                    
+                    price_result = None
+                    if predictor:
+                        try:
+                            device_info = {
+                                'brand': brand,
+                                'model': model,
+                                'original_price': original_price,
+                                'age_months': age_months
+                            }
+                            price_result = predictor.predict(device_info, [defect], grading['condition_score'])
+                        except:
+                            pass
+                    
+                    progress_bar.progress(100)
+                    status_text.text(" Diagnosis complete!!!")
+                    
+                    st.markdown("---")
+                    
+                    st.markdown(f'<div class="success-box"> <b>Valid {validation["device_type"].title()} Detected</b> (Confidence: {validation["confidence"]:.1%})</div>', unsafe_allow_html=True)
+                    
+                    st.subheader(" Detected Issue")
+                    
+                    severity_color = "#dc3545" if defect.get('critical', False) else "#ffc107" if defect['severity_score'] > 6 else "#28a745"
+                    
+                    st.markdown(f'<div class="defect-info"><div class="defect-name"> {defect["name"]}</div></div>', unsafe_allow_html=True)
+                    
+                    col_r1, col_r2 = st.columns(2)
+                    col_r1.metric(
+                        "Confidence", 
+                        f"{match_result['confidence']:.1%}",
+                        help="How certain the AI is about this detection. Higher is better."
+                    )
+                    col_r2.metric(
+                        "Severity", 
+                        f"{defect['severity_score']}/10",
+                        help="Impact of this defect: 0-4 (Minor), 5-7 (Moderate), 8-10 (Critical)"
+                    )
+                    
+                    if defect['severity_score'] >= 8:
+                        severity_msg = " **High Severity:** This defect significantly impacts device functionality and requires immediate attention."
+                    elif defect['severity_score'] >= 5:
+                        severity_msg = " **Moderate Severity:** This defect affects device usage. Consider repair before resale."
+                    else:
+                        severity_msg = " **Low Severity:** This is mostly a cosmetic issue with minimal impact on functionality."
+                    
+                    st.info(severity_msg)
+                    
+                    if defect.get('critical', False):
+                        st.markdown(f'<div class="warning-box"> <b>Critical Issue Detected</b><br>Immediate attention required</div>', unsafe_allow_html=True)
+                    
+                    st.subheader(" Condition Assessment")
+                    
+                    col_c1, col_c2 = st.columns(2)
+                    col_c1.metric(
+                        "Grade", 
+                        grading['grade'], 
+                        help="Letter grade from A (Excellent) to F (Bad) based on overall condition"
+                    )
+                    col_c2.metric(
+                        "Condition Score", 
+                        f"{grading['condition_score']}/10",
+                        help="Numerical score: 10 is perfect, 0 is non-functional. Affects resale value directly."
+                    )
+                    
+                    st.caption(f"**{grading['description']}**")
+                    
+                    with st.expander("What does this grade mean???", expanded=False):
+                        grade_info = {
+                            'A': "**Excellent Condition** - Device is like new with minimal to no defects. Commands premium resale price.",
+                            'B': "**Good Condition** - Device shows minor wear but fully functional. Good resale value.",
+                            'C': "**Fair Condition** - Device has noticeable defects but still usable. Moderate resale value.",
+                            'D': "**Poor Condition** - Device has significant issues affecting usability. Low resale value.",
+                            'F': "**Bad Condition** - Device has critical defects or is barely functional. Very low resale value."
+                        }
+                        st.write(grade_info.get(grading['grade'], "Assessment completed"))
+                        
+                        st.write("""\n**How it's calculated:**
+- Based on severity and number of defects
+- Physical damage has higher impact
+- Critical defects significantly lower the grade
+- Overall device age and wear considered""")
+                    
+                    if price_result:
+                        st.subheader("Resale Valuation")
+                        
+                        col_p1, col_p2, col_p3 = st.columns(3)
+                        col_p1.metric(
+                            "Estimated Price", 
+                            f"₹{price_result['predicted_price']:,}",
+                            help="AI-predicted resale price based on condition, defects, and market data"
+                        )
+                        col_p2.metric(
+                            "Min Price", 
+                            f"₹{price_result['price_range']['min']:,}",
+                            help="Minimum expected price in current market conditions"
+                        )
+                        col_p3.metric(
+                            "Max Price", 
+                            f"₹{price_result['price_range']['max']:,}",
+                            help="Maximum expected price for this condition"
+                        )
+                        
+                        st.caption(f"**Prediction Confidence:** {price_result['confidence']:.0%} - How reliable this price estimate is based on available data")
+                        
+                        with st.expander(" Price Impact Factors"):
+                            for factor in price_result['depreciation_factors']:
+                                st.markdown(f"• **{factor['factor']}**: {factor['impact']} - {factor['description']}")
+                    
+                    if len(match_result['all_matches']) > 1:
+                        with st.expander(" Alternative Diagnoses"):
+                            for i, alt in enumerate(match_result['all_matches'][1:3], 2):
+                                st.markdown(f"{i}. **{alt['defect']['name']}** - Confidence: {alt['confidence']:.1%}")
+                    
+                    st.markdown("---")
+                    
+                    try:
+                        from fpdf import FPDF
+                        from fpdf.enums import XPos, YPos
+                        
+                        class DiagnosisReport(FPDF):
+                            def header(self):
+                                self.set_font('Helvetica', 'B', 20)
+                                self.set_text_color(31, 119, 180)
+                                self.cell(0, 10, 'Device Diagnosis Report', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
+                                self.set_font('Helvetica', '', 10)
+                                self.set_text_color(100, 100, 100)
+                                self.cell(0, 6, f"Generated: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
+                                self.ln(10)
+                            
+                            def footer(self):
+                                self.set_y(-15)
+                                self.set_font('Helvetica', 'I', 8)
+                                self.set_text_color(128, 128, 128)
+                               
+                        
+                        pdf = DiagnosisReport()
+                        pdf.add_page()
+                        pdf.set_auto_page_break(auto=True, margin=15)
+                        
+                        pdf.set_font('Helvetica', 'B', 14)
+                        pdf.set_text_color(44, 62, 80)
+                        pdf.cell(0, 10, 'Device Information', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        pdf.ln(2)
+                        
+                        pdf.set_font('Helvetica', '', 11)
+                        pdf.set_text_color(0, 0, 0)
+                        device_info = [
+                            ('Device Type:', validation['device_type'].title()),
+                            ('Brand:', brand),
+                            ('Model:', model),
+                            ('Age:', f"{age_months} months"),
+                            ('Detection Confidence:', f"{validation['confidence']:.1%}")
+                        ]
+                        for label, value in device_info:
+                            pdf.set_font('Helvetica', 'B', 11)
+                            pdf.cell(60, 8, label, border=1, new_x=XPos.RIGHT, new_y=YPos.TOP, align='L')
+                            pdf.set_font('Helvetica', '', 11)
+                            pdf.cell(0, 8, str(value), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        
+                        pdf.ln(8)
+                        
+                        pdf.set_font('Helvetica', 'B', 14)
+                        pdf.set_text_color(44, 62, 80)
+                        pdf.cell(0, 10, 'Detected Issue', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        pdf.ln(2)
+                        
+                        pdf.set_font('Helvetica', '', 11)
+                        pdf.set_text_color(0, 0, 0)
+                        defect_info = [
+                            ('Defect Name:', defect['name']),
+                            ('Confidence:', f"{match_result['confidence']:.1%}"),
+                            ('Severity Score:', f"{defect['severity_score']}/10"),
+                            ('Critical:', 'Yes' if defect.get('critical', False) else 'No')
+                        ]
+                        for label, value in defect_info:
+                            pdf.set_font('Helvetica', 'B', 11)
+                            pdf.cell(60, 8, label, border=1, new_x=XPos.RIGHT, new_y=YPos.TOP, align='L')
+                            pdf.set_font('Helvetica', '', 11)
+                            pdf.cell(0, 8, str(value), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        
+                        pdf.ln(8)
+                        
+                        pdf.set_font('Helvetica', 'B', 14)
+                        pdf.set_text_color(44, 62, 80)
+                        pdf.cell(0, 10, 'Condition Assessment', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        pdf.ln(2)
+                        
+                        pdf.set_font('Helvetica', '', 11)
+                        pdf.set_text_color(0, 0, 0)
+                        condition_info = [
+                            ('Grade:', grading['grade']),
+                            ('Condition Score:', f"{grading['condition_score']}/10"),
+                            ('Description:', grading['description'])
+                        ]
+                        for label, value in condition_info:
+                            pdf.set_font('Helvetica', 'B', 11)
+                            pdf.cell(60, 8, label, border=1, new_x=XPos.RIGHT, new_y=YPos.TOP, align='L')
+                            pdf.set_font('Helvetica', '', 11)
+                            pdf.cell(0, 8, str(value), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        
+                        pdf.ln(8)
+                        
+                        if price_result:
+                            pdf.set_font('Helvetica', 'B', 14)
+                            pdf.set_text_color(44, 62, 80)
+                            pdf.cell(0, 10, 'Resale Valuation', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                            pdf.ln(2)
+                            
+                            pdf.set_font('Helvetica', '', 11)
+                            pdf.set_text_color(0, 0, 0)
+                            pricing_info = [
+                                ('Estimated Price:', f"Rs. {price_result['predicted_price']:,}"),
+                                ('Price Range:', f"Rs. {price_result['price_range']['min']:,} - Rs. {price_result['price_range']['max']:,}"),
+                                ('Prediction Confidence:', f"{price_result['confidence']:.0%}")
+                            ]
+                            for label, value in pricing_info:
+                                pdf.set_font('Helvetica', 'B', 11)
+                                pdf.cell(60, 8, label, border=1, new_x=XPos.RIGHT, new_y=YPos.TOP, align='L')
+                                pdf.set_font('Helvetica', '', 11)
+                                pdf.cell(0, 8, str(value), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+                        
+                        pdf_data = bytes(pdf.output())
+                        
+                        st.download_button(
+                            " Download Full Report (PDF)",
+                            data=pdf_data,
+                            file_name=f"diagnosis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
+                            mime="application/pdf"
+                        )
+                    except (ImportError, Exception) as e:
+                        st.warning(f" PDF generation failed: {str(e)}\n")
+                        report = {
+                            'device': {
+                                'type': validation['device_type'],
+                                'brand': brand,
+                                'model': model,
+                                'age_months': age_months
+                            },
+                            'defect': {
+                                'name': defect['name'],
+                                'confidence': match_result['confidence'],
+                                'severity': defect['severity_score']
+                            },
+                            'condition': {
+                                'grade': grading['grade'],
+                                'score': grading['condition_score']
+                            }
+                        }
+                        
+                        if price_result:
+                            report['pricing'] = {
+                                'estimated_price': price_result['predicted_price'],
+                                'price_range': price_result['price_range']
+                            }
+                        
+                        st.download_button(
+                            "📥 Download Full Report (JSON)",
+                            data=json.dumps(report, indent=2),
+                            file_name="diagnosis_report.json",
+                            mime="application/json"
+                        )
+                    
+                    os.remove(temp_path)
+                    
+                except Exception as e:
+                    st.error(f" Error during diagnosis: {str(e)}")
+                    if os.path.exists(temp_path):
+                        os.remove(temp_path)
+        else:
+            st.info(" Upload an image to begin diagnosis")
+    
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center; color: #666; padding: 2rem;'>
+        <p><b>Device Defect Diagnosis System</b></p>
+        <p>Built with CLIP, BERT, and XGBoost</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+
+if __name__ == "__main__":
+    main()

condition_grader.py

@@ -0,0 +1,99 @@
+class ConditionGrader:
+    def __init__(self):
+
+        self.grade_criteria = {
+            'A': {
+                'description': 'Excellent - Like New',
+                'max_defects': 0,
+                'min_condition_score': 9.0,
+                'max_severity': 0
+            },
+            'B': {
+                'description': 'Good - Minor Cosmetic Issues',
+                'max_defects': 2,
+                'min_condition_score': 7.0,
+                'max_severity': 5
+            },
+            'C': {
+                'description': 'Fair - Moderate Damage',
+                'max_defects': 3,
+                'min_condition_score': 5.0,
+                'max_severity': 7
+            },
+            'D': {
+                'description': 'Poor - Significant Damage',
+                'max_defects': 5,
+                'min_condition_score': 3.0,
+                'max_severity': 9
+            },
+            'F': {
+                'description': 'Unacceptable - Major Damage/Non-functional',
+                'max_defects': 999,
+                'min_condition_score': 0,
+                'max_severity': 10
+            }
+        }
+    
+    def calculate_condition_score(self, defects):
+       
+        if not defects:
+            return 10.0
+        total_severity = sum(d['severity_score'] for d in defects)
+        num_defects = len(defects)
+        avg_severity = total_severity / num_defects
+        has_critical = any(d['critical'] for d in defects)
+        condition_score = 10 - avg_severity
+        if num_defects > 1:
+            condition_score -= (num_defects - 1) * 0.5
+        if has_critical:
+            condition_score -= 2.0
+        
+        return max(0.0, min(10.0, condition_score))
+    
+    def assign_grade(self, defects, condition_score=None):
+        
+        if condition_score is None:
+            condition_score = self.calculate_condition_score(defects)
+        
+        num_defects = len(defects)
+        max_severity = max([d['severity_score'] for d in defects], default=0)
+        has_critical = any(d.get('critical', False) for d in defects)
+        
+        if num_defects == 0:
+            grade = 'A'
+        elif has_critical or max_severity >= 9:
+            if num_defects >= 2:
+                grade = 'F'
+            else:
+                grade = 'D'
+        elif condition_score >= 9:
+            grade = 'A'
+        elif condition_score >= 7:
+            grade = 'B'
+        elif condition_score >= 5:
+            grade = 'C'
+        elif condition_score >= 3:
+            grade = 'D'
+        else:
+            grade = 'F'
+        
+        return {
+            'grade': grade,
+            'description': self.grade_criteria[grade]['description'],
+            'condition_score': round(condition_score, 2),
+            'breakdown': {
+                'num_defects': num_defects,
+                'max_severity': max_severity,
+                'has_critical': has_critical,
+                'defect_categories': list(set(d['category'] for d in defects))
+            }
+        }
+    
+    def get_grade_info(self, grade):
+        return self.grade_criteria.get(grade, {})
+
+
+if __name__ == "__main__":
+    grader = ConditionGrader()
+    
+    

config.toml

@@ -0,0 +1,10 @@
+[theme]
+primaryColor = "#1f77b4"
+backgroundColor = "#ffffff"
+secondaryBackgroundColor = "#f0f2f6"
+textColor = "#262730"
+
+[server]
+headless = true
+port = 7860
+enableCORS = false

defect_matcher.py

@@ -0,0 +1,105 @@
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image
+import torch
+import json
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+import os
+
+class DefectMatcher:
+    
+    def __init__(self, defect_db_path="data/defect_database.json",
+        use_finetuned=True,
+        finetuned_model_path="models/finetuned_clip/best_model"):
+
+        if use_finetuned and os.path.exists(finetuned_model_path):
+            
+            self.model = CLIPModel.from_pretrained(finetuned_model_path)
+            self.processor = CLIPProcessor.from_pretrained(finetuned_model_path)
+            self.model_type = "fine-tuned"
+        else:
+            self.model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+            self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+            self.model_type = "pre-trained"
+        
+        self.model.eval()
+        
+        with open(defect_db_path, 'r') as f:
+            self.defect_db = json.load(f)['defects']
+    
+        self._precompute_defect_embeddings()
+    
+    def _precompute_defect_embeddings(self):
+        defect_descriptions = [d['description'] for d in self.defect_db]
+        
+        inputs = self.processor(
+            text=defect_descriptions,
+            return_tensors="pt",
+            padding=True,
+            truncation=True
+        )
+        
+        with torch.no_grad():
+            text_features = self.model.get_text_features(**inputs)
+            text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+        
+        self.defect_embeddings = text_features.cpu().numpy()
+    
+    def match(self, image_path, description_text=None, top_k=3):
+        image = Image.open(image_path).convert('RGB')
+        
+        if description_text and len(description_text.strip()) > 0:
+            inputs = self.processor(
+                text=[description_text],
+                images=image,
+                return_tensors="pt",
+                padding=True
+            )
+            
+            with torch.no_grad():
+                image_features = self.model.get_image_features(pixel_values=inputs['pixel_values'])
+                text_features = self.model.get_text_features(input_ids=inputs['input_ids'])
+                
+                image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+                text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+            
+                fused_features = 0.6 * image_features + 0.4 * text_features
+                fused_features = fused_features / fused_features.norm(dim=-1, keepdim=True)
+            
+            query_embedding = fused_features.cpu().numpy()
+            method = "multimodal"
+            
+        else:
+            inputs = self.processor(
+                images=image,
+                return_tensors="pt"
+            )
+            
+            with torch.no_grad():
+                image_features = self.model.get_image_features(**inputs)
+                image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+            
+            query_embedding = image_features.cpu().numpy()
+            method = "image_only"
+        similarities = cosine_similarity(query_embedding, self.defect_embeddings)[0]
+        
+        top_indices = np.argsort(similarities)[::-1][:top_k]
+        
+        matches = []
+        for idx in top_indices:
+            defect = self.defect_db[idx]
+            score = float(similarities[idx])
+            matches.append({
+                'defect': defect,
+                'similarity_score': score,
+                'confidence': score  
+            })
+        
+        return {
+            'top_match': matches[0]['defect'],
+            'confidence': matches[0]['confidence'],
+            'all_matches': matches,
+            'method': method,
+            'match_count': len(matches)
+        }
+

description_extractor.py

@@ -0,0 +1,84 @@
+import re
+import torch
+from transformers import pipeline
+#2
+class DescriptionExtractor:
+    
+    def __init__(self):
+        self.summarizer = pipeline(
+            "summarization",
+            model="facebook/bart-large-cnn"
+        )
+        self.part_keywords = [
+            "screen", "display", "glass", "battery", "power",
+            "charging port", "port", "hinge", "keyboard", "keys",
+            "speaker", "audio", "microphone", "body", "frame",
+            "casing", "lid", "touchpad", "camera"
+        ]
+        
+        self.symptom_keywords = [
+            "crack", "broken", "damage", "not working", "loose",
+            "drain", "hot", "overheat", "scratch", "dent",
+            "bent", "water", "liquid", "sound", "audio"
+        ]
+    
+    def extract(self, description):
+        
+        if not description or len(description.strip()) < 5:
+            return {
+                'original': description,
+                'summary': description,
+                'affected_parts': [],
+                'symptoms': [],
+                'keywords': [],
+                'length_category': 'none'
+            }
+        
+        desc_lower = description.lower()
+        
+        word_count = len(description.split())
+        if word_count < 10:
+            length_category = 'short'
+            summary = description
+        elif word_count < 50:
+            length_category = 'medium'
+            summary = description
+        else:
+            length_category = 'long'
+            try:
+                summary_result = self.summarizer(
+                    description,
+                    max_length=50,
+                    min_length=10,
+                    do_sample=False
+                )
+                summary = summary_result[0]['summary_text']
+            except:
+                summary = ' '.join(description.split()[:40]) + "..."
+        affected_parts = [
+            part for part in self.part_keywords
+            if part in desc_lower
+        ]
+        
+        symptoms = [
+            symptom for symptom in self.symptom_keywords
+            if symptom in desc_lower
+        ]
+        keywords = list(set(affected_parts + symptoms))
+        
+        return {
+            'original': description,
+            'summary': summary,
+            'affected_parts': affected_parts,
+            'symptoms': symptoms,
+            'keywords': keywords,
+            'length_category': length_category,
+            'word_count': word_count
+        }
+    
+    def create_search_text(self, description_info):
+        if not description_info['keywords']:
+            return description_info['summary']
+        search_text = f"{description_info['summary']} {' '.join(description_info['keywords'])}"
+        return search_text
+

domain_validator.py

@@ -0,0 +1,96 @@
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image
+import torch
+#1
+class DomainValidator:
+    
+    def __init__(self):
+        self.model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
+        self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+        self.model.eval()
+        
+        self.valid_categories = [
+            "a smartphone or mobile phone",
+            "a laptop computer",
+            "a desktop computer or monitor",
+            "electronic device with screen"
+        ]
+        
+        self.invalid_categories = [
+            "a person or human face",
+            "an animal or pet",
+            "nature or landscape",
+            "food or drink",
+            "random object or item"
+        ]
+    def validate(self, image_path, threshold=0.3):
+        
+        try:
+            image = Image.open(image_path).convert('RGB')
+            
+            all_categories = self.valid_categories + self.invalid_categories
+            
+            inputs = self.processor(
+                text=all_categories,
+                images=image,
+                return_tensors="pt",
+                padding=True
+            )
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits_per_image
+                probs = logits.softmax(dim=1)[0]
+            
+            max_idx = probs.argmax().item()
+            max_prob = probs[max_idx].item()
+            detected_category = all_categories[max_idx]
+            
+            is_valid = detected_category in self.valid_categories
+            
+            if is_valid and max_prob > threshold:
+                return {
+                    'is_valid': True,
+                    'confidence': max_prob,
+                    'detected_category': detected_category,
+                    'reason': f"Valid device detected: {detected_category}",
+                    'device_type': self._extract_device_type(detected_category)
+                }
+            elif is_valid:
+                return {
+                    'is_valid': False,
+                    'confidence': max_prob,
+                    'detected_category': detected_category,
+                    'reason': f"Device detected but confidence too low ({max_prob:.2f})",
+                    'device_type': None
+                }
+            else:
+                return {
+                    'is_valid': False,
+                    'confidence': max_prob,
+                    'detected_category': detected_category,
+                    'reason': f"Not a device - detected: {detected_category}",
+                    'device_type': None
+                }
+                
+        except Exception as e:
+            return {
+                'is_valid': False,
+                'confidence': 0.0,
+                'detected_category': 'error',
+                'reason': f"Error processing image: {str(e)}",
+                'device_type': None
+            }
+    
+    def _extract_device_type(self, category):
+        """Extract simple device type from category"""
+        if "phone" in category.lower():
+            return "phone"
+        elif "laptop" in category.lower():
+            return "laptop"
+        elif "computer" in category.lower() or "monitor" in category.lower():
+            return "computer"
+        else:
+            return "device"
+
+

price_predictor.py

@@ -0,0 +1,392 @@
+import pandas as pd
+import numpy as np
+import xgboost as xgb
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+from sklearn.preprocessing import LabelEncoder
+import joblib
+import json
+import os
+
+class PricePredictor:
+    
+    def __init__(self):
+        self.model = None
+        self.label_encoders = {}
+        self.feature_columns = []
+        self.is_trained = False
+        
+    def prepare_features(self, df):
+        df = df.copy()
+        categorical_cols = ['brand', 'model', 'condition_grade']
+        
+        for col in categorical_cols:
+            if col not in self.label_encoders:
+                self.label_encoders[col] = LabelEncoder()
+                df[f'{col}_encoded'] = self.label_encoders[col].fit_transform(df[col])
+            else:
+                df[f'{col}_encoded'] = df[col].map(
+                    lambda x: self.label_encoders[col].transform([x])[0] 
+                    if x in self.label_encoders[col].classes_ 
+                    else -1
+                )
+        
+        feature_cols = [
+            'original_price',
+            'age_months',
+            'brand_encoded',
+            'model_encoded',
+            'num_defects',
+            'has_screen_damage',
+            'has_water_damage',
+            'has_battery_issue',
+            'has_physical_damage',
+            'has_critical_defect',
+            'total_severity_score',
+            'avg_severity_score',
+            'total_repair_cost',
+            'condition_score',
+            'condition_grade_encoded'
+        ]
+        
+        self.feature_columns = feature_cols
+        
+        return df[feature_cols]
+    
+    def train(self, csv_path, test_size=0.2, random_state=42):
+      
+      df = pd.read_csv(csv_path)
+      X = self.prepare_features(df)
+      y = df['resale_price']
+    
+      X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
+    
+      self.model = xgb.XGBRegressor(
+          n_estimators=200,
+          max_depth=6,
+          learning_rate=0.1,
+          subsample=0.8,
+          colsample_bytree=0.8,
+          random_state=random_state,
+          objective='reg:squarederror',
+          n_jobs=-1
+          )
+      self.model.fit(
+          X_train, y_train,
+          eval_set=[(X_test, y_test)],
+          verbose=False)
+      y_pred_train = self.model.predict(X_train)
+      y_pred_test = self.model.predict(X_test)
+      train_mae = mean_absolute_error(y_train, y_pred_train)
+      test_mae = mean_absolute_error(y_test, y_pred_test)
+      train_rmse = np.sqrt(mean_squared_error(y_train, y_pred_train))
+      test_rmse = np.sqrt(mean_squared_error(y_test, y_pred_test))
+      train_r2 = r2_score(y_train, y_pred_train)
+      test_r2 = r2_score(y_test, y_pred_test)
+    
+      errors = np.abs(y_test - y_pred_test)
+      within_500 = np.sum(errors <= 500) / len(y_test) * 100
+      within_1000 = np.sum(errors <= 1000) / len(y_test) * 100
+      within_2000 = np.sum(errors <= 2000) / len(y_test) * 100
+    
+      mape = np.mean(np.abs((y_test - y_pred_test) / y_test)) * 100
+    
+      feature_importance = pd.DataFrame({
+          'feature': self.feature_columns,
+          'importance': self.model.feature_importances_
+      }).sort_values('importance', ascending=False)
+    
+      for idx, row in feature_importance.head(10).iterrows():
+          print(f"   {row['feature']:.<30} {row['importance']:.3f}")
+      sample_indices = np.random.choice(len(y_test), min(5, len(y_test)), replace=False)
+      for idx in sample_indices:
+          actual = y_test.iloc[idx]
+          predicted = y_pred_test[idx]
+          error = abs(actual - predicted)
+          print(f"   Actual: ₹{actual:>7,} | Predicted: ₹{predicted:>7,.0f} | Error: ₹{error:>6,.0f}")
+    
+      self.is_trained = True
+    
+      return {
+         'train_mae': train_mae,
+          'test_mae': test_mae,
+          'train_rmse': train_rmse,
+          'test_rmse': test_rmse,
+          'train_r2': train_r2,
+          'test_r2': test_r2,
+          'mape': mape,
+          'within_500': within_500,
+          'within_1000': within_1000,
+          'within_2000': within_2000 }
+        
+        
+    
+    def predict(self, device_info, defects, condition_score):
+       
+        if not self.is_trained:
+            raise ValueError("Model not trained. Call train() first or load_model().")
+        
+        num_defects = len(defects)
+        has_screen_damage = int(any(d.get('category') == 'screen' for d in defects))
+        has_water_damage = int(any(d.get('category') == 'water' for d in defects))
+        has_battery_issue = int(any(d.get('category') == 'battery' for d in defects))
+        has_physical_damage = int(any(d.get('category') == 'physical' for d in defects))
+        has_critical_defect = int(any(d.get('critical', False) for d in defects))
+        
+        total_severity = sum(d.get('severity_score', 0) for d in defects)
+        avg_severity = total_severity / num_defects if num_defects > 0 else 0
+        total_repair_cost = sum(d.get('repair_cost', 0) for d in defects)
+        
+        features = {
+            'original_price': device_info['original_price'],
+            'age_months': device_info['age_months'],
+            'brand': device_info['brand'],
+            'model': device_info['model'],
+            'num_defects': num_defects,
+            'has_screen_damage': has_screen_damage,
+            'has_water_damage': has_water_damage,
+            'has_battery_issue': has_battery_issue,
+            'has_physical_damage': has_physical_damage,
+            'has_critical_defect': has_critical_defect,
+            'total_severity_score': total_severity,
+            'avg_severity_score': avg_severity,
+            'total_repair_cost': total_repair_cost,
+            'condition_score': condition_score,
+            'condition_grade': self._score_to_grade(condition_score)
+        }
+        df = pd.DataFrame([features])
+        X = self.prepare_features(df)
+        predicted_price = self.model.predict(X)[0]
+        confidence_margin = max(500, 0.10 * predicted_price)
+        predicted_price = round(predicted_price / 100) * 100
+        price_min = max(500, round((predicted_price - confidence_margin) / 100) * 100)
+        price_max = round((predicted_price + confidence_margin) / 100) * 100
+        
+        return {
+            'predicted_price': int(predicted_price),
+            'price_range': {
+                'min': int(price_min),
+                'max': int(price_max)
+            },
+            'confidence': 0.85,  # Based on model R² score
+            'depreciation_factors': self._analyze_depreciation(device_info, defects),
+            'feature_contributions': self._get_feature_contributions(X)
+        }
+    
+    def _score_to_grade(self, score):
+        if score >= 9:
+            return 'A'
+        elif score >= 7:
+            return 'B'
+        elif score >= 5:
+            return 'C'
+        elif score >= 3:
+            return 'D'
+        else:
+            return 'F'
+    
+    def _analyze_depreciation(self, device_info, defects):
+        factors = []
+        age_years = device_info['age_months'] / 12
+        if age_years <= 1:
+            age_factor = -15 * age_years
+        else:
+            age_factor = -15 - (10 * (age_years - 1))
+        
+        factors.append({
+            'factor': 'Age Depreciation',
+            'impact': f"{age_factor:.1f}%",
+            'description': f"{device_info['age_months']} months old"
+        })
+        for defect in defects:
+            impact_pct = defect.get('price_impact', 0) * 100
+            factors.append({
+                'factor': defect.get('name', 'Unknown defect'),
+                'impact': f"{impact_pct:.1f}%",
+                'description': f"Repair cost: ₹{defect.get('repair_cost', 0):,}"
+            })
+        
+        return factors
+    
+    def _get_feature_contributions(self, X):
+        feature_importance = dict(zip(self.feature_columns, self.model.feature_importances_))
+        
+        top_features = sorted(feature_importance.items(), key=lambda x: x[1], reverse=True)[:5]
+        
+        contributions = []
+        for feature, importance in top_features:
+            contributions.append({
+                'feature': feature.replace('_', ' ').title(),
+                'importance': f"{importance:.3f}"
+            })
+        
+        return contributions
+    
+    def save_model(self, path='models/price_model.pkl'):
+        if not self.is_trained:
+            raise ValueError("No trained model to save")
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        
+        joblib.dump({
+            'model': self.model,
+            'label_encoders': self.label_encoders,
+            'feature_columns': self.feature_columns
+        }, path)
+    
+    def load_model(self, path='models/price_model.pkl'):
+
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Model file not found: {path}")
+        
+        data = joblib.load(path)
+        self.model = data['model']
+        self.label_encoders = data['label_encoders']
+        self.feature_columns = data['feature_columns']
+        self.is_trained = True
+
+
+def train_model():
+   
+    predictor = PricePredictor()
+    dataset_path = 'data/pricing_dataset.csv'
+    if not os.path.exists(dataset_path):
+        print(f"\ Dataset not found: {dataset_path}")
+        return None
+    metrics = predictor.train(dataset_path)
+    predictor.save_model()
+    return predictor, metrics
+
+def test_predictions():
+    predictor = PricePredictor()
+    predictor.load_model()
+    test_cases = [
+        {
+            'name': 'iPhone 13 - Cracked Screen',
+            'device': {
+                'brand': 'Apple',
+                'model': 'iPhone 13',
+                'original_price': 79900,
+                'age_months': 24
+            },
+            'defects': [
+                {
+                    'id': 'SCR001',
+                    'name': 'Cracked Screen',
+                    'severity_score': 9,
+                    'price_impact': -0.35,
+                    'repair_cost': 4000,
+                    'category': 'screen',
+                    'critical': True
+                }
+            ],
+            'condition_score': 6.0
+        },
+        {
+            'name': 'Samsung S22 - Perfect Condition',
+            'device': {
+                'brand': 'Samsung',
+                'model': 'Galaxy S22',
+                'original_price': 72999,
+                'age_months': 18
+            },
+            'defects': [],
+            'condition_score': 9.5
+        },
+        {
+            'name': 'MacBook Air - Multiple Issues',
+            'device': {
+                'brand': 'Apple',
+                'model': 'MacBook Air M2',
+                'original_price': 119900,
+                'age_months': 12
+            },
+            'defects': [
+                {
+                    'id': 'KEY001',
+                    'name': 'Keyboard Malfunction',
+                    'severity_score': 6,
+                    'price_impact': -0.18,
+                    'repair_cost': 2500,
+                    'category': 'keyboard',
+                    'critical': False
+                },
+                {
+                    'id': 'BAT001',
+                    'name': 'Battery Drain',
+                    'severity_score': 6,
+                    'price_impact': -0.18,
+                    'repair_cost': 2500,
+                    'category': 'battery',
+                    'critical': False
+                }
+            ],
+            'condition_score': 5.5
+        },
+        {
+            'name': 'OnePlus 11 - Water Damage',
+            'device': {
+                'brand': 'OnePlus',
+                'model': 'OnePlus 11',
+                'original_price': 56999,
+                'age_months': 6
+            },
+            'defects': [
+                {
+                    'id': 'WTR001',
+                    'name': 'Water Damage',
+                    'severity_score': 10,
+                    'price_impact': -0.60,
+                    'repair_cost': 8000,
+                    'category': 'water',
+                    'critical': True
+                }
+            ],
+            'condition_score': 2.0
+        }
+    ]
+    
+    for i, test in enumerate(test_cases, 1):
+        
+        device = test['device']
+        print(f"\nDevice: {device['brand']} {device['model']}")
+        print(f"   Original Price: ₹{device['original_price']:,}")
+        print(f"   Age: {device['age_months']} months ({device['age_months']/12:.1f} years)")
+        print(f"   Defects: {len(test['defects'])}")
+        
+        if test['defects']:
+            print(f"\n Detected Defects:")
+            for defect in test['defects']:
+                print(f"   • {defect['name']} (Severity: {defect['severity_score']}/10)")
+        
+        print(f"\n Condition Score: {test['condition_score']}/10")
+        
+        result = predictor.predict(
+            test['device'],
+            test['defects'],
+            test['condition_score']
+        )
+        
+        print(f"\n PREDICTED RESALE PRICE: ₹{result['predicted_price']:,}")
+        print(f"   Range: ₹{result['price_range']['min']:,} - ₹{result['price_range']['max']:,}")
+        print(f"   Confidence: {result['confidence']:.0%}")
+        
+        print(f"\n Price Impact Factors:")
+        for factor in result['depreciation_factors']:
+            print(f"   • {factor['factor']}: {factor['impact']}")
+            print(f"     {factor['description']}")
+        
+        print(f"\n Top Feature Contributions:")
+        for contrib in result['feature_contributions']:
+            print(f"   • {contrib['feature']}: {contrib['importance']}")
+
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1 and sys.argv[1] == 'test':
+        test_predictions()
+    else:
+        predictor, metrics = train_model()
+        if predictor:
+            input("Press Enter to run test predictions...")
+            test_predictions()

requirements.txt

@@ -1,3 +1,13 @@
-altair
-pandas
-streamlit
+torch
+transformers
+Pillow
+xgboost
+scikit-learn
+pandas
+numpy
+streamlit
+huggingface_hub
+matplotlib
+seaborn
+joblib
+fpdf2