securetools 0.1.1__tar.gz → 0.1.3__tar.gz

{securetools-0.1.1 → securetools-0.1.3}/PKG-INFO

@@ -1,4 +1,4 @@
 Metadata-Version: 2.4
 Name: securetools
-Version: 0.1.1
+Version: 0.1.3
 Summary: A collection of Python assignment source files

{securetools-0.1.1 → securetools-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "securetools"
-version = "0.1.1"
+version = "0.1.3"
 description = "A collection of Python assignment source files"
 
 [tool.setuptools.packages.find]

securetools-0.1.3/src/securetools/requirements.txt.py

@@ -0,0 +1,7 @@
+nltk
+spacy
+transformers
+emoji
+pandas
+torch
+sentencepiece

{securetools-0.1.1 → securetools-0.1.3}/src/securetools.egg-info/PKG-INFO

@@ -1,4 +1,4 @@
 Metadata-Version: 2.4
 Name: securetools
-Version: 0.1.1
+Version: 0.1.3
 Summary: A collection of Python assignment source files

{securetools-0.1.1 → securetools-0.1.3}/src/securetools.egg-info/SOURCES.txt

@@ -11,16 +11,8 @@ src/securetools/7_assignment.py
 src/securetools/8_assignment.py
 src/securetools/9_assignment.py
 src/securetools/__init__.py
+src/securetools/requirements.txt.py
 src/securetools.egg-info/PKG-INFO
 src/securetools.egg-info/SOURCES.txt
 src/securetools.egg-info/dependency_links.txt
-src/securetools.egg-info/top_level.txt
-src/securetools/NLPLE/LAB10/assignment_10.py
-src/securetools/NLPLE/LAB11/assignment_11.py
-src/securetools/NLPLE/LAB2/main.py
-src/securetools/NLPLE/LAB3/assignment_3.py
-src/securetools/NLPLE/LAB5/assignment_5.py
-src/securetools/NLPLE/LAB6/assignment_6.py
-src/securetools/NLPLE/LAB7/assignment_7.py
-src/securetools/NLPLE/LAB8/assignment_8.py
-src/securetools/NLPLE/LAB9/assignment_9.py
+src/securetools.egg-info/top_level.txt

securetools-0.1.1/src/securetools/NLPLE/LAB10/assignment_10.py

@@ -1,87 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 10: Prompt Engineering Techniques for LLMs
-'''
-"""
-Assignment 10: Prompt Engineering Techniques for LLMs
-- Programmatic implementation of Zero-Shot, One-Shot, Few-Shot, and Chain-of-Thought (CoT) prompts
-- Legal document summarization, risk clause detection, and plain-language brief generation
-- Systematic evaluation of prompt templates and output quality impact
-"""
-
-import os
-import json
-from typing import Dict
-
-def build_zero_shot_prompt(contract_text: str) -> str:
-    """Builds a zero-shot prompt for contract analysis."""
-    return f"""System: You are an expert legal assistant. Summarize the contract and identify risk clauses.
-Contract Text:
-"{contract_text}"
-Summary & Risk Clauses:"""
-
-def build_few_shot_prompt(contract_text: str) -> str:
-    """Builds a few-shot prompt with exemplar input-output pairs."""
-    return f"""System: Analyze legal contracts, extract key dates, liabilities, and plain-language summaries.
-
-Example 1:
-Contract: "The Licensee shall pay $50,000 annually. Failure to pay within 30 days results in immediate termination."
-Output:
-- Obligation: $50,000 annual fee.
-- Risk Clause: 30-day default termination.
-
-Example 2:
-Contract: "{contract_text}"
-Output:"""
-
-def build_chain_of_thought_prompt(contract_text: str) -> str:
-    """Builds a Chain-of-Thought (CoT) prompt enforcing step-by-step reasoning."""
-    return f"""System: Perform legal analysis using explicit step-by-step reasoning.
-Contract Text:
-"{contract_text}"
-
-Reasoning Steps:
-1. Identify contracting parties and primary obligations.
-2. Locate duration and confidentiality term limits.
-3. Extract financial risk caps or liability limitations.
-
-Final Analysis & Brief:"""
-
-def evaluate_prompt_strategies(contract_text: str) -> Dict[str, str]:
-    """Generates prompt templates across zero-shot, few-shot, and CoT strategies."""
-    return {
-        "Zero-Shot": build_zero_shot_prompt(contract_text),
-        "Few-Shot": build_few_shot_prompt(contract_text),
-        "Chain-of-Thought (CoT)": build_chain_of_thought_prompt(contract_text)
-    }
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 10: PROMPT ENGINEERING TECHNIQUES FOR LLMS")
-    print("=" * 60)
-
-    data_path = os.path.join(os.path.dirname(__file__), "sample_contracts.json")
-    if not os.path.exists(data_path):
-        print(f"Data file not found at {data_path}")
-        return
-
-    with open(data_path, "r", encoding="utf-8") as f:
-        contracts = json.load(f)
-
-    sample_contract = contracts[0]["text"]
-    print(f"\nSample Legal Contract:\n\"{sample_contract}\"\n")
-
-    prompts = evaluate_prompt_strategies(sample_contract)
-
-    print("=" * 60)
-    for strategy_name, prompt_str in prompts.items():
-        print(f"--- Prompting Strategy: {strategy_name} ---")
-        print(prompt_str)
-        print("-" * 60 + "\n")
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB11/assignment_11.py

@@ -1,80 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 11: RAG-based Document Question Answering System
-'''
-"""
-Assignment 11: RAG-based Document Question Answering System
-- Chunking & Indexing institutional handbook documents into vector space
-- Top-k semantic similarity retrieval engine (FAISS / TF-IDF Vector Store)
-- Context-grounded RAG answer synthesis for university student queries (exams, admissions, hostel rules)
-- Evaluation via ROUGE & BLEU retrieval metrics
-"""
-
-import os
-from typing import Tuple
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-
-class RAGQuestionAnsweringSystem:
-    """Retrieval-Augmented Generation (RAG) Question Answering Pipeline."""
-
-    def __init__(self, handbook_filepath: str):
-        with open(handbook_filepath, "r", encoding="utf-8") as f:
-            raw_text = f.read()
-
-        # Document Chunking (recursive section splitter)
-        self.chunks = [c.strip() for c in raw_text.split("SECTION") if c.strip()]
-        self.vectorizer = TfidfVectorizer(stop_words='english')
-        self.tfidf_matrix = self.vectorizer.fit_transform(self.chunks)
-
-    def retrieve_context(self, query: str) -> Tuple[str, float]:
-        """Retrieves top-1 semantic context chunk for query using cosine similarity."""
-        query_vec = self.vectorizer.transform([query])
-        similarities = cosine_similarity(query_vec, self.tfidf_matrix)[0]
-        top_idx = similarities.argmax()
-        return self.chunks[top_idx], float(similarities[top_idx])
-
-    def answer_query(self, query: str) -> dict:
-        """Synthesizes context-grounded response."""
-        context, confidence = self.retrieve_context(query)
-        lines = [line for line in context.split("\n") if line.strip()]
-        answer = lines[1] if len(lines) > 1 else lines[0]
-        return {
-            "query": query,
-            "answer": answer,
-            "confidence_score": round(confidence, 4),
-            "retrieved_context": context[:120] + "..."
-        }
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 11: RAG-BASED DOCUMENT QUESTION ANSWERING SYSTEM")
-    print("=" * 60)
-
-    handbook_path = os.path.join(os.path.dirname(__file__), "university_handbook.txt")
-    if not os.path.exists(handbook_path):
-        print(f"Handbook data file not found at {handbook_path}")
-        return
-
-    rag_system = RAGQuestionAnsweringSystem(handbook_path)
-    print(f"\nIndexed {len(rag_system.chunks)} handbook document chunks into vector store.")
-
-    queries = [
-        "When do end-semester examinations commence?",
-        "What are the postgraduate admission eligibility criteria?",
-        "What is the curfew time for hostel residents?"
-    ]
-
-    print("\n--- University Student-Support Chatbot QA ---")
-    for q in queries:
-        res = rag_system.answer_query(q)
-        print(f"\nUser Query : {res['query']}")
-        print(f"Confidence : {res['confidence_score']}")
-        print(f"RAG Answer : {res['answer']}")
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB2/main.py

@@ -1,157 +0,0 @@
-import re
-import pandas as pd
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 2: Regular Expressions & Text Cleaning
-'''
-# --------------------------------------------------
-# Read Dataset
-# --------------------------------------------------
-
-df = pd.read_csv('resumes.csv')
-
-print("Original Dataset\n")
-print(df)
-
-# --------------------------------------------------
-# TextCleaner Class
-# --------------------------------------------------
-
-class TextCleaner:
-
-    # Extract Email
-    def extract_email(self, text):
-
-        emails = re.findall(r'[\w\.-]+@[\w\.-]+\.\w+', text)
-
-        return ", ".join(emails)
-
-    # Extract URL
-    def extract_url(self, text):
-
-        urls = re.findall(r'https?://\S+', text)
-
-        return ", ".join(urls)
-
-    # Extract Phone Number
-    def extract_phone(self, text):
-
-        phones = re.findall(r'(\+?\d[\d\-\(\)\s]{8,}\d)', text)
-
-        cleaned = []
-
-        for phone in phones:
-
-            number = re.sub(r'\D', '', phone)
-
-            cleaned.append(number)
-
-        return ", ".join(cleaned)
-
-    # Extract Hashtags
-    def extract_hashtag(self, text):
-
-        hashtags = re.findall(r'#(\w+)', text)
-
-        return ", ".join(hashtags)
-
-    # Remove HTML Tags
-    def remove_html(self, text):
-
-        return re.sub(r'<.*?>', '', text)
-
-    # Remove JSON Tags
-    def remove_json(self, text):
-
-        return re.sub(r'\{.*?\}', '', text)
-
-    # Extract Experience
-    def extract_experience(self, text):
-
-        match = re.search(r'(\d+)\s+years', text, re.I)
-
-        if match:
-
-            return match.group(1)
-
-        return ""
-
-    # Extract Name
-    def extract_name(self, text):
-
-        words = text.split()
-
-        return " ".join(words[:2])
-
-    # Extract Skills
-    def extract_skills(self, text):
-
-        skills = ['Python','Java','SQL','Machine Learning',
-                  'Data Science','AI','NLP',
-                  'Deep Learning','React','HTML','JavaScript']
-
-        found = []
-
-        for skill in skills:
-
-            if skill.lower() in text.lower():
-
-                found.append(skill)
-
-        return ", ".join(found)
-
-# --------------------------------------------------
-
-cleaner = TextCleaner()
-
-# --------------------------------------------------
-# Apply Functions
-# --------------------------------------------------
-
-df["Name"] = df["resume"].apply(cleaner.extract_name)
-
-df["Email"] = df["resume"].apply(cleaner.extract_email)
-
-df["Phone"] = df["resume"].apply(cleaner.extract_phone)
-
-df["Experience"] = df["resume"].apply(cleaner.extract_experience)
-
-df["Skills"] = df["resume"].apply(cleaner.extract_skills)
-
-df["URL"] = df["resume"].apply(cleaner.extract_url)
-
-df["Hashtags"] = df["resume"].apply(cleaner.extract_hashtag)
-
-# Remove HTML
-
-df["Clean_Text"] = df["resume"].apply(cleaner.remove_html)
-
-# Remove JSON
-
-df["Clean_Text"] = df["Clean_Text"].apply(cleaner.remove_json)
-
-# --------------------------------------------------
-# Display Results
-# --------------------------------------------------
-
-print("\n\nExtracted Information\n")
-
-print(df[["Name",
-          "Email",
-          "Phone",
-          "Experience",
-          "Skills",
-          "URL",
-          "Hashtags"]])
-
-# --------------------------------------------------
-# Save CSV
-# --------------------------------------------------
-
-df.to_csv("extracted_resume_data.csv", index=False)
-
-print("\nData Saved Successfully!")

securetools-0.1.1/src/securetools/NLPLE/LAB3/assignment_3.py

@@ -1,102 +0,0 @@
-'''
-Name: Patil Hitesh Dattatraya
-Class: Btech IT 
-Batch: B2
-Roll:  106
-PRN:   UIT23M1106
-Assignment 3: Bag-of-Words & TF-IDF Vectorization
-'''
-"""
-Assignment 3: Bag-of-Words & TF-IDF Vectorization
-- Bag-of-Words (BoW) & TF-IDF vector representations built from scratch using NumPy
-- Verification with scikit-learn CountVectorizer & TfidfVectorizer
-- Document-similarity & Plagiarism Detection system based on Cosine Similarity
-"""
-
-import os
-import json
-import numpy as np
-from typing import List, Tuple
-from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-
-def bow_from_scratch(corpus: List[str]) -> Tuple[List[str], np.ndarray]:
-    """Generates vocabulary and Bag-of-Words matrix from scratch."""
-    vocab = sorted(list(set(w.lower() for doc in corpus for w in doc.split())))
-    word_to_idx = {w: i for i, w in enumerate(vocab)}
-    
-    matrix = np.zeros((len(corpus), len(vocab)), dtype=int)
-    for row_idx, doc in enumerate(corpus):
-        for word in doc.split():
-            w_clean = word.lower()
-            if w_clean in word_to_idx:
-                matrix[row_idx, word_to_idx[w_clean]] += 1
-    return vocab, matrix
-
-def tfidf_from_scratch(corpus: List[str]) -> Tuple[List[str], np.ndarray]:
-    """Generates normalized TF-IDF feature matrix from scratch."""
-    vocab, bow = bow_from_scratch(corpus)
-    N = len(corpus)
-    
-    # Term Frequency (TF)
-    doc_lengths = bow.sum(axis=1, keepdims=True)
-    tf = bow / np.maximum(doc_lengths, 1)
-    
-    # Inverse Document Frequency (IDF)
-    df = (bow > 0).sum(axis=0)
-    idf = np.log((N + 1) / (df + 1)) + 1
-    
-    tfidf = tf * idf
-    
-    # L2 Normalization
-    norms = np.linalg.norm(tfidf, axis=1, keepdims=True)
-    tfidf_normalized = np.where(norms > 0, tfidf / norms, tfidf)
-    return vocab, tfidf_normalized
-
-def run_plagiarism_check(corpus: List[str], doc_names: List[str], threshold: float = 0.70):
-    """Calculates cosine similarity across document pairs to flag potential plagiarism."""
-    vectorizer = TfidfVectorizer()
-    tfidf_matrix = vectorizer.fit_transform(corpus).toarray()
-    sim_matrix = cosine_similarity(tfidf_matrix)
-
-    print(f"{'Document A':<20} | {'Document B':<20} | {'Cosine Sim':<12} | {'Status':<15}")
-    print("-" * 75)
-
-    for i in range(len(doc_names)):
-        for j in range(i + 1, len(doc_names)):
-            score = sim_matrix[i, j]
-            status = "FLAGGED PLAGIARISM" if score >= threshold else "CLEAN"
-            print(f"{doc_names[i]:<20} | {doc_names[j]:<20} | {score:.4f}       | {status:<15}")
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 3: BAG-OF-WORDS & TF-IDF VECTORIZATION")
-    print("=" * 60)
-
-    data_path = os.path.join(os.path.dirname(__file__),"academic_submissions.json")
-    if not os.path.exists(data_path):
-        print(f"Data file not found at {data_path}")
-        return
-
-    with open(data_path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-
-    corpus = [item["content"] for item in data]
-    doc_ids = [item["id"] for item in data]
-
-    # 1. From-Scratch Verification
-    vocab_scratch, tfidf_scratch = tfidf_from_scratch(corpus)
-    print(f"\nVocabulary Size (From Scratch): {len(vocab_scratch)} words")
-    print(f"TF-IDF Matrix Shape: {tfidf_scratch.shape}")
-
-    # 2. Scikit-learn Comparison
-    sklearn_vec = TfidfVectorizer()
-    tfidf_sklearn = sklearn_vec.fit_transform(corpus).toarray()
-    print(f"Scikit-Learn TF-IDF Matrix Shape: {tfidf_sklearn.shape}")
-
-    # 3. Academic Plagiarism Detection Module
-    print("\n--- Academic Integrity Plagiarism Audit Report ---")
-    run_plagiarism_check(corpus, doc_ids, threshold=0.70)
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB5/assignment_5.py

@@ -1,85 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 5: Topic Modeling using LSA / LDA
-'''
-"""
-Assignment 5: Topic Modeling using LSA / LDA
-- Topic Modeling using Latent Semantic Analysis (LSA / SVD) and Latent Dirichlet Allocation (LDA)
-- Coherence & Topic Keyword Extraction
-- Real-World Application: Analyzing Telecom Support Tickets for operational decision-making
-"""
-
-import os
-import csv
-from typing import List, Tuple
-from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
-from sklearn.decomposition import LatentDirichletAllocation, TruncatedSVD
-
-def fit_lda_topics(corpus: List[str], num_topics: int = 3, top_words_count: int = 5) -> List[Tuple[str, List[str]]]:
-    """Fits Latent Dirichlet Allocation (LDA) topic model and returns top keywords per topic."""
-    vectorizer = CountVectorizer(stop_words='english')
-    dtm = vectorizer.fit_transform(corpus)
-    feature_names = vectorizer.get_feature_names_out()
-
-    lda = LatentDirichletAllocation(n_components=num_topics, random_state=42)
-    lda.fit(dtm)
-
-    topics = []
-    for idx, topic in enumerate(lda.components_):
-        top_indices = topic.argsort()[:-top_words_count - 1:-1]
-        top_words = [feature_names[i] for i in top_indices]
-        topics.append((f"Topic {idx + 1}", top_words))
-    return topics
-
-def fit_lsa_topics(corpus: List[str], num_topics: int = 3, top_words_count: int = 5) -> List[Tuple[str, List[str]]]:
-    """Fits Latent Semantic Analysis (LSA / TruncatedSVD) topic model."""
-    vectorizer = TfidfVectorizer(stop_words='english')
-    tfidf_matrix = vectorizer.fit_transform(corpus)
-    feature_names = vectorizer.get_feature_names_out()
-
-    lsa = TruncatedSVD(n_components=num_topics, random_state=42)
-    lsa.fit(tfidf_matrix)
-
-    topics = []
-    for idx, comp in enumerate(lsa.components_):
-        top_indices = comp.argsort()[:-top_words_count - 1:-1]
-        top_words = [feature_names[i] for i in top_indices]
-        topics.append((f"LSA Topic {idx + 1}", top_words))
-    return topics
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 5: TOPIC MODELING USING LSA / LDA")
-    print("=" * 60)
-
-    csv_path = os.path.join(os.path.dirname(__file__), "telecom_support_tickets.csv")
-    if not os.path.exists(csv_path):
-        print(f"Data file not found at {csv_path}")
-        return
-
-    documents = []
-    with open(csv_path, "r", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            documents.append(row["text"])
-
-    print(f"\nLoaded {len(documents)} customer support ticket descriptions.")
-
-    # 1. Fit LDA Model
-    lda_results = fit_lda_topics(documents, num_topics=3)
-    print("\n--- Discovered Topics via Latent Dirichlet Allocation (LDA) ---")
-    for topic_name, words in lda_results:
-        print(f"{topic_name:<12}: {', '.join(words)}")
-
-    # 2. Fit LSA Model
-    lsa_results = fit_lsa_topics(documents, num_topics=3)
-    print("\n--- Discovered Topics via Latent Semantic Analysis (LSA) ---")
-    for topic_name, words in lsa_results:
-        print(f"{topic_name:<12}: {', '.join(words)}")
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB6/assignment_6.py

@@ -1,81 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 6: Named Entity Recognition (NER)
-'''
-"""
-Assignment 6: Named Entity Recognition (NER)
-- spaCy NER pipeline & displaCy entity visualization logic
-- Custom spaCy EntityRuler for domain-specific clinical entity parsing
-- Extract Drug names, Dosages, Symptoms, and Diagnoses from EHR summaries
-"""
-
-import os
-import re
-import json
-from typing import Dict, List
-
-def extract_clinical_entities_rulebased(text: str) -> Dict[str, List[str]]:
-    """
-    Extracts clinical medical entities (Drug, Dosage, Diagnosis, Symptom)
-    using pattern matching / custom EntityRuler logic.
-    """
-    drug_pattern = r'\b(Amoxicillin|Lisinopril|Metformin|Paracetamol|Ibuprofen|Aspirin)\b'
-    dosage_pattern = r'\b\d+\s*(?:mg|g|ml)\b'
-    diagnosis_pattern = r'\b(hypertension|Diabetes Mellitus|Type 2 Diabetes|fever|asthma)\b'
-    symptom_pattern = r'\b(dizziness|nausea|headache|pain|cough)\b'
-
-    drugs = list(set(re.findall(drug_pattern, text, re.IGNORECASE)))
-    dosages = list(set(re.findall(dosage_pattern, text, re.IGNORECASE)))
-    diagnoses = list(set(re.findall(diagnosis_pattern, text, re.IGNORECASE)))
-    symptoms = list(set(re.findall(symptom_pattern, text, re.IGNORECASE)))
-
-    return {
-        "DRUG": drugs,
-        "DOSAGE": dosages,
-        "DIAGNOSIS": diagnoses,
-        "SYMPTOM": symptoms
-    }
-
-def spacy_clinical_ner(text: str) -> dict:
-    """Uses spaCy's pretrained NER engine if installed, falling back cleanly."""
-    try:
-        import spacy
-        nlp = spacy.load("en_core_web_sm")
-        doc = nlp(text)
-        entities = [(ent.text, ent.label_) for ent in doc.ents]
-        return {"spacy_entities": entities}
-    except Exception:
-        return {"spacy_entities": []}
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 6: NAMED ENTITY RECOGNITION (NER)")
-    print("=" * 60)
-
-    data_path = os.path.join(os.path.dirname(__file__),"clinical_discharge_summaries.json")
-    if not os.path.exists(data_path):
-        print(f"Data file not found at {data_path}")
-        return
-
-    with open(data_path, "r", encoding="utf-8") as f:
-        records = json.load(f)
-
-    print(f"\nProcessing {len(records)} patient discharge records:\n")
-
-    for rec in records:
-        print(f"--- Record ID: {rec['id']} ---")
-        print(f"Text Snippet: {rec['text']}")
-        
-        # Clinical Entity Rationale
-        ents = extract_clinical_entities_rulebased(rec['text'])
-        print(f"Extracted Drugs:     {ents['DRUG']}")
-        print(f"Extracted Dosages:   {ents['DOSAGE']}")
-        print(f"Extracted Diagnoses: {ents['DIAGNOSIS']}")
-        print(f"Extracted Symptoms:  {ents['SYMPTOM']}\n")
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB7/assignment_7.py

@@ -1,102 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 7: Sentiment Analysis using Machine Learning
-'''
-"""
-Assignment 7: Sentiment Analysis using Machine Learning
-- Binary sentiment classifier (positive/negative) on customer product reviews
-- Scikit-learn pipelines: TF-IDF + Logistic Regression, Naive Bayes, SVM
-- Model evaluation: Accuracy, Confusion Matrix, ROC-AUC curves
-- FMCG Brand-Sentiment monitoring system triggering real-time alerts when negative spikes > 30%
-"""
-
-import os
-import csv
-from typing import Dict, List
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.linear_model import LogisticRegression
-from sklearn.naive_bayes import MultinomialNB
-from sklearn.svm import SVC
-from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score
-
-def train_and_evaluate_classifiers(texts: List[str], labels: List[int]) -> Dict[str, dict]:
-    """Trains Logistic Regression, Naive Bayes, and SVM on TF-IDF vectors and computes metrics."""
-    vectorizer = TfidfVectorizer()
-    X = vectorizer.fit_transform(texts)
-
-    models = {
-        "Logistic Regression": LogisticRegression(),
-        "Multinomial Naive Bayes": MultinomialNB(),
-        "Support Vector Machine (SVM)": SVC(probability=True)
-    }
-
-    results = {}
-    for name, model in models.items():
-        model.fit(X, labels)
-        preds = model.predict(X)
-        probs = model.predict_proba(X)[:, 1] if hasattr(model, "predict_proba") else preds
-
-        acc = accuracy_score(labels, preds)
-        cm = confusion_matrix(labels, preds)
-        roc = roc_auc_score(labels, probs) if len(set(labels)) > 1 else 1.0
-
-        results[name] = {
-            "model": model,
-            "accuracy": acc,
-            "confusion_matrix": cm,
-            "roc_auc": roc,
-            "predictions": preds
-        }
-    return results
-
-def monitor_brand_health(predictions: List[int], threshold_percent: float = 30.0) -> str:
-    """Evaluates percentage of negative reviews and triggers brand risk alert if threshold exceeded."""
-    total = len(predictions)
-    if total == 0:
-        return "NO DATA"
-    neg_count = sum(1 for p in predictions if p == 0)
-    neg_ratio = (neg_count / total) * 100
-
-    if neg_ratio > threshold_percent:
-        return f"CRITICAL ALERT: Negative sentiment spike at {neg_ratio:.1f}% (> {threshold_percent}%)"
-    return f"NORMAL: Negative sentiment ratio at {neg_ratio:.1f}%"
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 7: SENTIMENT ANALYSIS USING MACHINE LEARNING")
-    print("=" * 60)
-
-    csv_path = os.path.join(os.path.dirname(__file__), "fmcg_product_reviews.csv")
-    if not os.path.exists(csv_path):
-        print(f"Data file not found at {csv_path}")
-        return
-
-    reviews, labels = [], []
-    with open(csv_path, "r", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            reviews.append(row["review"])
-            labels.append(int(row["sentiment"]))
-
-    print(f"\nLoaded {len(reviews)} product review samples.")
-
-    # 1. Train and Evaluate Classifiers
-    eval_results = train_and_evaluate_classifiers(reviews, labels)
-    print("\n--- Model Evaluation Benchmarks ---")
-    print(f"{'Model Architecture':<30} | {'Accuracy':<10} | {'ROC-AUC':<10}")
-    print("-" * 58)
-    for name, res in eval_results.items():
-        print(f"{name:<30} | {res['accuracy']*100:.1f}%      | {res['roc_auc']:.4f}")
-
-    # 2. Real-Time Brand Health Alert Monitoring
-    lr_preds = eval_results["Logistic Regression"]["predictions"]
-    status_alert = monitor_brand_health(lr_preds, threshold_percent=30.0)
-    print("\n--- Real-Time FMCG Brand Monitoring Dashboard ---")
-    print(f"Status: {status_alert}")
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB8/assignment_8.py

@@ -1,82 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 8: Transformer-based Sentiment Analysis using Hugging Face
-'''
-import os
-import csv
-from transformers import pipeline
-
-
-def predict_sentiment(texts):
-    model_name = "cardiffnlp/twitter-xlm-roberta-base-sentiment"
-    classifier = pipeline("sentiment-analysis", model=model_name)
-
-    results = []
-
-    for text in texts:
-        prediction = classifier(text)[0]
-
-        label = prediction["label"]
-
-        if label == "LABEL_0":
-            label = "Negative"
-        elif label == "LABEL_1":
-            label = "Neutral"
-        else:
-            label = "Positive"
-
-        results.append({
-            "text": text,
-            "label": label,
-            "score": round(prediction["score"], 4)
-        })
-
-    return results
-
-
-def main():
-    print("=" * 75)
-    print("MULTILINGUAL SENTIMENT ANALYSIS")
-    print("=" * 75)
-
-    file_path = os.path.join(os.path.dirname(__file__),"multilingual_opinion_tweets.csv")
-
-    if not os.path.exists(file_path):
-        print("CSV file not found:", file_path)
-        return
-
-    tweets = []
-    languages = []
-
-    with open(file_path, "r", encoding="utf-8") as file:
-        reader = csv.DictReader(file)
-
-        for row in reader:
-            tweets.append(row["text"])
-            languages.append(row["lang"].upper())
-
-    try:
-        results = predict_sentiment(tweets)
-
-        print(f"\n{'Language':<10} {'Sentiment':<12} {'Confidence':<12} Tweet")
-        print("-" * 85)
-
-        for language, result in zip(languages, results):
-            print(
-                f"{language:<10} "
-                f"{result['label']:<12} "
-                f"{result['score']:<12} "
-                f"{result['text']}"
-            )
-
-    except Exception as error:
-        print("Error loading the sentiment model:", error)
-        print("Please check your internet connection and installed libraries.")
-
-
-if __name__ == "__main__":
-    main()

securetools-0.1.1/src/securetools/NLPLE/LAB9/assignment_9.py

@@ -1,83 +0,0 @@
-'''
-Name: Amey Vivek Khodke
-Class: Btech IT 
-Batch: A2
-Roll:  147
-PRN:   0124UITM2015
-Assignment 9: Text Classification using Deep Learning (LSTM / BERT)
-'''
-"""
-Assignment 9: Text Classification using Deep Learning (LSTM / BERT)
-- Multi-class news article category routing (World, Sports, Business, Sci/Tech)
-- Bi-directional LSTM PyTorch network vs. Fine-tuned DistilBERT Transformer
-- Benchmark training time, classification accuracy, loss curves, and inference speed (< 200 ms)
-"""
-
-import os
-import csv
-import time
-from typing import Dict, List
-
-def benchmark_models(articles: List[str], categories: List[str]) -> List[dict]:
-    """Benchmarks deep learning LSTM vs. Transformer inference speed and accuracy."""
-    benchmarks = []
-    
-    # Bi-directional LSTM Benchmark Simulation
-    t0 = time.time()
-    time.sleep(0.015) # simulated inference
-    t1 = time.time()
-    benchmarks.append({
-        "model": "Bi-directional LSTM (PyTorch)",
-        "accuracy": "88.5%",
-        "avg_latency_ms": round((t1 - t0) * 1000, 2),
-        "target_met": True
-    })
-
-    # Fine-tuned DistilBERT Benchmark Simulation
-    t0 = time.time()
-    time.sleep(0.042) # simulated inference
-    t1 = time.time()
-    benchmarks.append({
-        "model": "Fine-tuned DistilBERT (Transformers)",
-        "accuracy": "94.2%",
-        "avg_latency_ms": round((t1 - t0) * 1000, 2),
-        "target_met": True
-    })
-
-    return benchmarks
-
-def main():
-    print("=" * 60)
-    print("ASSIGNMENT 9: DEEP LEARNING TEXT CLASSIFICATION (LSTM / BERT)")
-    print("=" * 60)
-
-    csv_path = os.path.join(os.path.dirname(__file__), "news_articles.csv")
-    if not os.path.exists(csv_path):
-        print(f"Data file not found at {csv_path}")
-        return
-
-    articles, categories = [], []
-    with open(csv_path, "r", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            articles.append(row["title"])
-            categories.append(row["category"])
-
-    print(f"\nLoaded {len(articles)} incoming news articles for category routing.")
-
-    # Run Benchmark
-    benchmark_data = benchmark_models(articles, categories)
-
-    print("\n--- Deep Learning vs. Transformer Model Benchmarks ---")
-    print(f"{'Model Architecture':<35} | {'Accuracy':<10} | {'Latency (ms)':<15} | {'<200ms Target'}")
-    print("-" * 75)
-    for b in benchmark_data:
-        status = "PASSED" if b["target_met"] else "FAILED"
-        print(f"{b['model']:<35} | {b['accuracy']:<10} | {b['avg_latency_ms']:<15} | {status}")
-
-    print("\n--- Sample Category Routing Output ---")
-    for title, cat in zip(articles, categories):
-        print(f"Article: {title:<50} -> Desk: [{cat}]")
-
-if __name__ == "__main__":
-    main()