Create app.py

app.py

@@ -0,0 +1,232 @@
+import streamlit as st
+from google import genai
+from PIL import Image
+import os
+from typing import Tuple, Optional
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(_name_)
+
+class CTScanAnalyzer:
+    def _init_(self, api_key: str):
+        """Initialize the CT Scan Analyzer with API key and configuration."""
+        self.client = genai.Client(api_key=api_key)
+        self.setup_page_config()
+        self.apply_custom_styles()
+    
+    @staticmethod
+    def setup_page_config() -> None:
+        """Configure Streamlit page settings."""
+        st.set_page_config(
+            page_title="CT Scan Analytics",
+            page_icon="🏥",
+            layout="wide"
+        )
+    
+    @staticmethod
+    def apply_custom_styles() -> None:
+        """Apply custom CSS styles with improved dark theme."""
+        st.markdown("""
+            <style>
+            :root {
+                --background-color: #1a1a1a;
+                --secondary-bg: #2d2d2d;
+                --text-color: #e0e0e0;
+                --accent-color: #4CAF50;
+                --border-color: #404040;
+                --hover-color: #45a049;
+            }
+
+            .main { background-color: var(--background-color); }
+            .stApp { background-color: var(--background-color); }
+            
+            .stButton>button {
+                width: 100%;
+                background-color: var(--accent-color);
+                color: white;
+                padding: 0.75rem;
+                border-radius: 6px;
+                border: none;
+                font-weight: 600;
+                transition: background-color 0.3s ease;
+            }
+            .stButton>button:hover {
+                background-color: var(--hover-color);
+            }
+            
+            .report-container {
+                background-color: var(--secondary-bg);
+                padding: 2rem;
+                border-radius: 12px;
+                margin: 1rem 0;
+                border: 1px solid var(--border-color);
+                box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            }
+            </style>
+        """, unsafe_allow_html=True)
+
+    def analyze_image(self, img: Image.Image) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Analyze CT scan image using Gemini AI.
+        Returns tuple of (doctor_analysis, patient_analysis).
+        """
+        try:
+            prompts = {
+                "doctor": """
+Provide a structured analysis of this CT scan for medical professionals without including any introductory or acknowledgment phrases. 
+Follow the structure below:
+
+1. Initial Observations
+   - Key anatomical structures
+   - Tissue density patterns
+   - Contrast enhancement patterns
+
+2. Detailed Findings
+   - Primary abnormalities
+   - Secondary findings
+   - Measurements and dimensions
+
+3. Clinical Correlation
+   - Differential diagnoses
+   - Recommended additional imaging
+   - Suggested clinical correlation
+
+4. Technical Assessment
+   - Image quality
+   - Positioning
+   - Artifacts if present
+                """,
+                
+                "patient": """
+Explain this CT scan in clear, simple terms for a patient without including any introductory or acknowledgment phrases. 
+Follow the structure below:
+
+1. What We're Looking At
+   - The part of the body shown
+   - What appears normal
+   - Any notable findings
+
+2. Next Steps
+   - What these findings might mean
+   - Questions to ask your doctor
+   - Any follow-up that might be needed
+
+Remember to use everyday language and avoid medical terminology.
+                """
+            }
+            
+            responses = {}
+            for audience, prompt in prompts.items():
+                response = self.client.models.generate_content(
+                    model="gemini-2.0-flash",
+                    contents=[prompt, img]
+                )
+                responses[audience] = response.text if hasattr(response, 'text') else None
+                
+            return responses["doctor"], responses["patient"]
+            
+        except Exception as e:
+            logger.error(f"Analysis failed: {str(e)}")
+            return None, None
+
+    def run(self):
+        """Run the Streamlit application."""
+        st.title("🏥 CT Scan Analytics")
+        st.markdown("""
+            Advanced CT scan analysis powered by AI. Upload your scan for instant
+            insights tailored for both medical professionals and patients.
+        """)
+
+        col1, col2 = st.columns([1, 1.5])
+
+        with col1:
+            uploaded_file = self.handle_file_upload()
+
+        with col2:
+            if uploaded_file:
+                self.process_analysis(uploaded_file)
+            else:
+                self.show_instructions()
+
+        self.show_footer()
+
+    def handle_file_upload(self) -> Optional[object]:
+        """Handle file upload and display image preview."""
+        uploaded_file = st.file_uploader(
+            "Upload CT Scan Image",
+            type=["png", "jpg", "jpeg"],
+            help="Supported formats: PNG, JPG, JPEG"
+        )
+        
+        if uploaded_file:
+            img = Image.open(uploaded_file)
+            st.image(img, caption="Uploaded CT Scan", use_column_width=True)
+            
+            with st.expander("Image Details"):
+                st.write(f"*Filename:* {uploaded_file.name}")
+                st.write(f"*Size:* {uploaded_file.size/1024:.2f} KB")
+                st.write(f"*Format:* {img.format}")
+                st.write(f"*Dimensions:* {img.size[0]}x{img.size[1]} pixels")
+                
+        return uploaded_file
+
+    def process_analysis(self, uploaded_file: object) -> None:
+        """Process the uploaded image and display analysis."""
+        if st.button("🔍 Analyze CT Scan", key="analyze_button"):
+            with st.spinner("Analyzing CT scan..."):
+                img = Image.open(uploaded_file)
+                doctor_analysis, patient_analysis = self.analyze_image(img)
+                
+                if doctor_analysis and patient_analysis:
+                    tab1, tab2 = st.tabs(["📋 Medical Report", "👥 Patient Summary"])
+                    
+                    with tab1:
+                        st.markdown("### Medical Professional's Report")
+                        st.markdown(f"<div class='report-container'>{doctor_analysis}</div>",
+                                  unsafe_allow_html=True)
+                    
+                    with tab2:
+                        st.markdown("### Patient-Friendly Explanation")
+                        st.markdown(f"<div class='report-container'>{patient_analysis}</div>",
+                                  unsafe_allow_html=True)
+                else:
+                    st.error("Analysis failed. Please try again.")
+
+    @staticmethod
+    def show_instructions() -> None:
+        """Display instructions when no image is uploaded."""
+        st.info("👈 Upload a CT scan image to begin analysis")
+        
+        with st.expander("ℹ How it works"):
+            st.markdown("""
+                1. *Upload* your CT scan image
+                2. Click *Analyze*
+                3. Receive two detailed reports:
+                   - Technical analysis for medical professionals
+                   - Patient-friendly explanation
+            """)
+
+    @staticmethod
+    def show_footer() -> None:
+        st.markdown("---")
+        st.markdown(
+            """
+            <div style='text-align: center'>
+                <p style='color: #888888; font-size: 0.8em;'>
+                    UNDER DEVELOPMENT
+                </p>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+if _name_ == "_main_":
+    # Get API key from environment variable
+    api_key = "AIzaSyCp9j5OGZb5hlykMIAJhbDII3IHYJWCrnQ"
+    if not api_key:
+        st.error("Please set GEMINI_API_KEY environment variable")
+    else:
+        analyzer = CTScanAnalyzer(api_key)
+        analyzer.run()