bda-practicals 0.1.0__tar.gz

bda_practicals-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.

bda_practicals-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

bda_practicals-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: bda-practicals
+Version: 0.1.0
+Summary: A collection of Big Data Analytics (BDA) practicals with instant one-word download commands (bda-3, bda-5, bda-6, bda-7).
+Home-page: https://github.com/yourusername/bda-practicals
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Big Data Analytics Practicals (`bda-practicals`)
+
+A complete collection of Big Data Analytics (BDA) practical implementations with **instant one-word download commands** (`bda-3`, `bda-5`, `bda-6`, `bda-7`).
+
+---
+
+## ⚡ Instant One-Word Commands
+
+Once installed via pip, just type the practical number you want:
+
+| Command | Action | Output File in Downloads |
+|---|---|---|
+| **`bda-3`** | Downloads **Practical 3** (MapReduce Word Count Simulation) | `practical_3.py` |
+| **`bda-5`** | Downloads **Practical 5** (DGIM Algorithm for Counting 1s) | `practical_5.py` |
+| **`bda-6`** | Downloads **Practical 6** (Flajolet-Martin Algorithm for Distinct Count) | `practical_6.py` |
+| **`bda-7`** | Downloads **Practical 7** (Bloom Filter Implementation) | `practical_7.py` |
+
+> Running any command like `bda-5` immediately puts the clean `.py` file into your **Downloads** folder and **pops open Windows Explorer** so you can view, edit, and run the code!
+
+### Download All Practicals at Once:
+```bash
+bda all
+# OR
+bda-all
+```
+
+---
+
+## 🚀 How to Run on Any Computer
+
+1. Open Terminal or Command Prompt:
+   ```bash
+   pip install bda-practicals
+   ```
+2. Download any practical:
+   ```bash
+   bda-5
+   # (Or bda-3, bda-6, bda-7)
+   ```
+3. Open the folder and run:
+   ```bash
+   python practical_5.py
+   ```
+
+---
+
+## License
+MIT License

bda_practicals-0.1.0/README.md

@@ -0,0 +1,48 @@
+# Big Data Analytics Practicals (`bda-practicals`)
+
+A complete collection of Big Data Analytics (BDA) practical implementations with **instant one-word download commands** (`bda-3`, `bda-5`, `bda-6`, `bda-7`).
+
+---
+
+## ⚡ Instant One-Word Commands
+
+Once installed via pip, just type the practical number you want:
+
+| Command | Action | Output File in Downloads |
+|---|---|---|
+| **`bda-3`** | Downloads **Practical 3** (MapReduce Word Count Simulation) | `practical_3.py` |
+| **`bda-5`** | Downloads **Practical 5** (DGIM Algorithm for Counting 1s) | `practical_5.py` |
+| **`bda-6`** | Downloads **Practical 6** (Flajolet-Martin Algorithm for Distinct Count) | `practical_6.py` |
+| **`bda-7`** | Downloads **Practical 7** (Bloom Filter Implementation) | `practical_7.py` |
+
+> Running any command like `bda-5` immediately puts the clean `.py` file into your **Downloads** folder and **pops open Windows Explorer** so you can view, edit, and run the code!
+
+### Download All Practicals at Once:
+```bash
+bda all
+# OR
+bda-all
+```
+
+---
+
+## 🚀 How to Run on Any Computer
+
+1. Open Terminal or Command Prompt:
+   ```bash
+   pip install bda-practicals
+   ```
+2. Download any practical:
+   ```bash
+   bda-5
+   # (Or bda-3, bda-6, bda-7)
+   ```
+3. Open the folder and run:
+   ```bash
+   python practical_5.py
+   ```
+
+---
+
+## License
+MIT License

bda_practicals-0.1.0/bda/__init__.py

@@ -0,0 +1,13 @@
+from bda_package import *
+from bda_package import (
+    practical_3,
+    practical_5,
+    practical_6,
+    practical_7,
+    download,
+    export,
+    run_practical,
+    run_all,
+)
+
+__version__ = "0.1.0"

bda_practicals-0.1.0/bda/__main__.py

@@ -0,0 +1,4 @@
+from bda_package.__main__ import main
+
+if __name__ == '__main__':
+    main()

bda_practicals-0.1.0/bda_package/__init__.py

@@ -0,0 +1,53 @@
+"""
+bda_package
+===========
+Big Data Analytics (BDA) practical implementations:
+- Practical 3: MapReduce Word Count Simulation
+- Practical 5: DGIM Algorithm (Counting 1s in a Sliding Window)
+- Practical 6: Flajolet-Martin Algorithm (Distinct Elements Counting)
+- Practical 7: Bloom Filter Implementation
+"""
+
+from . import practical_3
+from . import practical_5
+from . import practical_6
+from . import practical_7
+from .downloader import download
+
+export = download
+
+__version__ = "0.1.0"
+__all__ = [
+    "practical_3",
+    "practical_5",
+    "practical_6",
+    "practical_7",
+    "run_practical",
+    "run_all",
+    "download",
+    "export",
+]
+
+PRACTICALS = {
+    3: practical_3,
+    5: practical_5,
+    6: practical_6,
+    7: practical_7,
+}
+
+
+def run_practical(number: int, **kwargs):
+    """Run a specific BDA practical by number."""
+    if number not in PRACTICALS:
+        available = ", ".join(map(str, sorted(PRACTICALS.keys())))
+        raise ValueError(f"Practical {number} not found. Available: {available}")
+    return PRACTICALS[number].run(**kwargs)
+
+
+def run_all():
+    """Run all BDA practicals sequentially."""
+    results = {}
+    for num, mod in sorted(PRACTICALS.items()):
+        print(f"\n{'='*25} RUNNING BDA PRACTICAL {num} {'='*25}")
+        results[num] = mod.run()
+    return results

bda_practicals-0.1.0/bda_package/__main__.py

@@ -0,0 +1,105 @@
+import sys
+from . import run_practical, run_all, PRACTICALS
+from .downloader import download
+
+
+def make_cli_for(num: int):
+    """Factory to handle direct practical commands like bda-3, bda-5, etc."""
+    def handler():
+        if len(sys.argv) > 1:
+            arg = sys.argv[1].strip().lower()
+            if arg in ('--run', 'run'):
+                run_practical(num)
+                return
+            if arg in ('-h', '--help', 'help'):
+                print(f"Usage for bda-{num}:")
+                print(f"  bda-{num}           -> Download Practical {num} to Downloads")
+                print(f"  bda-{num} run       -> Run Practical {num} directly in terminal")
+                return
+        # Default behavior: download practical into Downloads and open folder!
+        download(num)
+    return handler
+
+
+cli_p3 = make_cli_for(3)
+cli_p5 = make_cli_for(5)
+cli_p6 = make_cli_for(6)
+cli_p7 = make_cli_for(7)
+
+
+def print_help():
+    print("""
+Big Data Analytics (BDA) Practicals CLI
+=======================================
+Quick One-Word Download Commands:
+  bda-3             -> Downloads Practical 3 (MapReduce Word Count) to Downloads
+  bda-5             -> Downloads Practical 5 (DGIM Algorithm) to Downloads
+  bda-6             -> Downloads Practical 6 (Flajolet-Martin Algorithm) to Downloads
+  bda-7             -> Downloads Practical 7 (Bloom Filter) to Downloads
+
+Download ALL BDA Practicals:
+  bda all           -> Downloads all 4 practicals into Downloads/BDA_Practicals
+  bda-all           -> Downloads all 4 practicals into Downloads/BDA_Practicals
+
+Run in terminal:
+  bda-3 run         -> Runs Practical 3 in terminal
+  bda-5 run         -> Runs Practical 5 in terminal
+  bda run 6         -> Runs Practical 6 in terminal
+""")
+
+
+def main():
+    if len(sys.argv) < 2:
+        # Default action when just running "bda":
+        # Download Practical 5 into Downloads folder and open it!
+        print("No practical specified. Downloading BDA Practical 5 (DGIM Algorithm)...")
+        download(5)
+        return
+
+    command = sys.argv[1].strip().lower()
+
+    if command in ("-h", "--help", "help"):
+        print_help()
+        return
+
+    # Check for download / get / export commands
+    if command in ("download", "get", "export"):
+        target_num = sys.argv[2].strip().lower() if len(sys.argv) > 2 else "5"
+        download(target_num)
+        return
+
+    # Check for run command
+    if command == "run":
+        target = sys.argv[2].strip().lower() if len(sys.argv) > 2 else "5"
+        if target == "all":
+            run_all()
+        else:
+            try:
+                num = int(target)
+                run_practical(num)
+            except ValueError:
+                print(f"Error: Invalid practical number '{target}'.")
+        return
+
+    if command in ("all", "bda-all"):
+        download("all")
+        return
+
+    # Direct number (e.g. "bda 5")
+    try:
+        num = int(command)
+        if num in PRACTICALS:
+            download(num)
+        else:
+            available = ", ".join(map(str, sorted(PRACTICALS.keys())))
+            print(f"Error: Practical number must be one of: {available}. Received: {num}")
+            print_help()
+            sys.exit(1)
+    except ValueError:
+        print(f"Error: Unrecognized option '{command}'.")
+        print_help()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

bda_practicals-0.1.0/bda_package/downloader.py

@@ -0,0 +1,107 @@
+import os
+import sys
+from pathlib import Path
+
+TEMPLATES = {}
+
+# Read templates directly from the package files so they always stay 100% in sync!
+def _load_templates():
+    pkg_dir = Path(__file__).parent
+    mapping = {
+        3: pkg_dir / "practical_3.py",
+        5: pkg_dir / "practical_5.py",
+        6: pkg_dir / "practical_6.py",
+        7: pkg_dir / "practical_7.py",
+    }
+    for num, filepath in mapping.items():
+        if filepath.exists():
+            with open(filepath, "r", encoding="utf-8") as f:
+                TEMPLATES[num] = f.read()
+
+_load_templates()
+
+PRACTICAL_NAMES = {
+    3: "MapReduce Word Count Simulation",
+    5: "DGIM Algorithm (Counting 1s in Sliding Window)",
+    6: "Flajolet-Martin Algorithm (Distinct Elements Counting)",
+    7: "Bloom Filter Implementation",
+}
+
+
+def get_default_download_dir(practical_num=None):
+    """Returns the Downloads directory on Windows/Mac/Linux."""
+    downloads_path = Path.home() / "Downloads"
+    if not downloads_path.exists():
+        downloads_path = Path.cwd()
+
+    if practical_num is None or str(practical_num).lower() == 'all':
+        target_dir = downloads_path / "BDA_Practicals"
+    else:
+        target_dir = downloads_path / f"BDA_Practical_{practical_num}"
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+    return target_dir
+
+
+def download(practical_num=3, target_dir=None, open_folder=True):
+    """
+    Downloads/exports the specified BDA practical script
+    directly to the user's Downloads folder or a specified target directory.
+    """
+    if not TEMPLATES:
+        _load_templates()
+
+    if isinstance(practical_num, str) and practical_num.lower() == 'all':
+        numbers = sorted(list(TEMPLATES.keys()))
+        if target_dir is None:
+            target_path = get_default_download_dir('all')
+        else:
+            target_path = Path(target_dir)
+            target_path.mkdir(parents=True, exist_ok=True)
+    else:
+        try:
+            num = int(practical_num)
+            if num not in TEMPLATES:
+                available = ", ".join(map(str, sorted(TEMPLATES.keys())))
+                raise ValueError(f"Practical {num} not found. Available practicals: {available}")
+            numbers = [num]
+            if target_dir is None:
+                target_path = get_default_download_dir(num)
+            else:
+                target_path = Path(target_dir)
+                target_path.mkdir(parents=True, exist_ok=True)
+        except ValueError as e:
+            raise ValueError(f"Invalid practical number: '{practical_num}'. {e}")
+
+    created_files = []
+
+    for num in numbers:
+        py_filename = f"practical_{num}.py"
+        py_filepath = target_path / py_filename
+        with open(py_filepath, 'w', encoding='utf-8') as f:
+            f.write(TEMPLATES[num])
+        created_files.append((py_filename, PRACTICAL_NAMES.get(num, "BDA Practical")))
+
+    print("\n" + "=" * 65)
+    print("SUCCESS! Downloaded BDA Practical files:")
+    print(f"Folder: {target_path}")
+    for fname, desc in created_files:
+        print(f"  - {fname}  ({desc})")
+    print("=" * 65)
+    print("To run:")
+    if len(numbers) == 1:
+        print(f"  cd \"{target_path}\"")
+        print(f"  python practical_{numbers[0]}.py")
+    else:
+        print(f"  cd \"{target_path}\"")
+        print("  python practical_3.py  (or practical_5.py, practical_6.py, practical_7.py)")
+    print("=" * 65 + "\n")
+
+    # Automatically open folder in Windows Explorer / OS file manager
+    if open_folder and sys.platform == 'win32':
+        try:
+            os.startfile(target_path)
+        except Exception:
+            pass
+
+    return str(target_path)

bda_practicals-0.1.0/bda_package/practical_3.py

@@ -0,0 +1,86 @@
+from collections import defaultdict
+
+# ==========================================
+# 1. MAPPER FUNCTION
+# ==========================================
+def mapper(document_id: int, text: str):
+    """
+    Takes a document, cleans/tokenizes it, and emits 
+    key-value pairs of the format: (word, 1).
+    """
+    mapped_pairs = []
+    # Convert text to lowercase and split into words
+    words = text.lower().split()
+    
+    for word in words:
+        # Strip common punctuation marks
+        cleaned_word = word.strip(".,!?;:\"'")
+        if cleaned_word:
+            mapped_pairs.append((cleaned_word, 1))
+            
+    return mapped_pairs
+
+
+# ==========================================
+# 2. SHUFFLE & SORT PHASE (Framework step)
+# ==========================================
+def shuffle_and_sort(mapped_results):
+    """
+    Groups all values associated with the same key (word) 
+    into a single list: {word: [1, 1, 1, ...]}
+    """
+    grouped_data = defaultdict(list)
+    for word, count in mapped_results:
+        grouped_data[word].append(count)
+    return grouped_data
+
+
+# ==========================================
+# 3. REDUCER FUNCTION
+# ==========================================
+def reducer(word, counts):
+    """
+    Takes a word and its list of counts, aggregates them, 
+    and outputs the final total frequency for that word.
+    """
+    return (word, sum(counts))
+
+
+# ==========================================
+# DRIVER PROGRAM / SIMULATION
+# ==========================================
+def run():
+    # Sample input dataset (representing multiple documents/lines in a stream)
+    documents = {
+        1: "Big Data analysis using MapReduce framework.",
+        2: "MapReduce is a programming model for data processing.",
+        3: "Big data and map reduce make data processing fast and scalable."
+    }
+
+    print("=== Step 1: Mapping Phase ===")
+    all_mapped = []
+    for doc_id, text in documents.items():
+        pairs = mapper(doc_id, text)
+        print(f"Doc {doc_id} Mapped -> {pairs}")
+        all_mapped.extend(pairs)
+
+    print("\n=== Step 2: Shuffle and Sort Phase ===")
+    grouped_data = shuffle_and_sort(all_mapped)
+    for word, counts in grouped_data.items():
+        print(f"Key: '{word}' => Values: {counts}")
+
+    print("\n=== Step 3: Reducing Phase ===")
+    final_word_counts = {}
+    for word, counts in grouped_data.items():
+        reduced_word, total_count = reducer(word, counts)
+        final_word_counts[reduced_word] = total_count
+
+    print("\n=== Final Output (Word Counts) ===")
+    for word, count in sorted(final_word_counts.items()):
+        print(f"  {word}: {count}")
+
+    return final_word_counts
+
+
+if __name__ == "__main__":
+    run()

bda_practicals-0.1.0/bda_package/practical_5.py

@@ -0,0 +1,162 @@
+class DGIMStream:
+    def __init__(self, window_size: int):
+        self.window_size = window_size
+        self.current_time = 0
+        self.buckets = []
+
+    def _resolve_buckets(self, verbose: bool = False):
+        i = 0
+        while i < len(self.buckets):
+            current_size = self.buckets[i]['size']
+            matching_indices = [idx for idx, b in enumerate(self.buckets) if b['size'] == current_size]
+            if len(matching_indices) > 2:
+                if verbose:
+                    print(f"    [MERGE TRIGGER] Found {len(matching_indices)} buckets of size {current_size}. Merging the two oldest...")
+                
+                oldest_idx_2 = matching_indices[-1]
+                oldest_idx_1 = matching_indices[-2]
+              
+                merged_size = current_size * 2
+                merged_timestamp = self.buckets[oldest_idx_1]['timestamp']
+                
+                if verbose:
+                    print(f"      - Merging bucket (size {current_size}, ts {self.buckets[oldest_idx_2]['timestamp']}) "
+                          f"and bucket (size {current_size}, ts {self.buckets[oldest_idx_1]['timestamp']})")
+                    print(f"      - Created new bucket: size {merged_size}, timestamp {merged_timestamp}")
+
+                del self.buckets[oldest_idx_2]
+                del self.buckets[oldest_idx_1]
+
+                inserted = False
+                for idx, b in enumerate(self.buckets):
+                    if b['timestamp'] < merged_timestamp:
+                        self.buckets.insert(idx, {'size': merged_size, 'timestamp': merged_timestamp})
+                        inserted = True
+                        break
+                if not inserted:
+                    self.buckets.append({'size': merged_size, 'timestamp': merged_timestamp})
+                
+                # Restart check from the beginning to handle cascading merges
+                i = 0
+            else:
+                i += 1
+
+    def add_bit(self, bit: int, verbose: bool = True):
+        """Processes an incoming bit (0 or 1) into the stream."""
+        if bit not in (0, 1):
+            print("Error: Bit must be 0 or 1.")
+            return
+
+        self.current_time += 1
+        if verbose:
+            print(f"\n[STREAM EVENT] Time t={self.current_time} | Received Bit: {bit}")
+
+        # Expire old buckets outside the current sliding window window_size
+        cutoff_time = self.current_time - self.window_size
+        expired_buckets = [b for b in self.buckets if b['timestamp'] <= cutoff_time]
+        if expired_buckets and verbose:
+            print(f"    [EXPIRY] Removing buckets with timestamp <= {cutoff_time}")
+        self.buckets = [b for b in self.buckets if b['timestamp'] > cutoff_time]
+
+        # If bit is 1, create a new bucket of size 1 at the current timestamp
+        if bit == 1:
+            if verbose:
+                print(f"    [INSERT] Bit is 1. Adding new bucket: size=1, timestamp={self.current_time}")
+            self.buckets.insert(0, {'size': 1, 'timestamp': self.current_time})
+            self._resolve_buckets(verbose=verbose)
+        else:
+            if verbose:
+                print(f"    [INFO] Bit is 0. No new bucket created.")
+
+        if verbose:
+            self.print_buckets()
+
+    def query(self, k: int) -> int:
+        """Estimates the number of 1s in the last k elements of the stream."""
+        if k <= 0:
+            return 0
+        
+        start_time = self.current_time - k + 1
+        estimated_ones = 0
+        
+        print(f"\n[QUERY EVALUATION] Estimating 1s in last {k} elements (Window: t={start_time} to t={self.current_time})")
+        
+        last_bucket = None
+        for b in self.buckets:
+            if b['timestamp'] >= start_time:
+                estimated_ones += b['size']
+                print(f"  - Fully inside window: Bucket(size={b['size']}, ts={b['timestamp']}) -> Added {b['size']}")
+            else:
+                # This bucket is partially outside the window
+                last_bucket = b
+                print(f"  - Partially outside window: Bucket(size={b['size']}, ts={b['timestamp']}) -> Will add half weight")
+                break
+
+        # DGIM Heuristic: Add half the size of the oldest bucket that overlaps the boundary
+        if last_bucket:
+            half_size = last_bucket['size'] // 2
+            estimated_ones += half_size
+            print(f"  -> Added half of boundary bucket size ({last_bucket['size']} / 2 = {half_size})")
+
+        print(f"Final Estimated Count of 1s in last {k} elements: **{estimated_ones}**\n")
+        return estimated_ones
+
+    def print_buckets(self):
+        """Displays the current structural state of DGIM buckets."""
+        print(f"[CURRENT BUCKETS STATE (Newest -> Oldest)]")
+        if not self.buckets:
+            print("  (No active buckets)")
+        else:
+            for idx, b in enumerate(self.buckets):
+                print(f"  [{idx}] Size: {b['size']} | Timestamp: {b['timestamp']}")
+        print("")
+
+
+def main():
+    try:
+        window_size = int(input("Enter sliding window size N  "))
+    except ValueError:
+        print("Invalid input. Using default window size N=10.")
+        window_size = 10
+
+    dgim = DGIMStream(window_size=window_size)
+
+    while True:
+        print("Menu:")
+        print("  1. Add a bit to stream (0 or 1)")
+        print("  2. Query count of 1s in last k elements")
+        print("  3. View current buckets state")
+        print("  4. Exit")
+        
+        choice = input("\nChoose an option (1-4): ").strip()
+
+        if choice == '1':
+            try:
+                bit = int(input("Enter bit (0 or 1): ").strip())
+                if bit in (0, 1):
+                    dgim.add_bit(bit, verbose=True)
+                else:
+                    print("Please enter strictly 0 or 1.")
+            except ValueError:
+                print("Invalid input. Enter an integer 0 or 1.")
+        elif choice == '2':
+            try:
+                k = int(input(f"Enter query length k (1 to {dgim.window_size}): ").strip())
+                dgim.query(k)
+            except ValueError:
+                print("Invalid input. Enter a valid integer.")
+        elif choice == '3':
+            dgim.print_buckets()
+        elif choice == '4':
+            print("Exiting DGIM Stream CLI. Goodbye!")
+            break
+        else:
+            print("Invalid option. Please choose between 1 and 4.")
+
+
+def run():
+    main()
+
+
+if __name__ == "__main__":
+    main()

bda_practicals-0.1.0/bda_package/practical_6.py

@@ -0,0 +1,95 @@
+import hashlib
+
+class FlajoletMartin:
+    def __init__(self, num_hashes: int = 4):
+        self.num_hashes = num_hashes
+        self.max_zeros = [0] * num_hashes
+        self.stream_count = 0
+
+    def _hash(self, item: str, seed: int, verbose: bool = False) -> int:
+        salted = (str(seed) + item).encode('utf-8')
+        digest_hex = hashlib.md5(salted).hexdigest()
+        digest_int = int(digest_hex, 16)
+        if verbose:
+            print(f"  [Hash Function #{seed + 1}]")
+            print(f"    - Salted String : '{salted.decode()}'")
+            print(f"    - MD5 Hex Digest: {digest_hex}")
+            print(f"    - Integer Value : {digest_int}")
+        return digest_int
+
+    def _trailing_zeros(self, n: int) -> int:
+        if n == 0:
+            return 0
+        return (n & -n).bit_length() - 1
+
+    def add_item(self, item: str, verbose: bool = True):
+        self.stream_count += 1
+        if verbose:
+            print(f"\n[STREAM ITEM #{self.stream_count}] Processing item: '{item}'")
+        for i in range(self.num_hashes):
+            h_val = self._hash(item, seed=i, verbose=verbose)
+            tz = self._trailing_zeros(h_val)
+            prev_max = self.max_zeros[i]
+            updated = False
+            if tz > prev_max:
+                self.max_zeros[i] = tz
+                updated = True
+            if verbose:
+                print(f"    - Trailing Zeros (R): {tz}")
+                print(f"    - Max R[{i+1}] Tracked: {prev_max} -> Updated Max: {self.max_zeros[i]} {'(NEW MAX!)' if updated else ''}")
+        
+        if verbose:
+            print(f"Current Max Zeros Array across all hash functions: {self.max_zeros}\n")
+
+    def get_estimate(self) -> float:
+        phi = 0.77351  
+        avg_two_to_r = sum(2 ** r for r in self.max_zeros) / self.num_hashes
+        estimate = avg_two_to_r / phi
+        return round(estimate, 2)
+
+
+def main():
+    try:
+        num_hashes = int(input("Enter number of hash functions: "))
+    except ValueError:
+        print("Invalid input. Using default: 4 hash functions.")
+        num_hashes = 4
+
+    fm = FlajoletMartin(num_hashes=num_hashes)
+
+    while True:
+        print("Menu:")
+        print("  1. Add an item to stream")
+        print("  2. View current distinct element estimation")
+        print("  3. View current Max Zeros array state (R)")
+        print("  4. Exit")
+        choice = input("\nChoose an option (1-4): ").strip()
+        if choice == '1':
+            item = input("Enter item/element: ").strip()
+            if item:
+                fm.add_item(item, verbose=True)
+            else:
+                print("Item cannot be empty.")
+        elif choice == '2':
+            estimate = fm.get_estimate()
+            print(f"\n[ESTIMATION REPORT]")
+            print(f"  - Total items processed   : {fm.stream_count}")
+            print(f"  - Max Zeros Array (R)     : {fm.max_zeros}")
+            print(f"  - Estimated Distinct Count: **{estimate}**\n")
+        elif choice == '3':
+            print(f"\n[STATE INSPECTION]")
+            print(f"  - Total items streamed : {fm.stream_count}")
+            print(f"  - Max Zeros Array (R)  : {fm.max_zeros}\n")
+        elif choice == '4':
+            print("Exiting FM Algorithm CLI. Goodbye!")
+            break
+        else:
+            print("Invalid option. Please choose between 1 and 4.")
+
+
+def run():
+    main()
+
+
+if __name__ == "__main__":
+    main()

bda_practicals-0.1.0/bda_package/practical_7.py

@@ -0,0 +1,149 @@
+import hashlib
+
+class BloomFilter:
+    def __init__(self, size: int, num_hashes: int):
+        self.size = size
+        self.num_hashes = num_hashes
+        self.bit_array = [0] * size
+
+    def _hashes(self, item: str, verbose: bool = False):
+        """Generates k different hash indices for a given item, with optional detailed logging."""
+        indices = []
+        if verbose:
+            print(f"[DEBUG] Processing item: '{item}'")
+            print(f"[DEBUG] Target Bit Array Size: {self.size}, Hash Count: {self.num_hashes}")
+
+        for i in range(self.num_hashes):
+            # Create salted string and encode to bytes
+            salted_str = str(i) + item
+            salted_bytes = salted_str.encode('utf-8')
+            
+            # Generate MD5 hash digest
+            digest_hex = hashlib.md5(salted_bytes).hexdigest()
+            
+            # Convert hex digest to integer and map to array index
+            digest_int = int(digest_hex, 16)
+            index = digest_int % self.size
+            indices.append(index)
+
+            if verbose:
+                print(f"  [Hash #{i + 1}]")
+                print(f"    - Salted String : '{salted_str}'")
+                print(f"    - Byte Encoding : {list(salted_bytes)}")
+                print(f"    - MD5 Hex Digest: {digest_hex}")
+                print(f"    - Integer Value : {digest_int}")
+                print(f"    - Mapped Index  : {digest_int} % {self.size} = **Index {index}**")
+
+        if verbose:
+            print(f"[DEBUG] Final Computed Indices: {indices}")
+
+        return indices
+
+    def add(self, item: str, verbose: bool = True):
+        """Adds an item to the Bloom filter and displays bit changes."""
+        if verbose:
+            print(f"\n[ADD OPERATION] Adding '{item}'...")
+            
+        indices = self._hashes(item, verbose=verbose)
+        
+        changed_bits = []
+        for index in indices:
+            previous_state = self.bit_array[index]
+            self.bit_array[index] = 1
+            changed_bits.append((index, previous_state, self.bit_array[index]))
+
+        if verbose:
+            print(f"[BIT-FLIP SUMMARY]")
+            for idx, prev, curr in changed_bits:
+                status = "changed 0 -> 1" if prev == 0 else "already 1"
+                print(f"  - Bit Index [{idx}]: {status}")
+            self.print_bit_array()
+
+    def check(self, item: str, verbose: bool = True) -> bool:
+        """Checks if an item is in the Bloom filter with detailed inspection steps."""
+        if verbose:
+            print(f"\n[CHECK OPERATION] Checking if '{item}' exists...")
+
+        indices = self._hashes(item, verbose=verbose)
+        
+        exists = True
+        if verbose:
+            print(f"[LOOKUP EVALUATION]")
+
+        for index in indices:
+            val = self.bit_array[index]
+            if verbose:
+                print(f"  - Inspecting Index [{index}]: Found value **{val}**")
+            if val == 0:
+                exists = False
+
+        if verbose:
+            print(f"  -> Conclusion: All indices checked. Final result = {exists}")
+
+        return exists
+
+    def print_bit_array(self):
+        print(f"\n[CURRENT BIT ARRAY STATE]")
+        if self.size <= 60:
+            indices_str = " ".join(f"{i:2}" for i in range(self.size))
+            separator = "-" * len(indices_str)
+            print(f"  Indices: {indices_str}")
+            print(f"           {separator}")
+            bits_str = " ".join(f"{b:2}" for b in self.bit_array)
+            print(f"  Values : {bits_str}")
+        else:
+            non_zero_count = sum(self.bit_array)
+            print(f"  Size: {self.size} bits | Active bits (1s): {non_zero_count} | Zero bits (0s): {self.size - non_zero_count}")
+            print(f"  Raw Bit Array  {self.bit_array[:50]}...")
+        print("")
+
+
+def main():
+    try:
+        size = int(input("Enter bit array size: "))
+        num_hashes = int(input("Enter number of hash functions: "))
+    except ValueError:
+        print("Using default values: size=40, num_hashes=3")
+        size, num_hashes = 40, 3
+
+    bf = BloomFilter(size, num_hashes)
+    bf.print_bit_array()
+
+    while True:
+        print("Menu:")
+        print("  1. Add an item")
+        print("  2. Check an item")
+        print("  3. View current bit array")
+        print("  4. Exit")
+        choice = input("\nChoose an option (1-4): ").strip()
+        if choice == '1':
+            item = input("Enter string to add: ").strip()
+            if item:
+                bf.add(item, verbose=True)
+            else:
+                print("Item cannot be empty.")
+        elif choice == '2':
+            item = input("Enter string to check: ").strip()
+            if item:
+                found = bf.check(item, verbose=True)
+                if found:
+                    print(f"RESULT: '{item}' **MIGHT BE PRESENT** in the set.")
+                else:
+                    print(f"RESULT: '{item}' is **DEFINITELY NOT PRESENT** in the set.")
+            else:
+                print("Item cannot be empty.")
+        elif choice == '3':
+            bf.print_bit_array()
+        elif choice == '4':
+            print("Exiting Bloom Filter CLI. Goodbye!")
+            break
+        else:
+            print("Invalid option. Please choose between 1 and 4.")
+
+
+def run():
+    main()
+
+
+if __name__ == "__main__":
+    main()

bda_practicals-0.1.0/bda_practicals.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: bda-practicals
+Version: 0.1.0
+Summary: A collection of Big Data Analytics (BDA) practicals with instant one-word download commands (bda-3, bda-5, bda-6, bda-7).
+Home-page: https://github.com/yourusername/bda-practicals
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# Big Data Analytics Practicals (`bda-practicals`)
+
+A complete collection of Big Data Analytics (BDA) practical implementations with **instant one-word download commands** (`bda-3`, `bda-5`, `bda-6`, `bda-7`).
+
+---
+
+## ⚡ Instant One-Word Commands
+
+Once installed via pip, just type the practical number you want:
+
+| Command | Action | Output File in Downloads |
+|---|---|---|
+| **`bda-3`** | Downloads **Practical 3** (MapReduce Word Count Simulation) | `practical_3.py` |
+| **`bda-5`** | Downloads **Practical 5** (DGIM Algorithm for Counting 1s) | `practical_5.py` |
+| **`bda-6`** | Downloads **Practical 6** (Flajolet-Martin Algorithm for Distinct Count) | `practical_6.py` |
+| **`bda-7`** | Downloads **Practical 7** (Bloom Filter Implementation) | `practical_7.py` |
+
+> Running any command like `bda-5` immediately puts the clean `.py` file into your **Downloads** folder and **pops open Windows Explorer** so you can view, edit, and run the code!
+
+### Download All Practicals at Once:
+```bash
+bda all
+# OR
+bda-all
+```
+
+---
+
+## 🚀 How to Run on Any Computer
+
+1. Open Terminal or Command Prompt:
+   ```bash
+   pip install bda-practicals
+   ```
+2. Download any practical:
+   ```bash
+   bda-5
+   # (Or bda-3, bda-6, bda-7)
+   ```
+3. Open the folder and run:
+   ```bash
+   python practical_5.py
+   ```
+
+---
+
+## License
+MIT License

bda_practicals-0.1.0/bda_practicals.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+bda/__init__.py
+bda/__main__.py
+bda_package/__init__.py
+bda_package/__main__.py
+bda_package/downloader.py
+bda_package/practical_3.py
+bda_package/practical_5.py
+bda_package/practical_6.py
+bda_package/practical_7.py
+bda_practicals.egg-info/PKG-INFO
+bda_practicals.egg-info/SOURCES.txt
+bda_practicals.egg-info/dependency_links.txt
+bda_practicals.egg-info/entry_points.txt
+bda_practicals.egg-info/top_level.txt

bda_practicals-0.1.0/bda_practicals.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bda_practicals-0.1.0/bda_practicals.egg-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+bda = bda_package.__main__:main
+bda-3 = bda_package.__main__:cli_p3
+bda-5 = bda_package.__main__:cli_p5
+bda-6 = bda_package.__main__:cli_p6
+bda-7 = bda_package.__main__:cli_p7
+bda-all = bda_package.__main__:main
+bda-practicals = bda_package.__main__:main

bda_practicals-0.1.0/bda_practicals.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+bda
+bda_package

bda_practicals-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

bda_practicals-0.1.0/setup.cfg

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

bda_practicals-0.1.0/setup.py

@@ -0,0 +1,38 @@
+import os
+from setuptools import setup, find_namespace_packages
+
+long_description = ""
+if os.path.exists('README.md'):
+    with open('README.md', 'r', encoding='utf-8') as f:
+        long_description = f.read()
+
+setup(
+    name='bda-practicals',
+    version='0.1.0',
+    packages=find_namespace_packages(include=['bda_package', 'bda_package.*', 'bda', 'bda.*']),
+    include_package_data=True,
+    install_requires=[],  # Standard library only (hashlib, collections, etc.)
+    entry_points={
+        'console_scripts': [
+            'bda-3=bda_package.__main__:cli_p3',
+            'bda-5=bda_package.__main__:cli_p5',
+            'bda-6=bda_package.__main__:cli_p6',
+            'bda-7=bda_package.__main__:cli_p7',
+            'bda=bda_package.__main__:main',
+            'bda-all=bda_package.__main__:main',
+            'bda-practicals=bda_package.__main__:main',
+        ],
+    },
+    description='A collection of Big Data Analytics (BDA) practicals with instant one-word download commands (bda-3, bda-5, bda-6, bda-7).',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    author='Your Name',
+    author_email='your.email@example.com',
+    url='https://github.com/yourusername/bda-practicals',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.8',
+)