python-lab-toolkit 1.0.0__py3-none-any.whl

pylab/templates/q12/main_analyzer.py

@@ -0,0 +1,46 @@
+import sys
+from text_preprocessor import normalize_text, remove_punctuation, tokenize
+from text_analyzer import compute_word_frequencies, count_alphabetic_characters, count_unique_words
+
+def display_docstrings():
+    print("=== Function Docstrings (Inspection) ===")
+    functions = [
+        ("normalize_text", normalize_text),
+        ("remove_punctuation", remove_punctuation),
+        ("tokenize", tokenize),
+        ("compute_word_frequencies", compute_word_frequencies),
+        ("count_alphabetic_characters", count_alphabetic_characters),
+        ("count_unique_words", count_unique_words),
+    ]
+    for name, func in functions:
+        print(f"Function: {name}")
+        print(f"Docstring: {func.__doc__.strip()}\n")
+
+def main():
+    sample_paragraph = (
+        "Python is a versatile, high-level programming language. "
+        "Python emphasizes code readability, and Python developers love clean software!"
+    )
+    print("=== Modular Text Analysis Demonstration ===")
+    print(f"Input Text:\n\"{sample_paragraph}\"\n")
+    
+    alpha_count = count_alphabetic_characters(sample_paragraph)
+    normalized = normalize_text(sample_paragraph)
+    clean_text = remove_punctuation(normalized)
+    tokens = tokenize(clean_text)
+    frequencies = compute_word_frequencies(tokens)
+    unique_count = count_unique_words(tokens)
+    
+    print(f"Total Alphabetic Characters: {alpha_count}")
+    print(f"Total Word Tokens          : {len(tokens)}")
+    print(f"Total Unique Words         : {unique_count}\n")
+    print("Word Frequencies (sorted by occurrences):")
+    sorted_freq = sorted(frequencies.items(), key=lambda item: item[1], reverse=True)
+    for word, count in sorted_freq:
+        print(f"  {word:<14} : {count}")
+    
+    print()
+    display_docstrings()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q12/text_analyzer.py

@@ -0,0 +1,16 @@
+from typing import Dict, List
+
+def compute_word_frequencies(tokens: List[str]) -> Dict[str, int]:
+    """Computes the frequency count for every unique token in the list."""
+    frequencies = {}
+    for token in tokens:
+        frequencies[token] = frequencies.get(token, 0) + 1
+    return frequencies
+
+def count_alphabetic_characters(text: str) -> int:
+    """Counts the total number of alphabetic characters present in the text."""
+    return sum(1 for char in text if char.isalpha())
+
+def count_unique_words(tokens: List[str]) -> int:
+    """Returns the count of distinct words present in the token list."""
+    return len(set(tokens))

pylab/templates/q12/text_preprocessor.py

@@ -0,0 +1,15 @@
+import string
+from typing import List
+
+def normalize_text(text: str) -> str:
+    """Converts the input string to lowercase and trims surrounding whitespace."""
+    return text.strip().lower()
+
+def remove_punctuation(text: str) -> str:
+    """Removes all standard punctuation marks from the provided text."""
+    translator = str.maketrans("", "", string.punctuation)
+    return text.translate(translator)
+
+def tokenize(text: str) -> List[str]:
+    """Splits a normalized, unpunctuated text into a list of word tokens."""
+    return text.split()

pylab/templates/q13/student.py

@@ -0,0 +1,26 @@
+import sys
+
+class Student:
+    def __init__(self, name, roll_number, course):
+        self.name = name.strip()
+        self.roll_number = str(roll_number).strip()
+        self.course = course.strip()
+
+    def display(self):
+        print(f"Name        : {self.name}")
+        print(f"Roll Number : {self.roll_number}")
+        print(f"Course      : {self.course}")
+        print("-" * 30)
+
+def main():
+    print("=== Student Record Display System ===")
+    student_records = [
+        Student("Aarav Sharma", "CS202601", "Computer Science"),
+        Student("Diya Patel", "DS202614", "Data Science & AI"),
+        Student("Kabir Mehta", "CY202622", "Cybersecurity"),
+    ]
+    for s in student_records:
+        s.display()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q14/circle.py

@@ -0,0 +1,26 @@
+import math
+import sys
+
+class Circle:
+    def __init__(self, radius):
+        if radius < 0:
+            raise ValueError("Circle radius cannot be negative.")
+        self.radius = float(radius)
+
+    def area(self):
+        return math.pi * (self.radius ** 2)
+
+    def circumference(self):
+        return 2 * math.pi * self.radius
+
+def main():
+    print("=== Circle Properties Calculator ===")
+    radii = [1.0, 3.5, 7.0, 10.0, 14.5]
+    print(f"{'Radius':<10} | {'Area':<16} | {'Circumference':<16}")
+    print("-" * 48)
+    for r in radii:
+        c = Circle(r)
+        print(f"{c.radius:<10.2f} | {c.area():<16.4f} | {c.circumference():<16.4f}")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q15/employee_salary.py

@@ -0,0 +1,46 @@
+import sys
+
+class Employee:
+    HRA_RATE = 0.20
+    DA_RATE = 0.10
+
+    def __init__(self, emp_id, name, basic_pay):
+        self.emp_id = str(emp_id).strip()
+        self.name = name.strip()
+        if basic_pay < 0:
+            raise ValueError("Basic pay cannot be negative.")
+        self.basic_pay = float(basic_pay)
+
+    def calculate_hra(self):
+        return self.basic_pay * self.HRA_RATE
+
+    def calculate_da(self):
+        return self.basic_pay * self.DA_RATE
+
+    def calculate_gross_salary(self):
+        return self.basic_pay + self.calculate_hra() + self.calculate_da()
+
+    def display_salary_slip(self):
+        hra = self.calculate_hra()
+        da = self.calculate_da()
+        gross = self.calculate_gross_salary()
+        print(f"Employee ID  : {self.emp_id}")
+        print(f"Name         : {self.name}")
+        print(f"Basic Pay    : ₹{self.basic_pay:,.2f}")
+        print(f"HRA (20%)    : ₹{hra:,.2f}")
+        print(f"DA (10%)     : ₹{da:,.2f}")
+        print(f"Gross Salary : ₹{gross:,.2f}")
+        print("=" * 36)
+
+def main():
+    print("=== Employee Salary Statement ===")
+    team = [
+        Employee("E101", "Priya Nair", 45000),
+        Employee("E102", "Rajesh Kumar", 62000),
+        Employee("E103", "Ananya Sen", 80000),
+    ]
+    for emp in team:
+        emp.display_salary_slip()
+
+if __name__ == "__main__":
+    main()

pylab/templates/q16/smart_calculator.py

@@ -0,0 +1,51 @@
+import sys
+
+class SmartCalculator:
+    def add(self, a=0, b=0, c=0):
+        return a + b + c
+
+    def multiply(self, *args):
+        if not args:
+            return 0
+        product = 1
+        for val in args:
+            product *= val
+        return product
+
+    def process_data(self, data):
+        if isinstance(data, (int, float)):
+            return f"Numeric absolute square: {abs(data) ** 2}"
+        elif isinstance(data, str):
+            return f"Processed string (length {len(data)}): {data.upper()}"
+        elif isinstance(data, (list, tuple, set)):
+            return f"Collection with {len(data)} items, sorted: {sorted(list(data))}"
+        elif isinstance(data, dict):
+            return f"Dictionary with keys: {list(data.keys())}"
+        else:
+            return f"Unsupported data type: {type(data).__name__}"
+
+def main():
+    print("=== SmartCalculator Demonstration ===")
+    calc = SmartCalculator()
+    
+    print("1. Addition with Default Arguments:")
+    print("   calc.add()           = ", calc.add())
+    print("   calc.add(10)         = ", calc.add(10))
+    print("   calc.add(10, 20)     = ", calc.add(10, 20))
+    print("   calc.add(10, 20, 30) = ", calc.add(10, 20, 30))
+
+    print("\n2. Multiplication with Variable Arguments (*args):")
+    print("   calc.multiply()                 = ", calc.multiply())
+    print("   calc.multiply(5)                = ", calc.multiply(5))
+    print("   calc.multiply(2, 3, 4)          = ", calc.multiply(2, 3, 4))
+    print("   calc.multiply(1, 2, 3, 4, 5, 6) = ", calc.multiply(1, 2, 3, 4, 5, 6))
+
+    print("\n3. Type-Dependent Processing:")
+    print("   Integer :", calc.process_data(12))
+    print("   Float   :", calc.process_data(-4.5))
+    print("   String  :", calc.process_data("python lab toolkit"))
+    print("   List    :", calc.process_data([42, 7, 19, 3, 88]))
+    print("   Dict    :", calc.process_data({"id": 1, "status": "active"}))
+
+if __name__ == "__main__":
+    main()

pylab/templates/q17/complex_number.py

@@ -0,0 +1,43 @@
+import sys
+
+class ComplexNumber:
+    def __init__(self, real=0.0, imag=0.0):
+        self.real = float(real)
+        self.imag = float(imag)
+
+    def __add__(self, other):
+        if not isinstance(other, ComplexNumber):
+            return NotImplemented
+        return ComplexNumber(self.real + other.real, self.imag + other.imag)
+
+    def __eq__(self, other):
+        if not isinstance(other, ComplexNumber):
+            return False
+        return math_is_close(self.real, other.real) and math_is_close(self.imag, other.imag)
+
+    def __str__(self):
+        sign = "+" if self.imag >= 0 else "-"
+        return f"{self.real:.2f} {sign} {abs(self.imag):.2f}i"
+
+    def __repr__(self):
+        return f"ComplexNumber(real={self.real}, imag={self.imag})"
+
+def math_is_close(a, b, tol=1e-9):
+    return abs(a - b) <= tol
+
+def main():
+    print("=== Complex Number Operator Overloading (+, ==) ===")
+    c1 = ComplexNumber(3.5, 4.2)
+    c2 = ComplexNumber(1.5, -2.2)
+    c3 = ComplexNumber(5.0, 2.0)
+    
+    c_sum = c1 + c2
+    print(f"c1           : {c1}")
+    print(f"c2           : {c2}")
+    print(f"c1 + c2      : {c_sum}")
+    print(f"c3           : {c3}")
+    print(f"c_sum == c3  : {c_sum == c3}")
+    print(f"c1 == c2     : {c1 == c2}")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q18/vehicle_inheritance.py

@@ -0,0 +1,43 @@
+import sys
+
+class Vehicle:
+    def __init__(self, make, model, year):
+        self.make = make.strip()
+        self.model = model.strip()
+        self.year = int(year)
+
+    def start_engine(self):
+        return f"The {self.year} {self.make} {self.model} engine is starting with a gentle purr."
+
+    def get_details(self):
+        return f"Vehicle: {self.year} {self.make} {self.model}"
+
+class Car(Vehicle):
+    def __init__(self, make, model, year, num_doors, fuel_type):
+        super().__init__(make, model, year)
+        self.num_doors = int(num_doors)
+        self.fuel_type = fuel_type.strip()
+
+    def start_engine(self):
+        base_status = super().start_engine()
+        return f"{base_status} The dashboard lights illuminate in sport mode."
+
+    def get_details(self):
+        parent_details = super().get_details()
+        return f"{parent_details} [Doors: {self.num_doors}, Fuel: {self.fuel_type}]"
+
+def main():
+    print("=== Vehicle and Car Inheritance Demonstration ===")
+    v = Vehicle("GenericMotors", "Utility-X", 2021)
+    c = Car("Tesla", "Model 3", 2024, 4, "Electric")
+    
+    print("Vehicle Instance:")
+    print("  Details:", v.get_details())
+    print("  Engine :", v.start_engine())
+    print()
+    print("Car Instance (Subclass using super()):")
+    print("  Details:", c.get_details())
+    print("  Engine :", c.start_engine())
+
+if __name__ == "__main__":
+    main()

pylab/templates/q19/file_word_counter.py

@@ -0,0 +1,48 @@
+import collections
+import os
+import sys
+
+def analyze_text_file(filepath):
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"File '{filepath}' does not exist.")
+    
+    total_lines = 0
+    total_words = 0
+    total_characters = 0
+    word_counter = collections.Counter()
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            total_lines += 1
+            total_characters += len(line)
+            clean_words = [w.strip(".,!?:;\"'()[]{}") for w in line.lower().split()]
+            valid_words = [w for w in clean_words if w]
+            total_words += len(valid_words)
+            word_counter.update(valid_words)
+
+    top_five = word_counter.most_common(5)
+    return {
+        "lines": total_lines,
+        "words": total_words,
+        "characters": total_characters,
+        "top_five": top_five
+    }
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "sample.txt"
+    print(f"=== Text File Statistics Analyzer: '{target}' ===")
+    try:
+        stats = analyze_text_file(target)
+        print(f"Total Lines      : {stats['lines']}")
+        print(f"Total Words      : {stats['words']}")
+        print(f"Total Characters : {stats['characters']}")
+        print("\nTop 5 Most Frequent Words:")
+        for word, count in stats["top_five"]:
+            print(f"  {word:<12} : {count} occurrences")
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+    except PermissionError as e:
+        print(f"Permission Error: Access denied for '{target}'. {e}")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q19/sample.txt

@@ -0,0 +1,6 @@
+Python is an easy to learn, powerful programming language.
+It has efficient high-level data structures and a simple but effective approach to object-oriented programming.
+Python elegant syntax and dynamic typing, together with its interpreted nature,
+make it an ideal language for scripting and rapid application development in many areas on most platforms.
+The Python interpreter and the extensive standard library are freely available in source or binary form.
+Python encourages programmers to write clean, readable code with modular design.

pylab/templates/q2/single_number.py

@@ -0,0 +1,26 @@
+import sys
+
+def find_single_number(numbers):
+    if not numbers:
+        raise ValueError("The input list cannot be empty.")
+    unique_val = 0
+    for num in numbers:
+        unique_val ^= num
+    return unique_val
+
+def main():
+    print("=== Single Number Finder using XOR ===")
+    sample_arrays = [
+        [4, 1, 2, 1, 2],
+        [2, 2, 1],
+        [17, 45, 17, 89, 45],
+        [99],
+        [10, 20, 30, 40, 50, 40, 30, 20, 10]
+    ]
+    for arr in sample_arrays:
+        unique_item = find_single_number(arr)
+        print(f"Array: {arr}")
+        print(f"Single Unique Element: {unique_item}\n")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q20/age_validator.py

@@ -0,0 +1,27 @@
+import sys
+
+class InvalidAgeException(Exception):
+    def __init__(self, age, message="Age must be between 18 and 60 inclusive."):
+        self.age = age
+        self.message = message
+        super().__init__(f"InvalidAgeException: Age {age} is outside the allowed range. {message}")
+
+def validate_age(age):
+    if not isinstance(age, (int, float)):
+        raise TypeError("Age must be a numeric value.")
+    if age < 18 or age > 60:
+        raise InvalidAgeException(age)
+    return True
+
+def main():
+    print("=== Custom InvalidAgeException Validator (Range: 18 - 60) ===")
+    test_ages = [15, 18, 25, 45, 60, 65, -2]
+    for candidate in test_ages:
+        try:
+            validate_age(candidate)
+            print(f"[APPROVED] Age {candidate:<3}: Valid applicant age.")
+        except InvalidAgeException as err:
+            print(f"[REJECTED] Age {candidate:<3}: {err.message}")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q21/transaction_manager.py

@@ -0,0 +1,45 @@
+import sys
+
+class InsufficientBalanceError(Exception):
+    pass
+
+class BankAccount:
+    def __init__(self, owner, balance):
+        self.owner = owner
+        self.balance = float(balance)
+
+    def withdraw(self, amount):
+        print(f"Initiating withdrawal of ₹{amount:,.2f} for account: {self.owner}")
+        try:
+            if amount <= 0:
+                raise ValueError("Withdrawal amount must be greater than zero.")
+            if amount > self.balance:
+                raise InsufficientBalanceError(
+                    f"Insufficient funds! Requested: ₹{amount:,.2f}, Available: ₹{self.balance:,.2f}"
+                )
+            self.balance -= amount
+        except ValueError as ve:
+            print(f"  [EXCEPT] Validation Failure: {ve}")
+            raise
+        except InsufficientBalanceError as ibe:
+            print(f"  [EXCEPT] Transaction Declined: {ibe}")
+            raise
+        else:
+            print(f"  [ELSE]   Transaction Authorized! Remaining Balance: ₹{self.balance:,.2f}")
+            return self.balance
+        finally:
+            print("  [FINALLY] Releasing transaction lock and writing audit ledger entry.\n")
+
+def main():
+    print("=== Robust Transaction Error Handling (try-except-else-finally) ===")
+    account = BankAccount("Rohit Sharma", 5000.0)
+    
+    test_amounts = [1500.0, 4000.0, -200.0]
+    for amt in test_amounts:
+        try:
+            account.withdraw(amt)
+        except Exception:
+            pass
+
+if __name__ == "__main__":
+    main()

pylab/templates/q22/date_formatter.py

@@ -0,0 +1,30 @@
+import datetime
+import sys
+
+def format_date(date_str):
+    clean_str = date_str.strip()
+    try:
+        parsed_date = datetime.datetime.strptime(clean_str, "%d-%m-%Y")
+        return True, parsed_date.strftime("%B %d, %Y")
+    except ValueError as err:
+        return False, f"Invalid date '{date_str}': {err}"
+
+def main():
+    print("=== Date Formatter and Validator (dd-mm-yyyy -> MonthName dd, yyyy) ===")
+    dates_to_test = [
+        "15-08-1947",
+        "26-01-1950",
+        "29-02-2024",
+        "29-02-2023",
+        "31-04-2023",
+        "12-13-2023",
+        "05-11-2026",
+        "invalid-date",
+    ]
+    for raw_date in dates_to_test:
+        valid, result = format_date(raw_date)
+        status = "[VALID]  " if valid else "[INVALID]"
+        print(f"  {status} {raw_date:<14} -> {result}")
+
+if __name__ == "__main__":
+    main()

pylab/templates/q23/rainfall_analyzer.py

@@ -0,0 +1,73 @@
+import csv
+import os
+import sys
+
+def calculate_std(values, mean_val):
+    try:
+        import numpy as np
+        return float(np.std(values))
+    except ImportError:
+        variance = sum((x - mean_val) ** 2 for x in values) / len(values)
+        return variance ** 0.5
+
+def analyze_rainfall(input_path, output_summary_path="rainfall_summary.csv"):
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Rainfall file '{input_path}' not found.")
+
+    station_data = {}
+    all_readings = []
+    max_rainfall = -1.0
+    max_record = None
+
+    with open(input_path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            station = row["Station"].strip()
+            date_str = row["Date"].strip()
+            val = float(row["Rainfall"])
+            
+            if station not in station_data:
+                station_data[station] = []
+            station_data[station].append(val)
+            all_readings.append(val)
+
+            if val > max_rainfall:
+                max_rainfall = val
+                max_record = (station, date_str, val)
+
+    print("=== Rainfall Data Analysis ===")
+    print(f"Total Records Processed: {len(all_readings)}")
+    print(f"Distinct Stations Count : {len(station_data)}")
+    if max_record:
+        print(f"Maximum Rainfall Record : {max_record[2]} mm at {max_record[0]} on {max_record[1]}")
+
+    summary_rows = []
+    print("\nStation Statistics:")
+    print(f"{'Station':<18} | {'Avg (mm)':<10} | {'Std Dev (mm)':<12} | {'Readings':<8}")
+    print("-" * 56)
+    for st, vals in sorted(station_data.items()):
+        avg_val = sum(vals) / len(vals)
+        std_val = calculate_std(vals, avg_val)
+        summary_rows.append({
+            "Station": st,
+            "Average_Rainfall": round(avg_val, 2),
+            "Std_Deviation": round(std_val, 2),
+            "Total_Readings": len(vals)
+        })
+        print(f"{st:<18} | {avg_val:<10.2f} | {std_val:<12.2f} | {len(vals):<8}")
+
+    with open(output_summary_path, "w", newline="", encoding="utf-8") as out_f:
+        fieldnames = ["Station", "Average_Rainfall", "Std_Deviation", "Total_Readings"]
+        writer = csv.DictWriter(out_f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(summary_rows)
+
+    print(f"\nSummary report exported successfully to: {output_summary_path}")
+    return summary_rows
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "rainfall.csv"
+    analyze_rainfall(target)
+
+if __name__ == "__main__":
+    main()

pylab/templates/q24/student_marks.py

@@ -0,0 +1,58 @@
+import csv
+import os
+import sys
+
+SAMPLE_STUDENTS = [
+    {"StudentID": "S101", "Name": "Aarav Sharma", "Marks": 88.5},
+    {"StudentID": "S102", "Name": "Diya Patel", "Marks": 94.0},
+    {"StudentID": "S103", "Name": "Kabir Mehta", "Marks": 79.5},
+    {"StudentID": "S104", "Name": "Ananya Sen", "Marks": 97.5},
+    {"StudentID": "S105", "Name": "Rohan Verma", "Marks": 83.0},
+    {"StudentID": "S106", "Name": "Ishaan Gupta", "Marks": 91.0},
+]
+
+def ensure_students_csv(filepath):
+    if not os.path.exists(filepath):
+        with open(filepath, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=["StudentID", "Name", "Marks"])
+            writer.writeheader()
+            writer.writerows(SAMPLE_STUDENTS)
+
+def process_students_csv(filepath):
+    ensure_students_csv(filepath)
+    students = []
+    total_marks = 0.0
+    highest_student = None
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            s_id = row["StudentID"].strip()
+            name = row["Name"].strip()
+            marks = float(row["Marks"])
+            record = {"StudentID": s_id, "Name": name, "Marks": marks}
+            students.append(record)
+            total_marks += marks
+            if highest_student is None or marks > highest_student["Marks"]:
+                highest_student = record
+
+    avg_marks = total_marks / len(students) if students else 0.0
+
+    print("=== Student Marks CSV Evaluation ===")
+    print(f"{'StudentID':<10} | {'Name':<18} | {'Marks':<8}")
+    print("-" * 42)
+    for s in students:
+        print(f"{s['StudentID']:<10} | {s['Name']:<18} | {s['Marks']:<8.2f}")
+    
+    print("-" * 42)
+    print(f"Class Average Marks     : {avg_marks:.2f}")
+    if highest_student:
+        print(f"Highest Scoring Student : {highest_student['Name']} ({highest_student['StudentID']}) with {highest_student['Marks']:.2f} marks")
+    return students, highest_student, avg_marks
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "students.csv"
+    process_students_csv(target)
+
+if __name__ == "__main__":
+    main()