Update LICENSE

accidently changed licence to app.py code

LICENSE

@@ -1,509 +1,21 @@
-#!/usr/bin/env python3
-"""
-Smart Paraphraser - Fixed AI Model Version
-Focus: Main AI model working properly with all syntax errors fixed
-"""
-
-import streamlit as st
-import re
-import random
-import io
-import html
-
-# Set page config
-st.set_page_config(page_title="Smart Paraphraser", layout="wide", page_icon="🔄")
-
-# Imports with fallbacks
-try:
-    import docx
-    DOCX_AVAILABLE = True
-except:
-    DOCX_AVAILABLE = False
-
-try:
-    import fitz  # PyMuPDF
-    PDF_AVAILABLE = True
-except:
-    PDF_AVAILABLE = False
-
-# Fixed AI model loading
-try:
-    from transformers import pipeline
-    import torch
-    
-    @st.cache_resource
-    def load_paraphraser():
-        try:
-            # Use a more reliable paraphrasing model
-            paraphraser = pipeline(
-                "text2text-generation",
-                model="Vamsi/T5_Paraphrase_Paws",  # More reliable than pegasus
-                device=-1,  # CPU
-                max_length=512,
-                truncation=True
-            )
-            
-            # Test the model with a simple sentence
-            test_result = paraphraser("This is a test sentence.")
-            if test_result and len(test_result) > 0:
-                st.success("✅ AI Model loaded successfully!")
-                return paraphraser
-            else:
-                st.error("❌ Model test failed")
-                return None
-                
-        except Exception as e:
-            st.error(f"❌ Failed to load AI model: {e}")
-            return None
-    
-    TRANSFORMERS_AVAILABLE = True
-except Exception as e:
-    st.error(f"❌ Transformers not available: {e}")
-    TRANSFORMERS_AVAILABLE = False
-
-# Session state
-if "input_text" not in st.session_state:
-    st.session_state.input_text = ""
-if "output_text" not in st.session_state:
-    st.session_state.output_text = ""
-
-class SmartParaphraser:
-    def __init__(self):
-        # Load the AI model
-        if TRANSFORMERS_AVAILABLE:
-            self.model = load_paraphraser()
-        else:
-            self.model = None
-        
-        # Basic synonyms for fallback only
-        self.synonyms = {
-            "dont": ["do not", "avoid", "refrain from", "never"],
-            "don't": ["do not", "avoid", "refrain from", "never"],
-            "touch": ["handle", "contact", "reach", "access", "operate"],
-            "this": ["that", "the", "such"],
-            "switch": ["button", "control", "lever", "mechanism"],
-            "will": ["would", "shall", "might", "could"],
-            "should": ["must", "ought to", "need to", "have to"],
-            "not": ["never", "avoid", "refrain from"],
-            "be": ["get", "become", "remain"],
-            "stay": ["keep", "remain", "avoid going near"],
-            "away": ["distant", "far", "clear"],
-            "from": ["of", "away from"],
-            "that": ["this", "the", "such"],
-            "no": ["absolutely no", "zero", "not a single"],
-            "one": ["person", "individual", "anyone"],
-            "put": ["place", "set", "position", "insert"],
-            "into": ["inside", "within", "in"],
-            "box": ["container", "case", "compartment"],
-            "after": ["following", "subsequent to", "once"],
-            "next": ["following", "subsequent", "upcoming"],
-            "possible": ["potential", "feasible", "available"],
-            "version": ["variation", "alternative", "option"],
-            "button": ["control", "switch", "key"],
-            "press": ["click", "push", "activate"],
-            "new": ["fresh", "different", "alternative"],
-            "keep": ["maintain", "preserve", "retain"],
-            "just": ["only", "simply", "merely"],
-            "text": ["content", "writing", "material"],
-            "word": ["term", "expression", "phrase"],
-            "sentence": ["statement", "phrase", "expression"],
-            "change": ["modify", "alter", "transform"],
-            "without": ["avoiding", "excluding", "minus"],
-            "meaning": ["sense", "significance", "interpretation"],
-            "same": ["identical", "similar", "equivalent"],
-            "different": ["distinct", "alternative", "varied"],
-            "simple": ["basic", "easy", "straightforward"],
-            "works": ["functions", "operates", "performs"],
-            "focus": ["concentrate", "emphasize", "prioritize"],
-            "each": ["every", "individual", "all"],
-            "even": ["including", "also", "additionally"],
-            "if": ["when", "in case", "should"],
-            "single": ["individual", "one", "sole"],
-            "also": ["additionally", "furthermore", "too"],
-            "changed": ["modified", "altered", "transformed"],
-            "remove": ["eliminate", "delete", "take away"],
-            "clear": ["erase", "delete", "empty"],
-            "all": ["everything", "complete", "entire"],
-            "both": ["each", "either", "the two"],
-            "input": ["entry", "data", "content"],
-            "output": ["result", "response", "outcome"],
-            "for": ["to accommodate", "intended for"],
-        }
-        
-        # Fixed sentence transformation patterns
-        self.transformations = [
-            # Properly handle contractions
-            (r"don\'t\s+(\w+)", r"avoid \1ing"),
-            (r"do not\s+(\w+)", r"refrain from \1ing"),
-            (r"will not", "shall not"),
-            (r"won\'t", "will not"),
-            (r"can\'t", "cannot"),
-            (r"shouldn\'t", "should not"),
-            # Fixed passive voice alternatives
-            (r"(\w+)\s+should\s+not\s+be\s+(\w+)", r"avoid \2ing \1"),
-            (r"(\w+)\s+must\s+not\s+be\s+(\w+)", r"never \2 \1"),
-            # Fixed command alternatives
-            (r"stay\s+away\s+from", "avoid approaching"),
-            (r"keep\s+away\s+from", "maintain distance from"),
-        ]
-    
-    def paraphrase_with_ai(self, text):
-        """Use AI model for paraphrasing - FIXED VERSION"""
-        if not self.model:
-            return None
-        
-        try:
-            # Clean and prepare input
-            text = text.strip()
-            if len(text) < 3:
-                return text
-            
-            # Handle single words properly
-            if len(text.split()) == 1:
-                # For single words, create a simple sentence context
-                input_text = f"paraphrase: {text}"
-            else:
-                # For sentences, add paraphrase prefix
-                input_text = f"paraphrase: {text}"
-            
-            # Generate paraphrase with better parameters
-            result = self.model(
-                input_text,
-                max_length=min(200, len(text.split()) * 3),
-                min_length=max(3, len(text.split())),
-                num_return_sequences=1,
-                temperature=0.9,
-                do_sample=True,
-                top_p=0.95,
-                repetition_penalty=1.2,
-                length_penalty=1.0,
-                early_stopping=True
-            )
-            
-            if result and len(result) > 0 and 'generated_text' in result[0]:
-                paraphrased = result[0]['generated_text'].strip()
-                
-                # Clean up the output
-                paraphrased = re.sub(r'^paraphrase:\s*', '', paraphrased, flags=re.IGNORECASE)
-                paraphrased = paraphrased.strip()
-                
-                # Quality check - simplified
-                if (paraphrased and 
-                    paraphrased.lower() != text.lower() and
-                    len(paraphrased) >= 2):
-                    return paraphrased
-            
-            return None
-            
-        except Exception as e:
-            st.warning(f"AI processing error: {e}")
-            return None
-    
-    def fallback_paraphrase(self, text):
-        """Rule-based paraphrasing as fallback"""
-        # Apply transformations first
-        result = text
-        for pattern, replacement in self.transformations:
-            result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
-        
-        # Synonym replacement - ALWAYS replace when available
-        words = result.split()
-        new_words = []
-        
-        for word in words:
-            clean_word = re.sub(r'[^\w]', '', word.lower())
-            punct = re.findall(r'[^\w]', word)
-            
-            # Always replace if synonym exists
-            if clean_word in self.synonyms:
-                synonym = random.choice(self.synonyms[clean_word])
-                
-                # Preserve capitalization
-                if word and word[0].isupper():
-                    synonym = synonym.capitalize()
-                
-                new_words.append(synonym + ''.join(punct))
-            else:
-                new_words.append(word)
-        
-        result = ' '.join(new_words)
-        
-        # Additional sentence restructuring
-        if len(result.split()) > 3:
-            # Move "not" placement
-            result = re.sub(r"(\w+)\s+not\s+(\w+)", r"not \1 \2", result)
-            
-            # Reorder simple sentences with "and"
-            if " and " in result:
-                parts = result.split(" and ")
-                if len(parts) == 2 and random.random() < 0.5:
-                    result = f"{parts[1].strip()} and {parts[0].strip()}"
-        
-        return result
-    
-    def paraphrase(self, text):
-        """Main paraphrasing function - AI FIRST"""
-        if not text or not text.strip():
-            return text
-        
-        original = text.strip()
-        
-        # Try AI model first - this is the main focus
-        if self.model:
-            ai_result = self.paraphrase_with_ai(original)
-            if ai_result and ai_result.lower() != original.lower():
-                return ai_result
-            else:
-                st.warning("⚠️ AI model didn't produce good result, using fallback")
-        else:
-            st.error("❌ AI model not available, using fallback")
-        
-        # Fallback to rule-based only if AI fails
-        rule_result = self.fallback_paraphrase(original)
-        
-        # Ensure some change happened
-        if rule_result.lower() == original.lower():
-            # Force minimal change
-            if "this" in rule_result.lower():
-                rule_result = rule_result.replace("this", "that", 1)
-            elif "that" in rule_result.lower():
-                rule_result = rule_result.replace("that", "this", 1)
-            elif original.endswith("."):
-                rule_result = rule_result.rstrip(".") + "!"
-            else:
-                # Try first available synonym
-                words = rule_result.split()
-                for i, word in enumerate(words):
-                    clean = word.lower().strip('.,!?')
-                    if clean in self.synonyms:
-                        words[i] = random.choice(self.synonyms[clean])
-                        if word and word[0].isupper():
-                            words[i] = words[i].capitalize()
-                        break
-                rule_result = ' '.join(words)
-        
-        return rule_result
-
-def highlight_changes(original, paraphrased):
-    """Highlight changed words with underline"""
-    if not original or not paraphrased:
-        return html.escape(paraphrased)
-    
-    orig_words = original.lower().split()
-    para_words = paraphrased.split()
-    
-    result = []
-    
-    # Simple word comparison
-    for i, word in enumerate(para_words):
-        word_clean = word.lower().strip('.,!?')
-        
-        # Check if this word was in original
-        if i < len(orig_words):
-            orig_clean = orig_words[i].strip('.,!?')
-            if word_clean != orig_clean:
-                result.append(f'<u style="text-decoration: underline; text-decoration-color: #2E86AB; text-decoration-thickness: 2px;">{html.escape(word)}</u>')
-            else:
-                result.append(html.escape(word))
-        else:
-            result.append(f'<u style="text-decoration: underline; text-decoration-color: #2E86AB; text-decoration-thickness: 2px;">{html.escape(word)}</u>')
-    
-    return ' '.join(result)
-
-def extract_text_from_file(uploaded_file):
-    """Extract text from files"""
-    try:
-        if uploaded_file.name.endswith('.txt'):
-            return str(uploaded_file.read(), encoding='utf-8')
-        
-        elif uploaded_file.name.endswith('.docx') and DOCX_AVAILABLE:
-            doc = docx.Document(io.BytesIO(uploaded_file.read()))
-            return '\n\n'.join([p.text for p in doc.paragraphs if p.text.strip()])
-        
-        elif uploaded_file.name.endswith('.pdf') and PDF_AVAILABLE:
-            pdf_doc = fitz.open(stream=uploaded_file.read(), filetype="pdf")
-            text = ""
-            for page in pdf_doc:
-                text += page.get_text() + "\n\n"
-            return text
-        
-        else:
-            st.error("Unsupported file type")
-            return ""
-    
-    except Exception as e:
-        st.error(f"Error reading file: {e}")
-        return ""
-
-def create_download_file(text):
-    """Create downloadable file"""
-    return text.encode('utf-8'), "text/plain"
-
-# Main App
-def main():
-    # CSS styling
-    st.markdown("""
-    <style>
-    .main-header {
-        font-size: 2.5rem;
-        color: #2E86AB;
-        text-align: center;
-        margin-bottom: 1rem;
-        font-weight: bold;
-    }
-    .subtitle {
-        text-align: center;
-        color: #666;
-        margin-bottom: 2rem;
-        font-style: italic;
-    }
-    .highlight-box {
-        padding: 1rem;
-        border: 1px solid #ddd;
-        border-radius: 8px;
-        background-color: #fafafa;
-        line-height: 1.8;
-        font-size: 16px;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-    
-    # Header
-    st.markdown('<div class="main-header">🔄 Smart Paraphraser</div>', unsafe_allow_html=True)
-    st.markdown('<div class="subtitle">AI-Powered Text Transformation</div>', unsafe_allow_html=True)
-    
-    # Initialize paraphraser
-    paraphraser = SmartParaphraser()
-    
-    # Show model status
-    if paraphraser.model:
-        st.success("🤖 AI Model: Ready")
-    else:
-        st.error("❌ AI Model: Not Available")
-    
-    # Main layout
-    col1, col2 = st.columns([1, 1])
-    
-    with col1:
-        st.subheader("📝 Input")
-        
-        # File upload option
-        uploaded_file = st.file_uploader("Upload file (optional):", type=['txt', 'docx', 'pdf'])
-        
-        if uploaded_file:
-            with st.spinner("Reading file..."):
-                file_text = extract_text_from_file(uploaded_file)
-                if file_text:
-                    st.session_state.input_text = file_text
-                    st.success(f"Loaded {len(file_text.split())} words")
-        
-        # Text input
-        input_text = st.text_area(
-            "Enter text to paraphrase:",
-            value=st.session_state.input_text,
-            height=300,
-            placeholder="Example: Don't touch this switch\n\nThe AI will transform this into different variations like:\n• Avoid handling that button\n• Stay away from the control",
-            key="input_area"
-        )
-        
-        # Update session state
-        st.session_state.input_text = input_text
-    
-    with col2:
-        st.subheader("✨ Output")
-        
-        # Action buttons
-        col_btn1, col_btn2, col_btn3 = st.columns([2, 2, 1])
-        
-        with col_btn1:
-            if st.button("🔄 Paraphrase", type="primary", use_container_width=True):
-                if st.session_state.input_text.strip():
-                    with st.spinner("AI processing..."):
-                        result = paraphraser.paraphrase(st.session_state.input_text)
-                        st.session_state.output_text = result
-                    st.success("✅ Paraphrased!")
-                else:
-                    st.error("Please enter some text first!")
-        
-        with col_btn2:
-            if st.button("⬅️ Output to Input", use_container_width=True):
-                if st.session_state.output_text:
-                    st.session_state.input_text = st.session_state.output_text
-                    st.session_state.output_text = ""
-                    st.rerun()
-                else:
-                    st.warning("No output to transfer!")
-        
-        with col_btn3:
-            if st.button("🗑️ Clear", use_container_width=True):
-                st.session_state.input_text = ""
-                st.session_state.output_text = ""
-                st.rerun()
-        
-        # Output display
-        if st.session_state.output_text:
-            # Show highlighted changes
-            if st.session_state.input_text and st.session_state.output_text != st.session_state.input_text:
-                st.markdown("**Changes underlined:**")
-                highlighted = highlight_changes(st.session_state.input_text, st.session_state.output_text)
-                st.markdown(f'<div class="highlight-box">{highlighted}</div>', unsafe_allow_html=True)
-            
-            # Plain output
-            st.text_area(
-                "Paraphrased text:",
-                value=st.session_state.output_text,
-                height=200,
-                key="output_area"
-            )
-            
-            # Download option
-            if st.session_state.output_text:
-                txt_data, txt_mime = create_download_file(st.session_state.output_text)
-                st.download_button(
-                    "💾 Download Result",
-                    data=txt_data,
-                    file_name="paraphrased.txt",
-                    mime=txt_mime,
-                    use_container_width=True
-                )
-        else:
-            st.info("👆 Enter text and click 'Paraphrase' to see AI results")
-    
-    # Example section
-    if not st.session_state.input_text and not st.session_state.output_text:
-        st.markdown("---")
-        with st.expander("💡 Try Examples", expanded=True):
-            examples = [
-                "Don't touch this switch",
-                "Stay away from that button", 
-                "This is a simple test",
-                "The cat sat on the mat",
-                "Please close the door behind you"
-            ]
-            
-            st.markdown("**Click any example to try:**")
-            cols = st.columns(len(examples))
-            
-            for i, example in enumerate(examples):
-                with cols[i]:
-                    if st.button(f"📝 Example {i+1}", key=f"ex_{i}"):
-                        st.session_state.input_text = example
-                        st.rerun()
-            
-            for example in examples:
-                st.markdown(f"• *{example}*")
-    
-    # Footer
-    st.markdown("---")
-    st.markdown("""
-    <div style="text-align: center; color: #666; padding: 1rem;">
-        <small>
-        🤖 AI-Powered Paraphrasing | 
-        🔄 Use "Output to Input" for continuous transformation |
-        📝 Supports single words to full documents
-        </small>
-    </div>
-    """, unsafe_allow_html=True)
-
-if __name__ == "__main__":
-    main()
+MIT License
+
+Copyright (c) 2025 Karan Tatyaso Kamble
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.