Initial commit to HF

.gitignore

@@ -0,0 +1,52 @@
+```
+# Byte-compiled / cache files
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+
+# Virtual environment
+venv/
+.env/
+env/
+.venv/
+
+# VS Code settings
+.vscode/
+
+# Environment / secrets
+*.env
+.env.*
+
+# Distribution / packaging
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Logs
+*.log
+*.out
+*.err
+*.enc
+
+# Testing
+.coverage
+.tox/
+nosetests.xml
+coverage.xml
+htmlcov/
+
+# Jupyter notebooks
+.ipynb_checkpoints
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Uvicorn / FastAPI specific
+*.sqlite3
+# Files
+/thesis_1.pdf

ReadMe.md

@@ -0,0 +1,27 @@
+# Adding to Huggingface
+
+1. Check Current status -> git remote -v
+2. To remove an exisitng HF Repo -> git remote remove hf
+3. To add Files to HF Repo -> git remote add hf https://huggingface.co/spaces/Username/SpaceName
+4. Then commit using -> git push hf main OR git push hf main --force
+
+#### Not permitting to add files to HF, generate new token with write permission
+
+1. Go to https://huggingface.co/settings/tokens
+2. Click **New token**
+3. Name it something like: hf-cli
+4. Set **Role = Write**
+5. Copy the generated token.
+6. logout and login in hf,
+        - huggingface-cli logout (deprecated) / hf auth logout
+        - huggingface-cli login (deprecated) / hf auth login
+        - paste key + enter / $env:HF_TOKEN = "token-no"
+7. confirm identity
+        - huggingface-cli whoami (deprecated)/ hf auth whoami
+8. try to push again
+        - git push hf main --force      
+
+
+git remote set-url origin https://<YOUR_USERNAME>:<YOUR_TOKEN>@huggingface.co/spaces/<YOUR_USERNAME>/<YOUR_REPO>.git
+
+To check root folder in Repo ->  git rev-parse --show-toplevel

hipaathesis.py

@@ -0,0 +1,734 @@
+import PyPDF2
+import re
+from collections import Counter
+import nltk
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+import string
+from datetime import datetime, timedelta
+import json
+import torch
+from transformers import T5ForConditionalGeneration, T5Tokenizer, pipeline, BlipProcessor, BlipForConditionalGeneration
+import warnings
+import fitz  # PyMuPDF
+from PIL import Image, ImageEnhance, ImageFilter
+import io
+import base64
+import os
+import pytesseract
+import hashlib
+import logging
+import getpass
+import tempfile
+import shutil
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+try:
+    import cv2
+    import numpy as np
+    OPENCV_AVAILABLE = True
+except ImportError:
+    print("OpenCV not available. Using PIL for image preprocessing.")
+    OPENCV_AVAILABLE = False
+    import numpy as np
+
+warnings.filterwarnings('ignore')
+
+app = FastAPI(title='AI (PDF→Summary+QnA+Scores)', version='0.2.1')
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+class HIPAALogger:
+    """HIPAA-compliant audit logging system"""
+    
+    def __init__(self, log_file="hipaa_audit.log"):
+        self.log_file = log_file
+        self.setup_logging()
+    
+    def setup_logging(self):
+        """Setup secure audit logging"""
+        logging.basicConfig(
+            filename=self.log_file,
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        self.logger = logging.getLogger('HIPAA_AUDIT')
+    
+    def log_access(self, user_id, action, resource, success=True):
+        """Log access attempts and actions"""
+        status = "SUCCESS" if success else "FAILURE"
+        message = f"USER:{user_id} ACTION:{action} RESOURCE:{resource} STATUS:{status}"
+        self.logger.info(message)
+    
+    def log_phi_processing(self, user_id, document_hash, action):
+        """Log PHI processing events"""
+        message = f"PHI_PROCESSING USER:{user_id} DOC_HASH:{document_hash} ACTION:{action}"
+        self.logger.info(message)
+
+class SecureFileHandler:
+    """Secure file handling with encryption and secure deletion"""
+    
+    def __init__(self, password=None):
+        self.password = password
+        self.key = self._derive_key(password) if password else None
+        self.fernet = Fernet(self.key) if self.key else None
+    
+    def _derive_key(self, password):
+        """Derive encryption key from password"""
+        password_bytes = password.encode()
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=b'hipaa_thesis_analyzer_salt',
+            iterations=100000,
+        )
+        key = base64.urlsafe_b64encode(kdf.derive(password_bytes))
+        return key
+    
+    def encrypt_data(self, data):
+        """Encrypt sensitive data"""
+        if not self.fernet:
+            return data
+        
+        if isinstance(data, str):
+            data = data.encode()
+        return self.fernet.encrypt(data)
+    
+    def decrypt_data(self, encrypted_data):
+        """Decrypt sensitive data"""
+        if not self.fernet:
+            return encrypted_data
+        
+        decrypted = self.fernet.decrypt(encrypted_data)
+        return decrypted.decode()
+    
+    def secure_save(self, data, filepath):
+        """Save data with encryption"""
+        if self.fernet:
+            encrypted_data = self.encrypt_data(json.dumps(data))
+            with open(filepath + '.enc', 'wb') as f:
+                f.write(encrypted_data)
+        else:
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2)
+    
+    def secure_load(self, filepath):
+        """Load encrypted data"""
+        if self.fernet and os.path.exists(filepath + '.enc'):
+            with open(filepath + '.enc', 'rb') as f:
+                encrypted_data = f.read()
+            decrypted_data = self.decrypt_data(encrypted_data)
+            return json.loads(decrypted_data)
+        elif os.path.exists(filepath):
+            with open(filepath, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return None
+    
+    def secure_delete(self, filepath):
+        """Securely delete files by overwriting"""
+        if os.path.exists(filepath):
+            # Overwrite file multiple times before deletion
+            file_size = os.path.getsize(filepath)
+            with open(filepath, 'rb+') as f:
+                for _ in range(3):  # DoD 5220.22-M standard
+                    f.seek(0)
+                    f.write(os.urandom(file_size))
+                    f.flush()
+            os.remove(filepath)
+        
+        # Also check for encrypted version
+        if os.path.exists(filepath + '.enc'):
+            file_size = os.path.getsize(filepath + '.enc')
+            with open(filepath + '.enc', 'rb+') as f:
+                for _ in range(3):
+                    f.seek(0)
+                    f.write(os.urandom(file_size))
+                    f.flush()
+            os.remove(filepath + '.enc')
+
+class HIPAACompliantThesisAnalyzer:
+    """HIPAA-compliant version of the thesis analyzer"""
+    
+    def __init__(self, user_id=None, password=None, session_timeout=30):
+        self.user_id = user_id or getpass.getuser()
+        self.session_timeout = session_timeout  # minutes
+        self.session_start = datetime.now()
+        self.last_activity = datetime.now()
+        
+        # Initialize HIPAA compliance components
+        self.hipaa_logger = HIPAALogger()
+        self.secure_handler = SecureFileHandler(password)
+        
+        # Log session start
+        self.hipaa_logger.log_access(self.user_id, "SESSION_START", "THESIS_ANALYZER")
+        
+        # Initialize base analyzer components
+        self._initialize_analyzer()
+        
+        print(f"HIPAA-Compliant Thesis Analyzer initialized for user: {self.user_id}")
+        print(f"Session timeout: {session_timeout} minutes")
+        print(f"Encryption enabled: {'Yes' if password else 'No'}")
+    
+    def _initialize_analyzer(self):
+        """Initialize the core analyzer components"""
+        try:
+            self.lemmatizer = WordNetLemmatizer()
+            self.stop_words = set(stopwords.words('english'))
+        except LookupError as e:
+            print(f"NLTK resource error: {e}")
+            self._download_nltk_resources()
+            self.lemmatizer = WordNetLemmatizer()
+            self.stop_words = set(stopwords.words('english'))
+
+        self.thesis_text = ""
+        self.sentences = []
+        self.key_terms = []
+        self.extracted_images = []
+        self.image_descriptions = []
+        self.ocr_results = []
+        self.use_ocr = True
+        self.use_blip = True
+
+        # Initialize T5 model
+        print("Loading T5-small model (HIPAA-compliant local processing)...")
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        
+        self.model_name = "t5-small"
+        self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
+        self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
+        self.model.to(self.device)
+
+        # Initialize pipelines
+        self.summarizer = pipeline(
+            "summarization",
+            model=self.model_name,
+            tokenizer=self.model_name,
+            device=0 if torch.cuda.is_available() else -1,
+            max_length=200,
+            min_length=150,
+            do_sample=True,
+            temperature=0.7
+        )
+
+        self.qa_pipeline = pipeline(
+            "text2text-generation",
+            model=self.model_name,
+            tokenizer=self.model_name,
+            device=0 if torch.cuda.is_available() else -1,
+            max_length=512,
+            do_sample=True,
+            temperature=0.7
+        )
+
+        # Initialize BLIP if enabled
+        if self.use_blip:
+            try:
+                self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+                self.blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+                self.blip_model.to(self.device)
+                print("BLIP model loaded for local image analysis")
+            except Exception as e:
+                print(f"BLIP model loading failed: {e}")
+                self.use_blip = False
+
+        # Check OCR availability
+        if self.use_ocr:
+            try:
+                pytesseract.get_tesseract_version()
+                print("Tesseract OCR available for local processing")
+            except Exception as e:
+                print(f"Tesseract OCR not available: {e}")
+                self.use_ocr = False
+    
+    def _download_nltk_resources(self):
+        """Download required NLTK resources"""
+        resources = [
+            ('tokenizers/punkt', 'punkt'),
+            ('tokenizers/punkt_tab', 'punkt_tab'),
+            ('corpora/stopwords', 'stopwords'),
+            ('corpora/wordnet', 'wordnet'),
+            ('corpora/omw-1.4', 'omw-1.4')
+        ]
+
+        for resource_path, resource_name in resources:
+            try:
+                nltk.data.find(resource_path)
+            except LookupError:
+                try:
+                    nltk.download(resource_name, quiet=True)
+                except Exception as e:
+                    print(f"Warning: Failed to download {resource_name}: {e}")
+    
+    def check_session_timeout(self):
+        """Check if session has timed out"""
+        time_since_start = datetime.now() - self.session_start
+        time_since_activity = datetime.now() - self.last_activity
+        
+        if time_since_activity.total_seconds() > (self.session_timeout * 60):
+            self.hipaa_logger.log_access(self.user_id, "SESSION_TIMEOUT", "THESIS_ANALYZER")
+            raise Exception("Session timed out due to inactivity. Please restart for security.")
+        
+        self.last_activity = datetime.now()
+    
+    def calculate_document_hash(self, content):
+        """Calculate secure hash of document content"""
+        return hashlib.sha256(content.encode()).hexdigest()
+    
+    def process_document_securely(self, pdf_path, questions, output_file=None):
+        """Process document with full HIPAA compliance"""
+        self.check_session_timeout()
+        
+        # Calculate document hash for audit trail
+        with open(pdf_path, 'rb') as f:
+            doc_content = f.read()
+            doc_hash = hashlib.sha256(doc_content).hexdigest()[:16]
+        
+        self.hipaa_logger.log_phi_processing(self.user_id, doc_hash, "DOCUMENT_LOAD")
+        
+        try:
+            # Extract text and images
+            text, images = self._extract_text_and_images(pdf_path)
+            self.hipaa_logger.log_phi_processing(self.user_id, doc_hash, "TEXT_EXTRACTION")
+            
+            # Perform OCR if enabled
+            ocr_results = []
+            if self.use_ocr and images:
+                ocr_results = self._perform_secure_ocr(images)
+                self.hipaa_logger.log_phi_processing(self.user_id, doc_hash, "OCR_PROCESSING")
+            
+            # Analyze images if BLIP enabled
+            image_descriptions = []
+            if self.use_blip and images:
+                image_descriptions = self._analyze_images_securely(images)
+                self.hipaa_logger.log_phi_processing(self.user_id, doc_hash, "IMAGE_ANALYSIS")
+            
+            # Combine all text
+            ocr_text = " ".join([result['ocr_text'] for result in ocr_results if result.get('ocr_text')])
+            combined_text = text + " " + ocr_text
+            
+            # Generate analysis
+            sections = self._extract_key_sections(combined_text)
+            key_terms = self._extract_key_terms(combined_text)
+            summary = self._generate_summary_secure(combined_text)
+            question_answers = self._answer_questions_secure(questions, combined_text)
+            
+            self.hipaa_logger.log_phi_processing(self.user_id, doc_hash, "ANALYSIS_COMPLETE")
+            
+            # Compile HIPAA-compliant report
+            report = {
+                "hipaa_compliance": {
+                    "processed_locally": True,
+                    "encrypted_storage": bool(self.secure_handler.fernet),
+                    "audit_logged": True,
+                    "user_id": self.user_id,
+                    "session_id": hashlib.md5(f"{self.user_id}{self.session_start}".encode()).hexdigest()[:8],
+                    "document_hash": doc_hash,
+                    "processing_timestamp": datetime.now().isoformat(),
+                    "no_external_apis": True,
+                    "local_processing_only": True
+                },
+                "document_info": {
+                    "file_path": os.path.basename(pdf_path),  # Only filename for privacy
+                    "analysis_timestamp": datetime.now().isoformat(),
+                    "total_characters": len(text),
+                    "total_images": len(images),
+                    "device_used": str(self.device)
+                },
+                "text_analysis": {
+                    "summary": summary,
+                    "key_terms": key_terms[:15],
+                    "sections_found": list(sections.keys())
+                },
+                "image_analysis": {
+                    "total_images_extracted": len(images),
+                    "images_with_text": len([r for r in ocr_results if r.get('has_text', False)]),
+                    "ocr_available": self.use_ocr,
+                    "blip_available": self.use_blip
+                },
+                "question_responses": question_answers,
+                "statistics": {
+                    "total_text_characters": len(text),
+                    "ocr_text_characters": len(ocr_text),
+                    "questions_processed": len(questions),
+                    "sections_identified": len(sections),
+                    "key_terms_extracted": len(key_terms)
+                }
+            }
+            
+            # Save securely if output file specified
+            if output_file:
+                self.secure_handler.secure_save(report, output_file)
+                self.hipaa_logger.log_access(self.user_id, "REPORT_SAVE", output_file)
+            
+            return report
+            
+        except Exception as e:
+            self.hipaa_logger.log_access(self.user_id, "PROCESSING_ERROR", pdf_path, success=False)
+            raise e
+    
+    def _extract_text_and_images(self, pdf_path):
+        """Securely extract text and images from PDF"""
+        text = ""
+        images = []
+        
+        try:
+            # Use PyMuPDF for comprehensive extraction
+            doc = fitz.open(pdf_path)
+            
+            for page_num in range(len(doc)):
+                page = doc.load_page(page_num)
+                
+                # Extract text
+                page_text = page.get_text()
+                if page_text.strip():
+                    text += page_text + "\n"
+                
+                # Extract images
+                image_list = page.get_images()
+                
+                for img_index, img in enumerate(image_list):
+                    try:
+                        xref = img[0]
+                        pix = fitz.Pixmap(doc, xref)
+                        
+                        if pix.n - pix.alpha < 4:
+                            img_data = pix.tobytes("ppm")
+                            img_pil = Image.open(io.BytesIO(img_data))
+                            
+                            image_info = {
+                                'page': page_num + 1,
+                                'index': img_index,
+                                'image': img_pil,
+                                'size': img_pil.size,
+                                'format': img_pil.format or 'Unknown'
+                            }
+                            images.append(image_info)
+                            
+                        pix = None
+                        
+                    except Exception as e:
+                        print(f"Error extracting image {img_index} from page {page_num + 1}: {e}")
+                        continue
+            
+            doc.close()
+            
+        except Exception as e:
+            print(f"Error in secure extraction: {e}")
+        
+        return text, images
+    
+    def _perform_secure_ocr(self, images):
+        """Perform OCR with audit logging"""
+        ocr_results = []
+        
+        for i, img_info in enumerate(images):
+            try:
+                img = img_info['image']
+                if img.mode != 'RGB':
+                    img = img.convert('RGB')
+                
+                # Preprocess for OCR
+                if OPENCV_AVAILABLE:
+                    img_array = np.array(img)
+                    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+                    denoised = cv2.medianBlur(gray, 3)
+                    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+                    enhanced = clahe.apply(denoised)
+                    _, thresh = cv2.threshold(enhanced, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+                    processed_img = Image.fromarray(thresh)
+                else:
+                    gray = img.convert('L')
+                    enhancer = ImageEnhance.Contrast(gray)
+                    enhanced = enhancer.enhance(2.0)
+                    processed_img = enhanced.filter(ImageFilter.SHARPEN)
+                
+                # Perform OCR locally
+                ocr_text = pytesseract.image_to_string(processed_img, config='--psm 6')
+                
+                ocr_result = {
+                    'page': img_info['page'],
+                    'image_index': img_info['index'],
+                    'ocr_text': ocr_text.strip(),
+                    'has_text': bool(ocr_text.strip()),
+                    'processing_method': 'Local_OCR'
+                }
+                
+                ocr_results.append(ocr_result)
+                
+            except Exception as e:
+                ocr_results.append({
+                    'page': img_info['page'],
+                    'image_index': img_info['index'],
+                    'ocr_text': '',
+                    'has_text': False,
+                    'error': str(e)
+                })
+        
+        return ocr_results
+    
+    def _analyze_images_securely(self, images):
+        """Analyze images locally with BLIP"""
+        if not self.use_blip:
+            return []
+        
+        descriptions = []
+        
+        for img_info in images:
+            try:
+                image = img_info['image']
+                if image.mode != 'RGB':
+                    image = image.convert('RGB')
+                
+                inputs = self.blip_processor(image, return_tensors="pt").to(self.device)
+                
+                with torch.no_grad():
+                    out = self.blip_model.generate(**inputs, max_length=100, num_beams=5)
+                
+                caption = self.blip_processor.decode(out[0], skip_special_tokens=True)
+                
+                description = {
+                    'page': img_info['page'],
+                    'image_index': img_info['index'],
+                    'caption': caption,
+                    'processing_method': 'Local_BLIP'
+                }
+                
+                descriptions.append(description)
+                
+            except Exception as e:
+                descriptions.append({
+                    'page': img_info['page'],
+                    'image_index': img_info['index'],
+                    'caption': 'Analysis failed',
+                    'error': str(e)
+                })
+        
+        return descriptions
+    
+    def _extract_key_sections(self, text):
+        """Extract key sections from text"""
+        sections = {}
+        section_patterns = {
+            'abstract': r'abstract\s*:?\s*(.*?)(?=\n\s*(?:introduction|chapter|acknowledgment|table of contents))',
+            'introduction': r'introduction\s*:?\s*(.*?)(?=\n\s*(?:literature review|methodology|chapter|background))',
+            'methodology': r'(?:methodology|methods)\s*:?\s*(.*?)(?=\n\s*(?:results|findings|analysis|chapter))',
+            'results': r'(?:results|findings)\s*:?\s*(.*?)(?=\n\s*(?:discussion|conclusion|chapter))',
+            'conclusion': r'conclusion\s*:?\s*(.*?)(?=\n\s*(?:references|bibliography|appendix))'
+        }
+
+        for section_name, pattern in section_patterns.items():
+            match = re.search(pattern, text.lower(), re.DOTALL | re.IGNORECASE)
+            if match:
+                sections[section_name] = match.group(1).strip()[:1000]  # Truncate for privacy
+
+        return sections
+    
+    def _extract_key_terms(self, text):
+        """Extract key terms securely"""
+        try:
+            words = re.findall(r'\b[a-zA-Z]+\b', text.lower())
+            words = [
+                self.lemmatizer.lemmatize(word)
+                for word in words
+                if word not in self.stop_words
+                   and len(word) > 3
+                   and word.isalpha()
+            ]
+
+            word_freq = Counter(words)
+            return [term for term, freq in word_freq.most_common(20)]
+
+        except Exception as e:
+            print(f"Error in key term extraction: {e}")
+            return []
+    
+    def _generate_summary_secure(self, text):
+        """Generate summary using local T5 model"""
+        try:
+            clean_text = re.sub(r'\s+', ' ', text).strip()
+            
+            # Chunk text for processing
+            max_length = 1000
+            if len(clean_text) > max_length:
+                clean_text = clean_text[:max_length]
+            
+            summary = self.summarizer(
+                clean_text,
+                max_length=200,
+                min_length=150,
+                do_sample=True,
+                temperature=0.7
+            )
+            
+            return summary[0]['summary_text']
+            
+        except Exception as e:
+            print(f"Error in T5 summarization: {e}")
+            # Fallback to extractive summary
+            sentences = re.split(r'[.!?]+', text)
+            return " ".join(sentences[:3]) + "..."
+    
+    def _answer_questions_secure(self, questions, text):
+        """Answer questions using local T5 model"""
+        answers = {}
+        
+        for question in questions:
+            try:
+                prompt = f"question: {question} context: {text[:1000]}"
+                
+                answer_result = self.qa_pipeline(
+                    prompt,
+                    max_length=200,
+                    min_length=30,
+                    do_sample=True,
+                    temperature=0.7,
+                    num_return_sequences=1
+                )
+                
+                answer = answer_result[0]['generated_text']
+                answer = re.sub(r'^(answer:|Answer:)', '', answer).strip()
+                
+                answers[question] = {
+                    'answer': answer,
+                    'method': 'Local_T5',
+                    'processed_securely': True
+                }
+                
+            except Exception as e:
+                answers[question] = {
+                    'answer': 'Unable to process question securely',
+                    'error': str(e),
+                    'method': 'Error'
+                }
+        
+        return answers
+    
+    def cleanup_session(self):
+        """Clean up session data securely"""
+        self.hipaa_logger.log_access(self.user_id, "SESSION_END", "THESIS_ANALYZER")
+        
+        # Clear sensitive data from memory
+        self.thesis_text = ""
+        self.extracted_images = []
+        self.ocr_results = []
+        self.image_descriptions = []
+        
+        # Clear model cache if needed
+        if hasattr(torch.cuda, 'empty_cache'):
+            torch.cuda.empty_cache()
+        
+        print("Session cleaned up securely")
+
+class AnalyzeReq(BaseModel):
+    storageKey: str  # path to PDF on disk (or adjust to your storage scheme)
+    projectId: Optional[str] = None
+    documentId: Optional[str] = None
+    ocr: bool = False
+    blip: bool = False
+    userId:str
+    password:str
+    useEncryption: bool =False
+
+@app.post('/analyze')
+def analyze(req: AnalyzeReq):
+    """Main function with HIPAA compliance demonstration"""
+    print("HIPAA-COMPLIANT THESIS ANALYZER")
+    print("=" * 50)
+
+    try:
+        # Initialize HIPAA-compliant analyzer
+        analyzer = HIPAACompliantThesisAnalyzer(
+            user_id=req.userId,
+            password=req.password,
+            session_timeout=30
+        )
+        
+        pdf_path = req.storageKey
+
+        # Sample questions
+        questions = [
+            "What is the main objective of the research?",
+            "What methodology was used in the study?",
+            "What are the key findings or results?",
+            "What conclusions did the authors draw?",
+            "What are the limitations of the study?",
+            "What motivated the researchers to conduct this study?",
+            "How does this research relate to existing literature?",
+            "What are the practical implications of the findings?",
+            "What assumptions underlie the research?",
+            "What statistical methods were used to analyze the data?",
+            "How robust are the study’s findings?",
+            "Are there any potential biases in the study design or data collection?",
+            "How do the results compare with previous studies on the same topic?",
+            "What are the potential future applications of this research?",
+            "How could this research be expanded or built upon in future studies?",
+            "What new questions have emerged as a result of this study?"
+        ]
+        
+        # Process document securely
+        print("\nProcessing document with HIPAA compliance...")
+        report = analyzer.process_document_securely(
+            pdf_path=pdf_path,
+            questions=questions,
+            output_file="hipaa_compliant_analysis"
+        )
+        
+        print("\n" + "="*60)
+        print("HIPAA-COMPLIANT ANALYSIS COMPLETE")
+        print("="*60)
+        print(f"✓ Processed locally: {report['hipaa_compliance']['processed_locally']}")
+        print(f"✓ Encrypted storage: {report['hipaa_compliance']['encrypted_storage']}")
+        print(f"✓ Audit logged: {report['hipaa_compliance']['audit_logged']}")
+        print(f"✓ No external APIs: {report['hipaa_compliance']['no_external_apis']}")
+        print(f"✓ Session ID: {report['hipaa_compliance']['session_id']}")
+        
+        # Cleanup
+        analyzer.cleanup_session()
+
+        return report
+    except Exception as e:
+        print(f"Error: {e}")
+        print("Ensure all requirements are installed and Tesseract is available.")
+
+#if __name__ == "__main__":
+    print("""
+HIPAA-COMPLIANT THESIS ANALYZER
+===============================
+
+HIPAA COMPLIANCE FEATURES:
+✓ Local processing only - no external API calls
+✓ Encryption at rest with password protection
+✓ Comprehensive audit logging
+✓ Session timeout and access controls
+✓ Secure file deletion
+✓ PHI processing audit trail
+✓ User authentication
+✓ Data integrity verification
+
+INSTALLATION:
+pip install torch transformers PyPDF2 nltk PyMuPDF pillow pytesseract cryptography
+
+SECURITY FEATURES:
+- All processing happens locally
+- Optional file encryption
+- Secure memory cleanup
+- Audit trail for all operations
+- Session management with timeouts
+- Secure file overwriting for deletion
+
+COMPLIANCE NOTES:
+- This tool provides technical safeguards
+- You must implement administrative and physical safeguards
+- Ensure your workstation meets HIPAA requirements
+- Regular security assessments recommended
+
+""")
+    
+    #main()

requirements.txt

@@ -0,0 +1,12 @@
+cryptography==46.0.1
+fastapi==0.118.0
+fitz==0.0.1.dev2
+nltk==3.9.1
+numpy==2.3.3
+opencv_python==4.12.0.88
+Pillow==11.3.0
+pydantic==2.11.9
+PyPDF2==3.0.1
+pytesseract==0.3.13
+torch==2.8.0
+transformers==4.56.1

thesis.py

@@ -0,0 +1,626 @@
+import PyPDF2
+import re
+from collections import Counter
+import nltk
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+import string
+from datetime import datetime
+import json
+import torch
+from transformers import T5ForConditionalGeneration, T5Tokenizer, pipeline
+import warnings
+
+warnings.filterwarnings('ignore')
+
+
+# Download required NLTK data with improved error handling
+def download_nltk_resources():
+    """Download required NLTK resources with proper error handling"""
+    resources = [
+        ('tokenizers/punkt', 'punkt'),
+        ('tokenizers/punkt_tab', 'punkt_tab'),
+        ('corpora/stopwords', 'stopwords'),
+        ('corpora/wordnet', 'wordnet'),
+        ('corpora/omw-1.4', 'omw-1.4')
+    ]
+
+    for resource_path, resource_name in resources:
+        try:
+            nltk.data.find(resource_path)
+            print(f"✓ {resource_name} already available")
+        except LookupError:
+            print(f"Downloading {resource_name}...")
+            try:
+                nltk.download(resource_name, quiet=False)
+                print(f"✓ {resource_name} downloaded successfully")
+            except Exception as e:
+                print(f"Warning: Failed to download {resource_name}: {e}")
+                continue
+
+
+# Download NLTK resources
+print("Checking and downloading required NLTK resources...")
+download_nltk_resources()
+
+
+class ThesisAnalyzer:
+    def __init__(self):
+        # Initialize NLTK components with error handling
+        try:
+            self.lemmatizer = WordNetLemmatizer()
+            self.stop_words = set(stopwords.words('english'))
+        except LookupError as e:
+            print(f"NLTK resource error: {e}")
+            print("Attempting to download missing resources...")
+            download_nltk_resources()
+            self.lemmatizer = WordNetLemmatizer()
+            self.stop_words = set(stopwords.words('english'))
+
+        self.thesis_text = ""
+        self.sentences = []
+        self.key_terms = []
+
+        # Initialize T5 model and tokenizer
+        print("Loading T5-small model and tokenizer...")
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        print(f"Using device: {self.device}")
+
+        # Load T5 model for text generation
+        self.model_name = "t5-small"
+        self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
+        self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
+        self.model.to(self.device)
+
+        # Initialize summarization pipeline
+        self.summarizer = pipeline(
+            "summarization",
+            model=self.model_name,
+            tokenizer=self.model_name,
+            device=0 if torch.cuda.is_available() else -1,
+            max_length=200,
+            min_length=150,
+            do_sample=True,
+            temperature=0.7
+        )
+
+        # Initialize question answering pipeline
+        self.qa_pipeline = pipeline(
+            "text2text-generation",
+            model=self.model_name,
+            tokenizer=self.model_name,
+            device=0 if torch.cuda.is_available() else -1,
+            max_length=512,
+            do_sample=True,
+            temperature=0.7
+        )
+
+        print("T5 model loaded successfully!")
+
+    def extract_text_from_pdf(self, pdf_path):
+        """Extract text content from PDF file"""
+        try:
+            with open(pdf_path, 'rb') as file:
+                reader = PyPDF2.PdfReader(file)
+                text = ""
+
+                for page_num, page in enumerate(reader.pages):
+                    try:
+                        text += page.extract_text() + "\n"
+                    except Exception as e:
+                        print(f"Error extracting text from page {page_num + 1}: {e}")
+                        continue
+
+                self.thesis_text = text
+                return text
+
+        except Exception as e:
+            print(f"Error reading PDF file: {e}")
+            return None
+
+    def preprocess_text(self, text):
+        """Clean and preprocess the text"""
+        # Remove extra whitespace and normalize
+        text = re.sub(r'\s+', ' ', text)
+        # Remove page numbers and headers/footers (basic cleaning)
+        text = re.sub(r'\n\d+\n', ' ', text)
+        # Remove excessive line breaks
+        text = re.sub(r'\n+', ' ', text)
+        # Remove special characters but keep basic punctuation
+        text = re.sub(r'[^\w\s\.\,\;\:\!\?\-\(\)]', ' ', text)
+
+        return text.strip()
+
+    def chunk_text(self, text, max_chunk_size=1000):
+        """Split text into chunks for processing with T5"""
+        try:
+            sentences = sent_tokenize(text)
+        except LookupError:
+            print("NLTK punkt tokenizer not found. Using basic sentence splitting...")
+            # Fallback to basic sentence splitting
+            sentences = re.split(r'[.!?]+', text)
+            sentences = [s.strip() for s in sentences if s.strip()]
+
+        chunks = []
+        current_chunk = ""
+
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= max_chunk_size:
+                current_chunk += sentence + " "
+            else:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                current_chunk = sentence + " "
+
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+
+        return chunks
+
+    def extract_key_sections(self, text):
+        """Extract key sections from the thesis"""
+        sections = {}
+
+        # Common thesis section patterns
+        section_patterns = {
+            'abstract': r'abstract\s*:?\s*(.*?)(?=\n\s*(?:introduction|chapter|acknowledgment|table of contents))',
+            'introduction': r'introduction\s*:?\s*(.*?)(?=\n\s*(?:literature review|methodology|chapter|background))',
+            'methodology': r'(?:methodology|methods)\s*:?\s*(.*?)(?=\n\s*(?:results|findings|analysis|chapter))',
+            'results': r'(?:results|findings)\s*:?\s*(.*?)(?=\n\s*(?:discussion|conclusion|chapter))',
+            'conclusion': r'conclusion\s*:?\s*(.*?)(?=\n\s*(?:references|bibliography|appendix))'
+        }
+
+        for section_name, pattern in section_patterns.items():
+            match = re.search(pattern, text.lower(), re.DOTALL | re.IGNORECASE)
+            if match:
+                sections[section_name] = match.group(1).strip()[:2000]  # Increased limit
+
+        return sections
+
+    def extract_key_terms(self, text, num_terms=20):
+        """Extract key terms from the thesis using T5"""
+        try:
+            # Traditional key term extraction with error handling
+            try:
+                words = word_tokenize(text.lower())
+            except LookupError:
+                print("NLTK tokenizer not available. Using basic word splitting...")
+                words = re.findall(r'\b[a-zA-Z]+\b', text.lower())
+
+            words = [
+                self.lemmatizer.lemmatize(word)
+                for word in words
+                if word not in self.stop_words
+                   and word not in string.punctuation
+                   and len(word) > 3
+                   and word.isalpha()
+            ]
+
+            word_freq = Counter(words)
+            traditional_terms = [term for term, freq in word_freq.most_common(num_terms)]
+
+            # Enhanced key term extraction using T5
+            try:
+                # Create a prompt for key term extraction
+                prompt = f"summarize: Extract key research terms from this academic text: {text[:1000]}"
+
+                # Use T5 to generate key terms
+                inputs = self.tokenizer.encode(prompt, return_tensors='pt', max_length=512, truncation=True)
+                inputs = inputs.to(self.device)
+
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        inputs,
+                        max_length=100,
+                        num_return_sequences=1,
+                        temperature=0.7,
+                        do_sample=True,
+                        pad_token_id=self.tokenizer.eos_token_id
+                    )
+
+                t5_terms = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+                t5_terms = [term.strip() for term in t5_terms.split(',') if term.strip()]
+
+                # Combine traditional and T5-generated terms
+                self.key_terms = list(set(traditional_terms[:15] + t5_terms[:10]))[:20]
+
+            except Exception as e:
+                print(f"Error in T5 key term extraction: {e}")
+                self.key_terms = traditional_terms
+
+        except Exception as e:
+            print(f"Error in key term extraction: {e}")
+            # Very basic fallback
+            words = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+            word_freq = Counter(words)
+            self.key_terms = [term for term, freq in word_freq.most_common(20)]
+
+        return self.key_terms
+
+    def generate_summary_with_t5(self, text):
+        """Generate summary using T5 model"""
+        try:
+            # Preprocess and chunk the text
+            clean_text = self.preprocess_text(text)
+            chunks = self.chunk_text(clean_text, max_chunk_size=1000)
+
+            print(f"Processing {len(chunks)} text chunks for summarization...")
+
+            # Generate summaries for each chunk
+            chunk_summaries = []
+            for i, chunk in enumerate(chunks[:5]):  # Limit to first 5 chunks
+                try:
+                    print(f"Summarizing chunk {i + 1}/{min(len(chunks), 5)}...")
+
+                    # Use the summarization pipeline
+                    summary = self.summarizer(
+                        chunk,
+                        max_length=150,
+                        min_length=50,
+                        do_sample=True,
+                        temperature=0.7
+                    )
+
+                    chunk_summaries.append(summary[0]['summary_text'])
+
+                except Exception as e:
+                    print(f"Error summarizing chunk {i + 1}: {e}")
+                    continue
+
+            # Combine chunk summaries
+            combined_summary = " ".join(chunk_summaries)
+
+            # Generate final summary
+            if len(combined_summary) > 500:
+                try:
+                    final_summary = self.summarizer(
+                        combined_summary,
+                        max_length=200,
+                        min_length=150,
+                        do_sample=True,
+                        temperature=0.7
+                    )
+                    return final_summary[0]['summary_text']
+                except:
+                    return combined_summary[:800] + "..."
+            else:
+                return combined_summary
+
+        except Exception as e:
+            print(f"Error in T5 summarization: {e}")
+            return self.fallback_summary(text)
+
+    def fallback_summary(self, text):
+        """Fallback summary method if T5 fails"""
+        try:
+            sentences = sent_tokenize(self.preprocess_text(text))
+        except LookupError:
+            # Basic sentence splitting fallback
+            sentences = re.split(r'[.!?]+', self.preprocess_text(text))
+            sentences = [s.strip() for s in sentences if s.strip()]
+
+        key_terms = self.extract_key_terms(text)
+
+        # Score sentences based on key term frequency
+        sentence_scores = {}
+        for sentence in sentences:
+            try:
+                words = word_tokenize(sentence.lower())
+            except LookupError:
+                words = re.findall(r'\b[a-zA-Z]+\b', sentence.lower())
+
+            score = sum(1 for word in words if word in key_terms)
+            sentence_scores[sentence] = score
+
+        # Select top sentences
+        top_sentences = sorted(sentence_scores.items(), key=lambda x: x[1], reverse=True)
+
+        summary_text = ""
+        word_count = 0
+        for sentence, score in top_sentences:
+            if word_count >= 180:
+                break
+            if len(sentence) > 20:
+                summary_text += sentence + " "
+                word_count += len(sentence.split())
+
+        return summary_text.strip()
+
+    def answer_questions_with_t5(self, questions):
+        """Answer questions using T5 model"""
+        if not self.thesis_text:
+            return "No thesis text loaded. Please extract text first."
+
+        answers = {}
+        clean_text = self.preprocess_text(self.thesis_text)
+
+        # Limit text length for processing
+        text_chunks = self.chunk_text(clean_text, max_chunk_size=1500)
+
+        for question in questions:
+            print(f"Processing question: {question[:50]}...")
+
+            try:
+                # Find the most relevant chunk for this question
+                best_chunk = ""
+                best_score = 0
+
+                try:
+                    question_words = set(word_tokenize(question.lower()))
+                except LookupError:
+                    question_words = set(re.findall(r'\b[a-zA-Z]+\b', question.lower()))
+
+                for chunk in text_chunks[:3]:  # Process first 3 chunks
+                    try:
+                        chunk_words = set(word_tokenize(chunk.lower()))
+                    except LookupError:
+                        chunk_words = set(re.findall(r'\b[a-zA-Z]+\b', chunk.lower()))
+
+                    overlap = len(question_words.intersection(chunk_words))
+                    if overlap > best_score:
+                        best_score = overlap
+                        best_chunk = chunk
+
+                # Create T5 prompt for question answering
+                prompt = f"question: {question} context: {best_chunk[:1000]}"
+
+                # Generate answer using T5
+                answer_result = self.qa_pipeline(
+                    prompt,
+                    max_length=200,
+                    min_length=30,
+                    do_sample=True,
+                    temperature=0.7,
+                    num_return_sequences=1
+                )
+
+                answer = answer_result[0]['generated_text']
+
+                # Clean up the answer
+                answer = re.sub(r'^(answer:|Answer:)', '', answer).strip()
+
+                answers[question] = {
+                    'answer': answer,
+                    'confidence': min(best_score / len(question_words), 1.0) if question_words else 0.5,
+                    'method': 'T5-generated',
+                    'chunk_used': len(best_chunk) > 0
+                }
+
+            except Exception as e:
+                print(f"Error processing question with T5: {e}")
+                # Fallback to traditional method
+                answers[question] = self.fallback_answer(question, clean_text)
+
+        return answers
+
+    def fallback_answer(self, question, text):
+        """Fallback answer method if T5 fails"""
+        try:
+            sentences = sent_tokenize(text)
+        except LookupError:
+            sentences = re.split(r'[.!?]+', text)
+            sentences = [s.strip() for s in sentences if s.strip()]
+
+        try:
+            question_words = [
+                word.lower() for word in word_tokenize(question)
+                if word.lower() not in self.stop_words and word.isalpha()
+            ]
+        except LookupError:
+            question_words = [
+                word.lower() for word in re.findall(r'\b[a-zA-Z]+\b', question)
+                if word.lower() not in self.stop_words and len(word) > 2
+            ]
+
+        relevant_sentences = []
+        for sentence in sentences:
+            sentence_lower = sentence.lower()
+            relevance_score = sum(1 for word in question_words if word in sentence_lower)
+
+            if relevance_score > 0:
+                relevant_sentences.append((sentence, relevance_score))
+
+        relevant_sentences.sort(key=lambda x: x[1], reverse=True)
+
+        if relevant_sentences:
+            answer_text = " ".join([s[0].strip() for s in relevant_sentences[:2]])
+            return {
+                'answer': answer_text,
+                'confidence': min(relevant_sentences[0][1] / len(question_words), 1.0),
+                'method': 'Traditional extraction',
+                'chunk_used': True
+            }
+        else:
+            return {
+                'answer': "No relevant information found in the thesis text.",
+                'confidence': 0.0,
+                'method': 'No match',
+                'chunk_used': False
+            }
+
+    def generate_report(self, pdf_path, questions, output_file=None):
+        """Generate a complete analysis report using T5"""
+        print("Starting advanced thesis analysis with T5-small...")
+
+        # Extract text from PDF
+        text = self.extract_text_from_pdf(pdf_path)
+        if not text:
+            return "Failed to extract text from PDF."
+
+        print(f"Extracted {len(text)} characters from PDF.")
+
+        # Extract key sections and terms
+        print("Extracting key sections and terms...")
+        sections = self.extract_key_sections(text)
+        key_terms = self.extract_key_terms(text)
+
+        # Generate summary using T5
+        print("Generating T5-powered summary...")
+        summary = self.generate_summary_with_t5(text)
+
+        # Answer questions using T5
+        print("Answering questions with T5...")
+        question_answers = self.answer_questions_with_t5(questions)
+
+        # Compile report
+        report = f"""
+{'=' * 70}
+ADVANCED THESIS ANALYSIS REPORT (T5-Small Enhanced)
+{'=' * 70}
+
+Generated on: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+Document: {pdf_path}
+Model: T5-Small (Hugging Face Transformers)
+Device: {str(self.device)}
+
+{'=' * 70}
+THESIS SUMMARY (AI-Generated)
+{'=' * 70}
+
+{summary}
+
+Key Terms Identified: {', '.join(key_terms[:15])}
+
+Sections Found: {', '.join(sections.keys())}
+
+{'=' * 70}
+QUESTION RESPONSES (T5-Enhanced)
+{'=' * 70}
+
+"""
+
+        for i, (question, response) in enumerate(question_answers.items(), 1):
+            report += f"""
+Question {i}: {question}
+
+Answer: {response['answer']}
+
+Confidence Level: {response['confidence']:.2f}
+Generation Method: {response['method']}
+Context Used: {'Yes' if response['chunk_used'] else 'No'}
+
+{'-' * 50}
+"""
+
+        report += f"""
+
+{'=' * 70}
+ANALYSIS STATISTICS
+{'=' * 70}
+
+Total Characters: {len(text):,}
+Total Sentences: {len(sent_tokenize(text)):,}
+Key Terms Identified: {len(key_terms)}
+Questions Processed: {len(questions)}
+Sections Identified: {len(sections)}
+Model Performance: T5-Small with {str(self.device).upper()} acceleration
+
+{'=' * 70}
+TECHNICAL DETAILS
+{'=' * 70}
+
+Model: {self.model_name}
+Tokenizer: T5Tokenizer
+Framework: Hugging Face Transformers
+PyTorch Device: {str(self.device)}
+Summarization Pipeline: Enabled
+Question Answering: T5 Text-to-Text Generation
+
+{'=' * 70}
+"""
+
+        # Save to file if specified
+        if output_file:
+            try:
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write(report)
+                print(f"Report saved to: {output_file}")
+            except Exception as e:
+                print(f"Error saving report: {e}")
+
+        return report
+
+
+def main():
+    """Main function to demonstrate usage"""
+    try:
+        analyzer = ThesisAnalyzer()
+
+        # Example usage
+        pdf_path = "thesis.pdf"  # Replace with your PDF path
+
+        # Enhanced questions for T5 processing
+        sample_questions = [
+            "What is the main objective of the research?",
+            "What methodology was used in the study?",
+            "What are the key findings or results?",
+            "What conclusions did the authors draw?",
+            "What are the limitations of the study?",
+            "What motivated the researchers to conduct this study?",
+            "How does this research relate to existing literature?",
+            "What are the practical implications of the findings?",
+            "What assumptions underlie the research?",
+            "What statistical methods were used to analyze the data?",
+            "How robust are the study’s findings?",
+            "Are there any potential biases in the study design or data collection?",
+            "How do the results compare with previous studies on the same topic?",
+            "What are the potential future applications of this research?",
+            "How could this research be expanded or built upon in future studies?",
+            "What new questions have emerged as a result of this study?"
+        ]
+
+        # Generate report
+        report = analyzer.generate_report(
+            pdf_path=pdf_path,
+            questions=sample_questions,
+            output_file="t5_thesis_analysis_report.txt"
+        )
+
+        print("\nT5-ENHANCED ANALYSIS COMPLETE!")
+        print("\nSample of generated report:")
+        print("=" * 60)
+        print(report[:1500] + "...")
+
+    except FileNotFoundError:
+        print(f"PDF file '{pdf_path}' not found. Please check the file path.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        print("Make sure you have installed the required packages:")
+        print("pip install torch transformers PyPDF2 nltk")
+
+
+if __name__ == "__main__":
+    # Instructions for usage
+    print("""
+T5-ENHANCED THESIS ANALYZER - SETUP INSTRUCTIONS
+=================================================
+
+1. Install required packages:
+   pip install torch transformers PyPDF2 nltk
+
+2. First run will download T5-small model (~240MB)
+
+3. Update the pdf_path variable with your thesis file path
+
+4. The program will use GPU if available, CPU otherwise
+
+5. Run the script to generate AI-enhanced analysis report
+
+NEW FEATURES WITH T5-SMALL:
+- Advanced text summarization using transformer models
+- Intelligent question answering with context understanding
+- Better key term extraction
+- Enhanced natural language generation
+- Confidence scoring for answers
+
+The program will:
+- Load T5-small model from Hugging Face
+- Extract and preprocess text from PDF
+- Generate AI-powered summaries (150-200 words)
+- Answer questions using advanced NLP
+- Save detailed report with technical metrics
+
+""")
+
+    main()