securetools 0.1.1__tar.gz

securetools-0.1.1/PKG-INFO

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

securetools-0.1.1/pyproject.toml

@@ -0,0 +1,11 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "securetools"
+version = "0.1.1"
+description = "A collection of Python assignment source files"
+
+[tool.setuptools.packages.find]
+where = ["src"]

securetools-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

securetools-0.1.1/src/securetools/10_assignment.py

@@ -0,0 +1,82 @@
+'''
+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/11_assignment.py

@@ -0,0 +1,75 @@
+'''
+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/1_assignment.py

@@ -0,0 +1,52 @@
+import re, emoji, nltk, spacy
+from nltk.tokenize import word_tokenize, RegexpTokenizer
+from nltk.corpus import stopwords
+from nltk.stem import PorterStemmer, SnowballStemmer, WordNetLemmatizer
+from nltk import pos_tag
+from transformers import AutoTokenizer
+ 
+for p in ["punkt", "punkt_tab", "stopwords", "wordnet", "omw-1.4",
+          "averaged_perceptron_tagger", "averaged_perceptron_tagger_eng"]:
+    nltk.download(p, quiet=True)
+ 
+nlp = spacy.load("en_core_web_sm")
+bert = AutoTokenizer.from_pretrained("bert-base-multilingual-cased")
+ 
+data = ["Breaking News!! India wins the match 🇮🇳🏏 #Cricket https://news.com",
+        "OMG 😂😂 This fake news is spreading everywhere!!",
+        "आज मौसम बहुत अच्छा है 😊",
+        "COVID-19 cases are increasing rapidly in Europe.",
+        "@john Check this out!! https://abc.com #Breaking",
+        "Yeh news bilkul fake hai!! 😡😡"]
+ 
+def clean(t):
+    t = re.sub(r"http\S+|@\w+", "", t).replace("#", "")
+    return re.sub(r"\s+", " ", emoji.replace_emoji(t, "")).strip()
+ 
+corpus = [clean(t) for t in data]
+regex, stop = RegexpTokenizer(r"\w+"), set(stopwords.words("english"))
+porter, snow, lem = PorterStemmer(), SnowballStemmer("english"), WordNetLemmatizer()
+ 
+steps = {
+    "CLEANED TEXT":          lambda t: t,
+    "WHITESPACE TOKENS":     lambda t: t.split(),
+    "REGEX TOKENS":          lambda t: regex.tokenize(t),
+    "BERT SUBWORD TOKENS":   lambda t: bert.tokenize(t),
+    "STOPWORDS REMOVED":     lambda t: [w for w in word_tokenize(t) if w.lower() not in stop],
+    "PORTER STEMS":          lambda t: [porter.stem(w) for w in regex.tokenize(t)],
+    "SNOWBALL STEMS":        lambda t: [snow.stem(w) for w in regex.tokenize(t)],
+    "WORDNET LEMMAS":        lambda t: [lem.lemmatize(w) for w in regex.tokenize(t)],
+    "NLTK POS TAGS":         lambda t: pos_tag(word_tokenize(t)),
+    "SPACY (TOKEN, LEMMA, POS)": lambda t: [(x.text, x.lemma_, x.pos_) for x in nlp(t)],
+}
+ 
+for name, fn in steps.items():
+    print(f"\n=== {name} ===")
+    for t in corpus:
+        print(fn(t))
+ 
+s = corpus[0]
+print("\n=== NLTK vs SPACY ===\nText:", s)
+print("NLTK  :", pos_tag(word_tokenize(s)))
+print("spaCy :", [(x.text, x.pos_) for x in nlp(s)])
+print("spaCy lemmas:", [x.lemma_ for x in nlp(s)])

securetools-0.1.1/src/securetools/2_assignment.py

@@ -0,0 +1,155 @@
+import re
+from pathlib import Path
+
+import pandas as pd
+'''
+Assignment 2: Regular Expressions & Text Cleaning
+'''
+# --------------------------------------------------
+# Read Dataset
+# --------------------------------------------------
+
+assignment_dir = Path(__file__).resolve().parent
+df = pd.read_csv(assignment_dir / '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(assignment_dir / 'extracted_resume_data.csv', index=False)
+
+print("\nData Saved Successfully!")

securetools-0.1.1/src/securetools/3_assignment.py

@@ -0,0 +1,97 @@
+'''
+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()