Update app.py

app.py

@@ -16,11 +16,115 @@ nltk.download('stopwords', quiet=True)
 nltk.download('wordnet', quiet=True)
 nltk.download('averaged_perceptron_tagger', quiet=True)
 
-# ... (keep all the existing functions)
+def read_file_content(uploaded_file):
+    if uploaded_file.type == "text/plain":
+        return uploaded_file.getvalue().decode("utf-8")
+    elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+        doc = Document(uploaded_file)
+        return " ".join([paragraph.text for paragraph in doc.paragraphs])
+    else:
+        raise ValueError("Unsupported file type")
+
+def preprocess_text(text):
+    # Convert to lowercase and remove punctuation
+    text = re.sub(r'[^\w\s]', '', text.lower())
+    
+    # Tokenize and remove stopwords
+    stop_words = set(stopwords.words('english'))
+    tokens = word_tokenize(text)
+    return [word for word in tokens if word not in stop_words]
+
+def cosine_similarity(vec1, vec2):
+    intersection = set(vec1.keys()) & set(vec2.keys())
+    numerator = sum([vec1[x] * vec2[x] for x in intersection])
+    
+    sum1 = sum([vec1[x]**2 for x in vec1.keys()])
+    sum2 = sum([vec2[x]**2 for x in vec2.keys()])
+    denominator = sqrt(sum1) * sqrt(sum2)
+    
+    if not denominator:
+        return 0.0
+    else:
+        return float(numerator) / denominator
+
+def calculate_word_similarity(text1, text2):
+    words1 = preprocess_text(text1)
+    words2 = preprocess_text(text2)
+    
+    vec1 = Counter(words1)
+    vec2 = Counter(words2)
+    
+    similarity = cosine_similarity(vec1, vec2)
+    return similarity * 100
+
+def calculate_sentence_similarity(text1, text2):
+    sentences1 = sent_tokenize(text1)
+    sentences2 = sent_tokenize(text2)
+    
+    similarities = []
+    for sent1 in sentences1:
+        max_similarity = 0
+        for sent2 in sentences2:
+            similarity = calculate_word_similarity(sent1, sent2)
+            if similarity > max_similarity:
+                max_similarity = similarity
+        similarities.append(max_similarity)
+    
+    average_similarity = sum(similarities) / len(similarities) if similarities else 0.0
+    return average_similarity
+
+def longest_common_subsequence(text1, text2):
+    sentences1 = sent_tokenize(text1)
+    sentences2 = sent_tokenize(text2)
+    
+    m, n = len(sentences1), len(sentences2)
+    L = [[0] * (n + 1) for _ in range(m + 1)]
+    
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if sentences1[i-1] == sentences2[j-1]:
+                L[i][j] = L[i-1][j-1] + 1
+            else:
+                L[i][j] = max(L[i-1][j], L[i][j-1])
+    
+    # Backtrack to find the LCS
+    lcs = []
+    i, j = m, n
+    while i > 0 and j > 0:
+        if sentences1[i-1] == sentences2[j-1]:
+            lcs.append(sentences1[i-1])
+            i -= 1
+            j -= 1
+        elif L[i-1][j] > L[i][j-1]:
+            i -= 1
+        else:
+            j -= 1
+    
+    return list(reversed(lcs))
+
+def suggest_rewrites(sentence):
+    words = word_tokenize(sentence)
+    tagged_words = nltk.pos_tag(words)
+    
+    rewrites = []
+    
+    for word, tag in tagged_words:
+        syns = wordnet.synsets(word)
+        if syns:
+            if tag.startswith('N') or tag.startswith('V') or tag.startswith('J') or tag.startswith('R'):
+                synonym = syns[0].lemmas()[0].name()
+                if synonym != word:
+                    rewrites.append(synonym)
+                else:
+                    rewrites.append(word)
+            else:
+                rewrites.append(word)
+        else:
+            rewrites.append(word)
+    
+    return " ".join(rewrites)
 
 def calculate_plagiarism_percentage(word_similarity, sentence_similarity):
-    # This is a simple way to calculate plagiarism percentage
-    # You may want to adjust the weights or use a more sophisticated method
     return (word_similarity + sentence_similarity) / 2
 
 def create_bar_chart(word_similarity, sentence_similarity, plagiarism_percentage):