Pomodoro Timer

import os

import json

import time

import threading

from datetime import datetime, date, timedelta

from pathlib import Path

from collections import defaultdict

try:

    import matplotlib.pyplot as plt

    MATPLOTLIB_OK = True

except ImportError:

    MATPLOTLIB_OK = False

try:

    import winsound

    SOUND_ENGINE = "winsound"

except ImportError:

    try:

        import subprocess

        SOUND_ENGINE = "subprocess"

    except:

        SOUND_ENGINE = None

# ============================================================

# CONFIGURATION

# ============================================================

DATA_FILE = "pomodoro_data.json"

DEFAULT_CONFIG = {

    "work_minutes":       25,

    "short_break":        5,

    "long_break":         15,

    "sessions_before_long": 4,

    "auto_start_break":   False,

    "sound_enabled":      True,

    "daily_goal":         8,       # pomodoros per day

}

# ============================================================

# HELPERS

# ============================================================

def clear():

    os.system("cls" if os.name == "nt" else "clear")

def fmt_time(seconds):

    m = seconds // 60

    s = seconds % 60

    return f"{m:02d}:{s:02d}"

def draw_bar(value, max_val, width=30, fill="█", empty="░"):

    if max_val == 0:

        return ""

    filled = int((min(value, max_val) / max_val) * width)

    return fill * filled + empty * (width - filled)

def beep(times=1):

    """Play a beep sound — cross platform."""

    for _ in range(times):

        if SOUND_ENGINE == "winsound":

            try:

                winsound.Beep(1000, 400)

            except:

                print("\a")

        elif SOUND_ENGINE == "subprocess":

            try:

                subprocess.run(["paplay", "/usr/share/sounds/freedesktop/stereo/complete.oga"],

                               capture_output=True)

            except:

                print("\a")

        else:

            print("\a")

        time.sleep(0.2)

# ============================================================

# LOAD & SAVE DATA

# ============================================================

def load_data():

    if Path(DATA_FILE).exists():

        try:

            with open(DATA_FILE, "r") as f:

                return json.load(f)

        except:

            pass

    return {

        "config":   DEFAULT_CONFIG.copy(),

        "sessions": [],

        "tasks":    []

    }

def save_data(data):

    with open(DATA_FILE, "w") as f:

        json.dump(data, f, indent=2)

# ============================================================

# TIMER ENGINE

# ============================================================

class PomodoroTimer:

    def __init__(self, data):

        self.data          = data

        self.config        = data.get("config", DEFAULT_CONFIG.copy())

        self.running       = False

        self.paused        = False

        self.current_type  = "work"      # work / short_break / long_break

        self.seconds_left  = 0

        self.session_count = 0           # completed work sessions today

        self.total_today   = self._count_today()

        self.current_task  = ""

        self._thread       = None

        self._pause_event  = threading.Event()

        self._pause_event.set()

    def _count_today(self):

        today = str(date.today())

        return sum(1 for s in self.data["sessions"]

                   if s.get("date") == today and s.get("type") == "work")

    def _duration(self, session_type):

        if session_type == "work":

            return self.config["work_minutes"] * 60

        elif session_type == "short_break":

            return self.config["short_break"] * 60

        else:

            return self.config["long_break"] * 60

    def start(self, session_type="work", task=""):

        if self.running:

            print("  Timer already running.")

            return

        self.current_type = session_type

        self.seconds_left = self._duration(session_type)

        self.current_task = task

        self.running      = True

        self.paused       = False

        self._pause_event.set()

        self._thread = threading.Thread(

            target=self._countdown, daemon=True

        )

        self._thread.start()

    def _countdown(self):

        start_time = datetime.now()

        while self.seconds_left > 0 and self.running:

            self._pause_event.wait()   # blocks if paused

            if not self.running:

                break

            self._display_timer()

            time.sleep(1)

            if not self.paused:

                self.seconds_left -= 1

        if self.running and self.seconds_left <= 0:

            self._on_complete(start_time)

        self.running = False

    def _display_timer(self):

        clear()

        icons = {"work": "WORK", "short_break": "SHORT BREAK", "long_break": "LONG BREAK"}

        total = self._duration(self.current_type)

        elapsed = total - self.seconds_left

        pct = elapsed / total * 100 if total else 0

        bar = draw_bar(elapsed, total, width=35)

        print("\n" + "="*55)

        print(f"   POMODORO TIMER  —  {icons[self.current_type]}")

        print("="*55)

        print(f"\n   {fmt_time(self.seconds_left)}  remaining")

        print(f"\n   {bar}  {pct:.0f}%\n")

        if self.current_task:

            print(f"   Task: {self.current_task}")

        print(f"\n   Sessions today : {self.total_today + (1 if self.current_type == 'work' else 0)}"

              f" / {self.config['daily_goal']} goal")

        print(f"   Session #      : {self.session_count + 1}")

        status = "PAUSED" if self.paused else "RUNNING"

        print(f"\n   [{status}]  Ctrl+C or menu to stop")

        print("="*55)

    def _on_complete(self, start_time):

        end_time = datetime.now()

        if self.config.get("sound_enabled"):

            beep(3 if self.current_type == "work" else 1)

        # Log session

        session = {

            "type":       self.current_type,

            "date":       str(date.today()),

            "start":      start_time.strftime("%H:%M:%S"),

            "end":        end_time.strftime("%H:%M:%S"),

            "duration":   self._duration(self.current_type) // 60,

            "task":       self.current_task,

            "completed":  True,

        }

        self.data["sessions"].append(session)

        save_data(self.data)

        if self.current_type == "work":

            self.session_count += 1

            self.total_today   += 1

        clear()

        print("\n" + "="*55)

        icon = "WORK SESSION COMPLETE!" if self.current_type == "work" else "BREAK OVER!"

        print(f"   {icon}")

        print("="*55)

        if self.current_type == "work":

            print(f"\n   Great work! Session {self.session_count} done.")

            if self.total_today >= self.config["daily_goal"]:

                print(f"   DAILY GOAL REACHED! {self.total_today} pomodoros today!")

            # Determine next break

            if self.session_count % self.config["sessions_before_long"] == 0:

                print(f"   Next: LONG BREAK ({self.config['long_break']} min)")

            else:

                print(f"   Next: SHORT BREAK ({self.config['short_break']} min)")

        else:

            print(f"\n   Break done. Ready for the next work session!")

        print()

    def pause(self):

        if not self.running:

            return

        self.paused = True

        self._pause_event.clear()

        print("  Timer paused.")

    def resume(self):

        if not self.running:

            return

        self.paused = False

        self._pause_event.set()

        print("  Timer resumed.")

    def stop(self):

        self.running = False

        self._pause_event.set()   # unblock if paused

        print("  Timer stopped.")

    def status(self):

        if not self.running:

            print("\n  No timer running.")

            return

        state = "PAUSED" if self.paused else "RUNNING"

        icons = {"work": "Work", "short_break": "Short Break",

                 "long_break": "Long Break"}

        print(f"\n  [{state}] {icons[self.current_type]}: "

              f"{fmt_time(self.seconds_left)} remaining")

# ============================================================

# STATS & REPORTS

# ============================================================

def stats_today(data):

    today    = str(date.today())

    sessions = [s for s in data["sessions"] if s.get("date") == today]

    work     = [s for s in sessions if s.get("type") == "work"]

    breaks   = [s for s in sessions if s.get("type") != "work"]

    goal     = data["config"].get("daily_goal", 8)

    print("\n" + "="*55)

    print(f"  TODAY'S STATS  —  {today}")

    print("="*55)

    print(f"  Pomodoros    : {len(work)} / {goal}")

    bar = draw_bar(len(work), goal)

    print(f"  Progress     : {bar}")

    print(f"  Work time    : {len(work) * data['config']['work_minutes']} min")

    print(f"  Breaks       : {len(breaks)}")

    if work:

        tasks = [s["task"] for s in work if s.get("task")]

        if tasks:

            print(f"\n  Tasks worked on:")

            for t in set(tasks):

                count = tasks.count(t)

                print(f"    • {t}  ({count} pomodoro{'s' if count > 1 else ''})")

    if len(work) >= goal:

        print(f"\n  DAILY GOAL REACHED!")

    else:

        remaining = goal - len(work)

        print(f"\n  {remaining} more pomodoro(s) to reach daily goal.")

    print("="*55)

def stats_weekly(data):

    sessions = data["sessions"]

    today    = date.today()

    # Last 7 days

    daily = {}

    for i in range(6, -1, -1):

        d = str(today - timedelta(days=i))

        daily[d] = 0

    for s in sessions:

        d = s.get("date", "")

        if d in daily and s.get("type") == "work":

            daily[d] += 1

    max_count = max(daily.values()) if daily else 1

    goal = data["config"].get("daily_goal", 8)

    print("\n" + "="*55)

    print("  WEEKLY STATS  (Last 7 Days)")

    print("="*55)

    total_week = 0

    for d, count in daily.items():

        try:

            label = datetime.strptime(d, "%Y-%m-%d").strftime("%a %d %b")

        except:

            label = d

        bar   = draw_bar(count, max(max_count, goal), width=25)

        goal_marker = " GOAL!" if count >= goal else ""

        print(f"  {label:<12} {count:>3} {bar}{goal_marker}")

        total_week += count

    avg = total_week / 7

    print("="*55)

    print(f"  Total this week : {total_week} pomodoros")

    print(f"  Daily average   : {avg:.1f}")

    print(f"  Daily goal      : {goal}")

    print("="*55)

def stats_all_time(data):

    sessions = data["sessions"]

    work     = [s for s in sessions if s.get("type") == "work"]

    if not work:

        print("\n  No sessions recorded yet.")

        return

    total_pomodoros = len(work)

    total_minutes   = sum(s.get("duration", 25) for s in work)

    total_hours     = total_minutes / 60

    # Most productive day

    day_counts = defaultdict(int)

    for s in work:

        day_counts[s.get("date", "")] += 1

    best_day   = max(day_counts, key=day_counts.get)

    best_count = day_counts[best_day]

    # Most worked task

    task_counts = defaultdict(int)

    for s in work:

        t = s.get("task", "")

        if t:

            task_counts[t] += 1

    print("\n" + "="*55)

    print("  ALL-TIME STATS")

    print("="*55)

    print(f"  Total pomodoros : {total_pomodoros:,}")

    print(f"  Total work time : {total_hours:.1f} hours  ({total_minutes:,} min)")

    print(f"  Days tracked    : {len(day_counts)}")

    print(f"  Avg per day     : {total_pomodoros / max(len(day_counts), 1):.1f}")

    print(f"  Best day        : {best_day}  ({best_count} pomodoros)")

    if task_counts:

        top_task  = max(task_counts, key=task_counts.get)

        print(f"  Most worked on  : {top_task}  ({task_counts[top_task]} sessions)")

    print("="*55)

def recent_sessions(data, n=10):

    sessions = data["sessions"]

    if not sessions:

        print("\n  No sessions yet.")

        return

    print("\n" + "="*65)

    print(f"  RECENT SESSIONS  (last {n})")

    print("="*65)

    print(f"  {'DATE':<12} {'TYPE':<14} {'START':<10} {'DUR':>5}  TASK")

    print("  " + "-"*60)

    for s in reversed(sessions[-n:]):

        stype = s.get("type", "").replace("_", " ").upper()

        dur   = f"{s.get('duration', '?')}m"

        task  = s.get("task", "")[:25]

        print(f"  {s.get('date',''):<12} {stype:<14} "

              f"{s.get('start',''):<10} {dur:>5}  {task}")

    print("="*65)

# ============================================================

# MATPLOTLIB CHART

# ============================================================

def plot_weekly_chart(data):

    if not MATPLOTLIB_OK:

        print("\n  matplotlib not installed.")

        print("  Install: pip install matplotlib")

        return

    sessions = data["sessions"]

    today    = date.today()

    daily    = {}

    for i in range(13, -1, -1):

        d = str(today - timedelta(days=i))

        daily[d] = 0

    for s in sessions:

        d = s.get("date", "")

        if d in daily and s.get("type") == "work":

            daily[d] += 1

    labels = []

    values = list(daily.values())

    for d in daily.keys():

        try:

            labels.append(datetime.strptime(d, "%Y-%m-%d").strftime("%d %b"))

        except:

            labels.append(d)

    goal   = data["config"].get("daily_goal", 8)

    colors = ["#2ecc71" if v >= goal else "#3498db" for v in values]

    fig, ax = plt.subplots(figsize=(13, 5))

    bars = ax.bar(labels, values, color=colors, alpha=0.85, width=0.6)

    # Goal line

    ax.axhline(y=goal, color="#e74c3c", linestyle="--",

               linewidth=1.5, label=f"Daily goal ({goal})")

    # Value labels on bars

    for bar, val in zip(bars, values):

        if val > 0:

            ax.text(bar.get_x() + bar.get_width() / 2,

                    bar.get_height() + 0.1,

                    str(val), ha="center", va="bottom", fontsize=9)

    ax.set_title("Pomodoro Sessions — Last 14 Days",

                 fontsize=13, fontweight="bold")

    ax.set_ylabel("Pomodoros")

    ax.set_xlabel("Date")

    ax.legend()

    ax.grid(axis="y", alpha=0.3)

    plt.xticks(rotation=45, ha="right")

    plt.tight_layout()

    from io import BytesIO

    buf = BytesIO()

    plt.savefig("pomodoro_chart.png", dpi=120, bbox_inches="tight")

    print("\n  Chart saved: pomodoro_chart.png")

    plt.show()

# ============================================================

# SETTINGS

# ============================================================

def edit_settings(data):

    cfg = data["config"]

    print("\n" + "="*50)

    print("  SETTINGS")

    print("="*50)

    print(f"  1. Work duration    : {cfg['work_minutes']} min")

    print(f"  2. Short break      : {cfg['short_break']} min")

    print(f"  3. Long break       : {cfg['long_break']} min")

    print(f"  4. Sessions before long break: {cfg['sessions_before_long']}")

    print(f"  5. Daily goal       : {cfg['daily_goal']} pomodoros")

    print(f"  6. Sound enabled    : {cfg['sound_enabled']}")

    print(f"  7. Save & return")

    print("="*50)

    while True:

        sub = input("\n  Edit (1-7): ").strip()

        if sub == "1":

            v = input(f"  Work minutes [{cfg['work_minutes']}]: ").strip()

            if v.isdigit(): cfg["work_minutes"] = int(v)

        elif sub == "2":

            v = input(f"  Short break [{cfg['short_break']}]: ").strip()

            if v.isdigit(): cfg["short_break"] = int(v)

        elif sub == "3":

            v = input(f"  Long break [{cfg['long_break']}]: ").strip()

            if v.isdigit(): cfg["long_break"] = int(v)

        elif sub == "4":

            v = input(f"  Sessions before long [{cfg['sessions_before_long']}]: ").strip()

            if v.isdigit(): cfg["sessions_before_long"] = int(v)

        elif sub == "5":

            v = input(f"  Daily goal [{cfg['daily_goal']}]: ").strip()

            if v.isdigit(): cfg["daily_goal"] = int(v)

        elif sub == "6":

            cfg["sound_enabled"] = not cfg["sound_enabled"]

            print(f"  Sound: {cfg['sound_enabled']}")

        elif sub == "7":

            data["config"] = cfg

            save_data(data)

            print("  Settings saved.")

            break

        else:

            print("  Invalid option.")

# ============================================================

# MAIN MENU

# ============================================================

def print_menu(timer, data):

    cfg    = data["config"]

    today  = str(date.today())

    today_count = sum(1 for s in data["sessions"]

                      if s.get("date") == today and s.get("type") == "work")

    goal   = cfg["daily_goal"]

    status = "RUNNING" if timer.running else "IDLE"

    print("\n" + "-"*50)

    print(f"  POMODORO TIMER  [{status}]  "

          f"Today: {today_count}/{goal}")

    print("-"*50)

    print(f"  Work: {cfg['work_minutes']}m  |  "

          f"Short: {cfg['short_break']}m  |  "

          f"Long: {cfg['long_break']}m")

    print("-"*50)

    print("  1. Start WORK session")

    print("  2. Start SHORT BREAK")

    print("  3. Start LONG BREAK")

    print("  4. Pause / Resume timer")

    print("  5. Stop timer")

    print("  6. Today's stats")

    print("  7. Weekly stats")

    print("  8. All-time stats")

    print("  9. Recent sessions")

    print("  10. Plot chart (14-day)")

    print("  11. Settings")

    print("  0. Exit")

    print("-"*50)

def main():

    print("\n" + "="*55)

    print("     POMODORO TIMER WITH STATS")

    print("="*55)

    print("\n  The Pomodoro Technique:")

    print("  Work 25 min → Short break 5 min → Repeat x4 → Long break 15 min")

    data  = load_data()

    timer = PomodoroTimer(data)

    today = str(date.today())

    today_count = sum(1 for s in data["sessions"]

                      if s.get("date") == today and s.get("type") == "work")

    print(f"\n  Today so far: {today_count} pomodoro(s)")

    while True:

        print_menu(timer, data)

        choice = input("  > ").strip()

        if choice == "1":

            task = input("  What are you working on? (Enter to skip): ").strip()

            if timer.running:

                print("  Stop current timer first (option 5).")

            else:

                timer.start("work", task)

                print(f"\n  Work session started! ({data['config']['work_minutes']} min)")

                print("  Return to menu anytime — timer runs in background.")

        elif choice == "2":

            if timer.running:

                print("  Stop current timer first.")

            else:

                timer.start("short_break")

                print(f"\n  Short break started! ({data['config']['short_break']} min)")

        elif choice == "3":

            if timer.running:

                print("  Stop current timer first.")

            else:

                timer.start("long_break")

                print(f"\n  Long break started! ({data['config']['long_break']} min)")

        elif choice == "4":

            if timer.paused:

                timer.resume()

            else:

                timer.pause()

        elif choice == "5":

            timer.stop()

        elif choice == "6":

            stats_today(data)

        elif choice == "7":

            stats_weekly(data)

        elif choice == "8":

            stats_all_time(data)

        elif choice == "9":

            n = input("  Show last N sessions (default 10): ").strip()

            n = int(n) if n.isdigit() else 10

            recent_sessions(data, n)

        elif choice == "10":

            plot_weekly_chart(data)

        elif choice == "11":

            edit_settings(data)

            timer.config = data["config"]

        elif choice == "0":

            timer.stop()

            print("\n  Goodbye! Keep up the great work!\n")

            break

        else:

            print("  Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

    main()

File Encryption / Decryption Tool

 import os

import json

import hashlib

import base64

import secrets

import getpass

from datetime import datetime

from pathlib import Path

try:

    from cryptography.fernet import Fernet, InvalidToken

    from cryptography.hazmat.primitives import hashes

    from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC

    CRYPTO_OK = True

except ImportError:

    CRYPTO_OK = False

# ============================================================

# CONFIGURATION

# ============================================================

KEY_FILE      = "encryption.key"

VAULT_LOG     = "encryption_vault.json"

ENC_EXTENSION = ".encrypted"

SALT_SIZE     = 16       # bytes

ITERATIONS    = 480000   # PBKDF2 iterations (NIST recommended)

# ============================================================

# HELPERS

# ============================================================

def format_size(size_bytes):

    for unit in ["B", "KB", "MB", "GB"]:

        if size_bytes < 1024:

            return f"{size_bytes:.1f} {unit}"

        size_bytes /= 1024

    return f"{size_bytes:.1f} GB"

def file_checksum(filepath):

    """Return MD5 checksum of a file."""

    h = hashlib.md5()

    with open(filepath, "rb") as f:

        while chunk := f.read(8192):

            h.update(chunk)

    return h.hexdigest()

# ============================================================

# KEY MANAGEMENT

# ============================================================

def generate_key():

    """Generate a new random Fernet key."""

    return Fernet.generate_key()

def derive_key_from_password(password: str, salt: bytes = None):

    """

    Derive a Fernet-compatible key from a password using PBKDF2-HMAC-SHA256.

    Returns (key, salt).

    """

    if salt is None:

        salt = secrets.token_bytes(SALT_SIZE)

    kdf = PBKDF2HMAC(

        algorithm=hashes.SHA256(),

        length=32,

        salt=salt,

        iterations=ITERATIONS,

    )

    key = base64.urlsafe_b64encode(kdf.derive(password.encode()))

    return key, salt

def save_key(key: bytes, filepath=KEY_FILE):

    """Save a key to a file."""

    with open(filepath, "wb") as f:

        f.write(key)

    print(f"  Key saved: {filepath}")

    print("  IMPORTANT: Keep this key file safe. Without it, decryption is impossible!")

def load_key(filepath=KEY_FILE):

    """Load a key from file."""

    if not Path(filepath).exists():

        print(f"  Key file not found: {filepath}")

        return None

    with open(filepath, "rb") as f:

        return f.read().strip()

# ============================================================

# VAULT LOG

# ============================================================

def load_vault():

    if Path(VAULT_LOG).exists():

        try:

            with open(VAULT_LOG, "r") as f:

                return json.load(f)

        except:

            pass

    return {"files": []}

def save_vault(vault):

    with open(VAULT_LOG, "w") as f:

        json.dump(vault, f, indent=2)

def log_operation(vault, operation, filepath, output_path, method):

    vault["files"].append({

        "operation":   operation,

        "source":      str(filepath),

        "output":      str(output_path),

        "method":      method,

        "timestamp":   datetime.now().strftime("%d-%m-%Y %H:%M:%S"),

        "size":        format_size(Path(output_path).stat().st_size)

                       if Path(output_path).exists() else "?"

    })

    vault["files"] = vault["files"][-100:]

    save_vault(vault)

# ============================================================

# ENCRYPT FILE

# ============================================================

def encrypt_file(filepath, key: bytes, output_path=None,

                 salt: bytes = None):

    """

    Encrypt a file using Fernet.

    If salt is provided, it's prepended to the encrypted output

    (used for password-based encryption).

    Returns output path or None on failure.

    """

    filepath = Path(filepath)

    if not filepath.exists():

        print(f"  File not found: {filepath}")

        return None

    if output_path is None:

        output_path = filepath.with_suffix(filepath.suffix + ENC_EXTENSION)

    output_path = Path(output_path)

    try:

        fernet = Fernet(key)

        with open(filepath, "rb") as f:

            data = f.read()

        encrypted = fernet.encrypt(data)

        with open(output_path, "wb") as f:

            if salt:

                # Write salt length (2 bytes) + salt + encrypted data

                f.write(len(salt).to_bytes(2, "big"))

                f.write(salt)

            f.write(encrypted)

        orig_size = format_size(filepath.stat().st_size)

        enc_size  = format_size(output_path.stat().st_size)

        checksum  = file_checksum(filepath)

        print(f"\n  Encrypted successfully!")

        print(f"  Input  : {filepath.name}  ({orig_size})")

        print(f"  Output : {output_path.name}  ({enc_size})")

        print(f"  Checksum (original): {checksum}")

        return output_path

    except Exception as e:

        print(f"  Encryption failed: {e}")

        return None

# ============================================================

# DECRYPT FILE

# ============================================================

def decrypt_file(filepath, key: bytes, output_path=None,

                 password_based=False):

    """

    Decrypt a Fernet-encrypted file.

    If password_based=True, reads the salt from the file header.

    Returns output path or None on failure.

    """

    filepath = Path(filepath)

    if not filepath.exists():

        print(f"  File not found: {filepath}")

        return None

    # Determine output path

    if output_path is None:

        name = filepath.name

        if name.endswith(ENC_EXTENSION):

            out_name = name[:-len(ENC_EXTENSION)]

        else:

            out_name = name + ".decrypted"

        output_path = filepath.parent / out_name

    output_path = Path(output_path)

    try:

        with open(filepath, "rb") as f:

            raw = f.read()

        if password_based:

            # Read salt from header

            salt_len  = int.from_bytes(raw[:2], "big")

            salt      = raw[2:2 + salt_len]

            encrypted = raw[2 + salt_len:]

            # Re-derive key from password

            password = getpass.getpass("  Password: ")

            key, _   = derive_key_from_password(password, salt)

        else:

            encrypted = raw

        fernet    = Fernet(key)

        decrypted = fernet.decrypt(encrypted)

        with open(output_path, "wb") as f:

            f.write(decrypted)

        orig_size = format_size(filepath.stat().st_size)

        dec_size  = format_size(output_path.stat().st_size)

        checksum  = file_checksum(output_path)

        print(f"\n  Decrypted successfully!")

        print(f"  Input  : {filepath.name}  ({orig_size})")

        print(f"  Output : {output_path.name}  ({dec_size})")

        print(f"  Checksum (restored): {checksum}")

        return output_path

    except InvalidToken:

        print("  Decryption failed: Wrong key or password, or file is corrupted.")

        return None

    except Exception as e:

        print(f"  Decryption failed: {e}")

        return None

# ============================================================

# ENCRYPT / DECRYPT FOLDER

# ============================================================

def process_folder(folder_path, key, operation,

                   extensions=None, password_based=False, salt=None):

    folder = Path(folder_path)

    if not folder.is_dir():

        print("  Invalid folder.")

        return

    if operation == "encrypt":

        if extensions:

            files = [f for f in folder.rglob("*")

                     if f.is_file() and f.suffix.lower() in extensions

                     and not f.name.endswith(ENC_EXTENSION)]

        else:

            files = [f for f in folder.rglob("*")

                     if f.is_file() and not f.name.endswith(ENC_EXTENSION)]

    else:

        files = [f for f in folder.rglob("*")

                 if f.is_file() and f.name.endswith(ENC_EXTENSION)]

    if not files:

        print(f"  No files found to {operation}.")

        return

    print(f"\n  Found {len(files)} file(s) to {operation}.")

    confirm = input(f"  Proceed? (y/n): ").strip().lower()

    if confirm != "y":

        print("  Cancelled.")

        return

    success = 0

    failed  = 0

    vault   = load_vault()

    for f in files:

        print(f"\n  [{operation.upper()}] {f.name}")

        if operation == "encrypt":

            result = encrypt_file(f, key, salt=salt)

        else:

            result = decrypt_file(f, key, password_based=password_based)

        if result:

            success += 1

            log_operation(vault, operation, f, result,

                          "password" if password_based else "key-file")

        else:

            failed += 1

    save_vault(vault)

    print(f"\n  Done: {success} succeeded, {failed} failed.")

# ============================================================

# ENCRYPT TEXT STRING

# ============================================================

def encrypt_text(key: bytes):

    print("\n  Enter text to encrypt (type END on new line to finish):")

    lines = []

    while True:

        line = input()

        if line.strip().upper() == "END":

            break

        lines.append(line)

    text = "\n".join(lines)

    fernet    = Fernet(key)

    encrypted = fernet.encrypt(text.encode())

    encoded   = encrypted.decode()

    print(f"\n  Encrypted text (copy this):")

    print(f"  {encoded}")

    save = input("\n  Save to file? (y/n): ").strip().lower()

    if save == "y":

        fname = f"encrypted_text_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"

        with open(fname, "w") as f:

            f.write(encoded)

        print(f"  Saved: {fname}")

def decrypt_text(key: bytes):

    print("\n  Paste encrypted text:")

    enc_text = input("  > ").strip()

    try:

        fernet    = Fernet(key)

        decrypted = fernet.decrypt(enc_text.encode()).decode()

        print(f"\n  Decrypted text:")

        print(f"  {decrypted}")

    except InvalidToken:

        print("  Decryption failed: Invalid token or wrong key.")

    except Exception as e:

        print(f"  Error: {e}")

# ============================================================

# DISPLAY VAULT LOG

# ============================================================

def display_vault():

    vault = load_vault()

    files = vault.get("files", [])

    if not files:

        print("\n  No operations logged yet.")

        return

    print("\n" + "="*65)

    print(f"  ENCRYPTION VAULT LOG  ({len(files)} entries)")

    print("="*65)

    print(f"  {'OP':<10} {'TIMESTAMP':<22} {'METHOD':<10} FILE")

    print("  " + "-"*60)

    for entry in reversed(files[-20:]):

        op     = entry["operation"].upper()

        ts     = entry["timestamp"]

        method = entry["method"]

        fname  = Path(entry["output"]).name

        print(f"  {op:<10} {ts:<22} {method:<10} {fname}")

    print("="*65)

# ============================================================

# SETUP: GET OR CREATE KEY

# ============================================================

def setup_key_menu():

    print("\n  KEY SETUP")

    print("  1. Generate new random key (save to file)")

    print("  2. Use existing key file")

    print("  3. Use password (derive key)")

    choice = input("\n  Choice (1/2/3): ").strip()

    if choice == "1":

        key = generate_key()

        fname = input(f"  Save key as [{KEY_FILE}]: ").strip() or KEY_FILE

        save_key(key, fname)

        return key, False, None

    elif choice == "2":

        fname = input(f"  Key file path [{KEY_FILE}]: ").strip() or KEY_FILE

        key = load_key(fname)

        if key:

            print(f"  Key loaded from: {fname}")

            return key, False, None

        return None, False, None

    elif choice == "3":

        password = getpass.getpass("  Enter password: ")

        confirm  = getpass.getpass("  Confirm password: ")

        if password != confirm:

            print("  Passwords do not match.")

            return None, False, None

        key, salt = derive_key_from_password(password)

        print("  Key derived from password successfully.")

        print(f"  Strength tip: Use 12+ chars with mixed letters, numbers, symbols.")

        return key, True, salt

    return None, False, None

# ============================================================

# MAIN MENU

# ============================================================

def print_menu(key_loaded, method):

    status = f"Key loaded ({method})" if key_loaded else "No key loaded"

    print("\n" + "-"*50)

    print(f"  FILE ENCRYPTION TOOL  [{status}]")

    print("-"*50)

    print("  1. Setup key (generate / load / password)")

    print("  2. Encrypt a file")

    print("  3. Decrypt a file")

    print("  4. Encrypt all files in folder")

    print("  5. Decrypt all .encrypted files in folder")

    print("  6. Encrypt text string")

    print("  7. Decrypt text string")

    print("  8. View vault log")

    print("  0. Exit")

    print("-"*50)

def main():

    print("\n" + "="*55)

    print("     FILE ENCRYPTION / DECRYPTION TOOL")

    print("="*55)

    if not CRYPTO_OK:

        print("\n  cryptography library not installed!")

        print("  Install it:  pip install cryptography")

        return

    print("\n  Uses Fernet symmetric encryption (AES-128-CBC + HMAC-SHA256)")

    print("  Supports: key file OR password-based encryption\n")

    current_key      = None

    password_based   = False

    current_salt     = None

    method_str       = ""

    # Auto-load key if exists

    if Path(KEY_FILE).exists():

        current_key = load_key(KEY_FILE)

        method_str  = "key-file"

        print(f"  Auto-loaded key from: {KEY_FILE}")

    vault = load_vault()

    while True:

        print_menu(current_key is not None, method_str)

        choice = input("  > ").strip()

        if choice == "1":

            current_key, password_based, current_salt = setup_key_menu()

            if current_key:

                method_str = "password" if password_based else "key-file"

        elif choice in ["2", "3", "4", "5", "6", "7"]:

            if not current_key:

                print("\n  No key loaded. Please set up a key first (Option 1).")

                continue

            if choice == "2":

                path = input("\n  File to encrypt: ").strip()

                out  = input("  Output path (Enter = auto): ").strip() or None

                result = encrypt_file(path, current_key, out,

                                      salt=current_salt)

                if result:

                    log_operation(vault, "encrypt", path, result, method_str)

                    save_vault(vault)

            elif choice == "3":

                path = input("\n  File to decrypt: ").strip()

                out  = input("  Output path (Enter = auto): ").strip() or None

                result = decrypt_file(path, current_key, out,

                                      password_based=password_based)

                if result:

                    log_operation(vault, "decrypt", path, result, method_str)

                    save_vault(vault)

            elif choice == "4":

                folder = input("\n  Folder path: ").strip()

                ext_in = input("  File types to encrypt (e.g. .txt .pdf, Enter=all): ").strip()

                exts   = [e if e.startswith(".") else f".{e}"

                          for e in ext_in.split()] if ext_in else None

                process_folder(folder, current_key, "encrypt",

                               extensions=exts,

                               salt=current_salt)

            elif choice == "5":

                folder = input("\n  Folder path: ").strip()

                process_folder(folder, current_key, "decrypt",

                               password_based=password_based)

            elif choice == "6":

                encrypt_text(current_key)

            elif choice == "7":

                decrypt_text(current_key)

        elif choice == "8":

            display_vault()

        elif choice == "0":

            print("\n  Goodbye!\n")

            break

        else:

            print("  Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

    main()

Log File Analyzer

import re

import os

import json

from datetime import datetime

from pathlib import Path

from collections import defaultdict, Counter

# ============================================================

# CONFIGURATION

# ============================================================

REPORT_FILE = "log_analysis_report.json"

# Common log level patterns

LOG_LEVELS = ["CRITICAL", "ERROR", "WARNING", "WARN", "INFO", "DEBUG", "TRACE", "FATAL"]

# Built-in format patterns

LOG_FORMATS = {

    "apache_access": r'(?P<ip>\S+) \S+ \S+ \[(?P<datetime>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+)[^"]*" (?P<status>\d{3}) (?P<size>\S+)',

    "apache_error":  r'\[(?P<datetime>[^\]]+)\] \[(?P<level>\w+)\] (?P<message>.*)',

    "nginx_access":  r'(?P<ip>\S+) - \S+ \[(?P<datetime>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+)[^"]*" (?P<status>\d{3}) (?P<size>\d+)',

    "python_log":    r'(?P<datetime>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}),\d+ (?P<level>\w+) (?P<logger>\S+) (?P<message>.*)',

    "syslog":        r'(?P<datetime>\w{3}\s+\d+ \d{2}:\d{2}:\d{2}) (?P<host>\S+) (?P<process>\S+): (?P<message>.*)',

    "generic":       r'(?P<datetime>\d{4}[-/]\d{2}[-/]\d{2}[T ]\d{2}:\d{2}:\d{2}).*?(?P<level>CRITICAL|ERROR|WARNING|WARN|INFO|DEBUG|TRACE|FATAL).*?(?P<message>.*)',

}

# ============================================================

# HELPERS

# ============================================================

def draw_bar(value, max_val, width=25, fill="█", empty="░"):

    if max_val == 0:

        return ""

    filled = int((min(value, max_val) / max_val) * width)

    return fill * filled + empty * (width - filled)

def format_size(size_bytes):

    for unit in ["B", "KB", "MB", "GB"]:

        if size_bytes < 1024:

            return f"{size_bytes:.1f} {unit}"

        size_bytes /= 1024

    return f"{size_bytes:.1f} GB"

def safe_read(filepath, encoding="utf-8"):

    try:

        with open(filepath, "r", encoding=encoding, errors="replace") as f:

            return f.readlines()

    except Exception as e:

        print(f"  Error reading file: {e}")

        return []

# ============================================================

# AUTO-DETECT LOG FORMAT

# ============================================================

def detect_format(lines):

    """Try each format pattern on first 20 lines. Return best match."""

    sample = lines[:20]

    scores = {}

    for fmt_name, pattern in LOG_FORMATS.items():

        matches = sum(1 for line in sample if re.search(pattern, line))

        scores[fmt_name] = matches

    best = max(scores, key=scores.get)

    if scores[best] > 0:

        return best, scores[best]

    return "generic", 0

# ============================================================

# CORE PARSER

# ============================================================

def parse_log(filepath, fmt_name=None, keyword_filter=None,

              level_filter=None, max_lines=0):

    """

    Parse a log file and return structured data.

    Returns dict with entries, stats, errors.

    """

    lines = safe_read(filepath)

    if not lines:

        return None

    total_lines = len(lines)

    print(f"\n  File    : {Path(filepath).name}")

    print(f"  Size    : {format_size(Path(filepath).stat().st_size)}")

    print(f"  Lines   : {total_lines:,}")

    # Auto-detect format

    if not fmt_name or fmt_name == "auto":

        fmt_name, score = detect_format(lines)

        print(f"  Format  : {fmt_name} (auto-detected, {score}/20 lines matched)")

    else:

        print(f"  Format  : {fmt_name}")

    pattern = LOG_FORMATS.get(fmt_name, LOG_FORMATS["generic"])

    # Limit lines if requested

    if max_lines > 0:

        lines = lines[:max_lines]

        print(f"  Parsing : first {max_lines:,} lines")

    # Parse each line

    entries       = []

    level_counts  = Counter()

    hour_counts   = Counter()

    ip_counts     = Counter()

    status_counts = Counter()

    path_counts   = Counter()

    message_list  = []

    parse_errors  = 0

    keyword_hits  = []

    for i, line in enumerate(lines):

        line = line.rstrip()

        if not line:

            continue

        match = re.search(pattern, line, re.IGNORECASE)

        if match:

            entry = match.groupdict()

            # Normalize level

            level = entry.get("level", "").upper()

            if not level:

                # Try to find level anywhere in line

                for lvl in LOG_LEVELS:

                    if lvl in line.upper():

                        level = lvl

                        break

            entry["level"] = level or "UNKNOWN"

            level_counts[entry["level"]] += 1

            # Extract hour from datetime

            dt_str = entry.get("datetime", "")

            for fmt in ["%Y-%m-%d %H:%M:%S", "%d/%b/%Y:%H:%M:%S",

                        "%b %d %H:%M:%S", "%Y/%m/%d %H:%M:%S"]:

                try:

                    dt = datetime.strptime(dt_str[:len(fmt)], fmt)

                    hour_counts[dt.strftime("%H:00")] += 1

                    entry["datetime_parsed"] = dt.strftime("%d-%m-%Y %H:%M:%S")

                    break

                except:

                    continue

            # Track IPs, status codes, paths (for web logs)

            if "ip" in entry and entry["ip"]:

                ip_counts[entry["ip"]] += 1

            if "status" in entry and entry["status"]:

                status_counts[entry["status"]] += 1

            if "path" in entry and entry["path"]:

                path_counts[entry["path"]] += 1

            # Track messages

            msg = entry.get("message", line[:120])

            message_list.append(msg)

            # Apply filters

            if level_filter and entry["level"] not in [l.upper() for l in level_filter]:

                continue

            if keyword_filter and keyword_filter.lower() not in line.lower():

                continue

            entry["line_no"] = i + 1

            entry["raw"]     = line[:200]

            entries.append(entry)

            # Keyword tracking

            if keyword_filter and keyword_filter.lower() in line.lower():

                keyword_hits.append({"line": i + 1, "text": line[:200]})

        else:

            parse_errors += 1

    parse_rate = round((1 - parse_errors / max(len(lines), 1)) * 100, 1)

    print(f"  Parsed  : {len(entries):,} entries  ({parse_rate}% success rate)")

    return {

        "filepath":     str(filepath),

        "filename":     Path(filepath).name,

        "total_lines":  total_lines,

        "parsed":       len(entries),

        "parse_errors": parse_errors,

        "format":       fmt_name,

        "entries":      entries,

        "level_counts": dict(level_counts),

        "hour_counts":  dict(hour_counts),

        "ip_counts":    dict(ip_counts),

        "status_counts":dict(status_counts),

        "path_counts":  dict(path_counts),

        "message_list": message_list,

        "keyword_hits": keyword_hits,

    }

# ============================================================

# DISPLAY: LEVEL SUMMARY

# ============================================================

def display_level_summary(result):

    counts   = result["level_counts"]

    total    = sum(counts.values())

    if not counts:

        print("\n  No log level data found.")

        return

    max_val  = max(counts.values())

    print("\n" + "="*55)

    print(f"  LOG LEVEL SUMMARY  —  {result['filename']}")

    print("="*55)

    print(f"  {'LEVEL':<12} {'COUNT':>8}  {'%':>6}  BAR")

    print("  " + "-"*51)

    order = ["FATAL", "CRITICAL", "ERROR", "WARNING", "WARN",

             "INFO", "DEBUG", "TRACE", "UNKNOWN"]

    for level in order:

        count = counts.get(level, 0)

        if count == 0:

            continue

        pct = count / total * 100

        bar = draw_bar(count, max_val)

        print(f"  {level:<12} {count:>8,}  {pct:>5.1f}%  {bar}")

    print("  " + "-"*51)

    print(f"  {'TOTAL':<12} {total:>8,}")

    print("="*55)

    # Highlight issues

    errors   = counts.get("ERROR", 0) + counts.get("CRITICAL", 0) + counts.get("FATAL", 0)

    warnings = counts.get("WARNING", 0) + counts.get("WARN", 0)

    if errors > 0:

        print(f"\n  *** {errors:,} ERROR/CRITICAL/FATAL entries found!")

    if warnings > 0:

        print(f"  *** {warnings:,} WARNING entries found.")

    if errors == 0 and warnings == 0:

        print("\n  All clear — no errors or warnings detected.")

# ============================================================

# DISPLAY: HOURLY ACTIVITY

# ============================================================

def display_hourly_activity(result):

    counts = result["hour_counts"]

    if not counts:

        print("\n  No timestamp data found for hourly analysis.")

        return

    max_val = max(counts.values())

    print("\n" + "="*55)

    print("  HOURLY ACTIVITY")

    print("="*55)

    for hour in sorted(counts.keys()):

        count = counts[hour]

        bar   = draw_bar(count, max_val, width=30)

        print(f"  {hour}  {count:>6,}  {bar}")

    peak_hour  = max(counts, key=counts.get)

    quiet_hour = min(counts, key=counts.get)

    print("="*55)

    print(f"  Peak hour  : {peak_hour}  ({counts[peak_hour]:,} entries)")

    print(f"  Quiet hour : {quiet_hour}  ({counts[quiet_hour]:,} entries)")

# ============================================================

# DISPLAY: TOP IPs / PATHS / STATUS CODES

# ============================================================

def display_web_stats(result, top_n=10):

    ip_counts     = result.get("ip_counts", {})

    status_counts = result.get("status_counts", {})

    path_counts   = result.get("path_counts", {})

    if not ip_counts and not status_counts and not path_counts:

        print("\n  No web log data (IPs / status codes / paths) found.")

        return

    print("\n" + "="*55)

    print("  WEB LOG STATISTICS")

    print("="*55)

    if ip_counts:

        top_ips = sorted(ip_counts.items(), key=lambda x: x[1], reverse=True)[:top_n]

        max_val = top_ips[0][1]

        print(f"\n  TOP {top_n} IP ADDRESSES:")

        print(f"  {'IP':<18} {'REQUESTS':>10}  BAR")

        print("  " + "-"*45)

        for ip, count in top_ips:

            bar = draw_bar(count, max_val, width=15)

            print(f"  {ip:<18} {count:>10,}  {bar}")

    if status_counts:

        print(f"\n  HTTP STATUS CODES:")

        print(f"  {'CODE':<8} {'COUNT':>10}  MEANING")

        print("  " + "-"*40)

        meanings = {

            "200": "OK", "201": "Created", "301": "Moved Permanently",

            "302": "Found", "304": "Not Modified", "400": "Bad Request",

            "401": "Unauthorized", "403": "Forbidden", "404": "Not Found",

            "500": "Internal Server Error", "502": "Bad Gateway",

            "503": "Service Unavailable"

        }

        for code, count in sorted(status_counts.items()):

            meaning = meanings.get(code, "")

            print(f"  {code:<8} {count:>10,}  {meaning}")

    if path_counts:

        top_paths = sorted(path_counts.items(), key=lambda x: x[1], reverse=True)[:top_n]

        max_val   = top_paths[0][1]

        print(f"\n  TOP {top_n} REQUESTED PATHS:")

        print(f"  {'PATH':<35} {'HITS':>8}  BAR")

        print("  " + "-"*55)

        for path, count in top_paths:

            display_path = path[:33] + ".." if len(path) > 35 else path

            bar = draw_bar(count, max_val, width=10)

            print(f"  {display_path:<35} {count:>8,}  {bar}")

    print("="*55)

# ============================================================

# DISPLAY: RECENT ERRORS

# ============================================================

def display_errors(result, top_n=20):

    entries = result["entries"]

    errors  = [e for e in entries

               if e.get("level") in ("ERROR", "CRITICAL", "FATAL")]

    if not errors:

        print("\n  No ERROR / CRITICAL / FATAL entries found.")

        return

    print("\n" + "="*65)

    print(f"  ERRORS & CRITICAL ENTRIES  ({len(errors):,} total, showing last {top_n})")

    print("="*65)

    for e in errors[-top_n:]:

        dt  = e.get("datetime_parsed") or e.get("datetime", "")[:19]

        msg = e.get("message") or e.get("raw", "")

        msg = msg[:80]

        print(f"\n  [{e['level']}]  Line {e.get('line_no','?')}  {dt}")

        print(f"  {msg}")

    print("="*65)

# ============================================================

# DISPLAY: KEYWORD SEARCH RESULTS

# ============================================================

def display_keyword_hits(result, keyword):

    hits = result.get("keyword_hits", [])

    if not hits:

        print(f"\n  No matches found for: '{keyword}'")

        return

    print("\n" + "="*65)

    print(f"  KEYWORD SEARCH: '{keyword}'  ({len(hits):,} matches)")

    print("="*65)

    for hit in hits[:30]:

        print(f"\n  Line {hit['line']:>6}:  {hit['text'][:100]}")

    if len(hits) > 30:

        print(f"\n  ... and {len(hits) - 30} more matches.")

    print("="*65)

# ============================================================

# DISPLAY: COMMON PATTERNS / REPEATED MESSAGES

# ============================================================

def display_patterns(result, top_n=15):

    messages = result.get("message_list", [])

    if not messages:

        print("\n  No messages extracted.")

        return

    # Normalize messages (strip numbers/IPs for better grouping)

    def normalize(msg):

        msg = re.sub(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', '<IP>', msg)

        msg = re.sub(r'\b\d+\b', '<N>', msg)

        msg = re.sub(r'"[^"]*"', '"<VAL>"', msg)

        return msg[:80].strip()

    normalized = [normalize(m) for m in messages if m.strip()]

    counts     = Counter(normalized)

    top        = counts.most_common(top_n)

    max_val    = top[0][1] if top else 1

    print("\n" + "="*65)

    print(f"  MOST REPEATED LOG PATTERNS  (Top {top_n})")

    print("="*65)

    print(f"  {'COUNT':>7}  MESSAGE PATTERN")

    print("  " + "-"*60)

    for pattern, count in top:

        bar = draw_bar(count, max_val, width=12)

        print(f"  {count:>7,}  {bar}  {pattern}")

    print("="*65)

# ============================================================

# FULL REPORT

# ============================================================

def full_report(result):

    display_level_summary(result)

    display_hourly_activity(result)

    display_web_stats(result)

    display_errors(result)

    display_patterns(result)

# ============================================================

# SAVE REPORT TO JSON

# ============================================================

def save_report(result):

    report = {

        "filename":      result["filename"],

        "analyzed_at":   datetime.now().strftime("%d-%m-%Y %H:%M:%S"),

        "total_lines":   result["total_lines"],

        "parsed":        result["parsed"],

        "format":        result["format"],

        "level_counts":  result["level_counts"],

        "top_ips":       dict(sorted(result["ip_counts"].items(),

                                     key=lambda x: x[1], reverse=True)[:20]),

        "status_codes":  result["status_counts"],

        "top_paths":     dict(sorted(result["path_counts"].items(),

                                     key=lambda x: x[1], reverse=True)[:20]),

        "hourly":        result["hour_counts"],

    }

    with open(REPORT_FILE, "w") as f:

        json.dump(report, f, indent=2)

    print(f"\n  Report saved: {REPORT_FILE}")

# ============================================================

# BATCH ANALYZE (FOLDER)

# ============================================================

def batch_analyze(folder):

    folder = Path(folder)

    if not folder.is_dir():

        print("  Invalid folder.")

        return

    log_files = (list(folder.glob("*.log")) +

                 list(folder.glob("*.txt")) +

                 list(folder.glob("*.out")))

    if not log_files:

        print(f"  No .log / .txt / .out files in {folder}")

        return

    print(f"\n  Found {len(log_files)} log file(s).\n")

    summary = []

    for f in log_files:

        result = parse_log(f)

        if result:

            errors   = (result["level_counts"].get("ERROR", 0) +

                        result["level_counts"].get("CRITICAL", 0) +

                        result["level_counts"].get("FATAL", 0))

            warnings = (result["level_counts"].get("WARNING", 0) +

                        result["level_counts"].get("WARN", 0))

            summary.append({

                "file":     f.name,

                "lines":    result["total_lines"],

                "errors":   errors,

                "warnings": warnings,

            })

    print("\n" + "="*60)

    print(f"  BATCH SUMMARY  ({len(summary)} files)")

    print("="*60)

    print(f"  {'FILE':<30} {'LINES':>8} {'ERRORS':>8} {'WARNINGS':>10}")

    print("  " + "-"*56)

    for s in summary:

        print(f"  {s['file']:<30} {s['lines']:>8,} {s['errors']:>8,} "

              f"{s['warnings']:>10,}")

    total_errors   = sum(s["errors"]   for s in summary)

    total_warnings = sum(s["warnings"] for s in summary)

    print("  " + "-"*56)

    print(f"  {'TOTAL':<30} {'':>8} {total_errors:>8,} {total_warnings:>10,}")

    print("="*60)

# ============================================================

# MAIN MENU

# ============================================================

def print_menu():

    print("\n" + "-"*48)

    print("  LOG FILE ANALYZER")

    print("-"*48)

    print("  1. Analyze log file (full report)")

    print("  2. Log level summary")

    print("  3. Hourly activity chart")

    print("  4. Web log stats (IPs / status / paths)")

    print("  5. Show errors & critical entries")

    print("  6. Search keyword in log")

    print("  7. Repeated message patterns")

    print("  8. Batch analyze a folder")

    print("  9. Save report to JSON")

    print("  0. Exit")

    print("-"*48)

def main():

    print("\n" + "="*55)

    print("     LOG FILE ANALYZER")

    print("="*55)

    print("\n  Supports: Apache, Nginx, Python, Syslog, Generic logs")

    print("  Auto-detects format from first 20 lines.\n")

    last_result = None

    while True:

        print_menu()

        choice = input("  > ").strip()

        if choice in ["1","2","3","4","5","6","7","9"]:

            if not last_result or choice == "1":

                path = input("\n  Log file path: ").strip()

                if not path or not Path(path).exists():

                    print("  File not found.")

                    continue

                fmt_choice = input(

                    "  Format (auto/apache_access/apache_error/"

                    "nginx_access/python_log/syslog/generic): "

                ).strip() or "auto"

                kw = None

                if choice == "6":

                    kw = input("  Keyword to search: ").strip()

                lvl_filter = None

                max_lines  = 0

                ml = input("  Max lines to parse (0=all): ").strip()

                max_lines = int(ml) if ml.isdigit() else 0

                last_result = parse_log(path, fmt_choice, kw, lvl_filter, max_lines)

                if not last_result:

                    continue

        if choice == "1":

            full_report(last_result)

        elif choice == "2":

            display_level_summary(last_result)

        elif choice == "3":

            display_hourly_activity(last_result)

        elif choice == "4":

            display_web_stats(last_result)

        elif choice == "5":

            n = input("  Show last N errors (default 20): ").strip()

            n = int(n) if n.isdigit() else 20

            display_errors(last_result, n)

        elif choice == "6":

            kw = input("  Keyword to search: ").strip()

            if kw:

                # Re-parse with keyword

                last_result = parse_log(last_result["filepath"],

                                        last_result["format"],

                                        kw)

                if last_result:

                    display_keyword_hits(last_result, kw)

        elif choice == "7":

            n = input("  Top N patterns (default 15): ").strip()

            n = int(n) if n.isdigit() else 15

            display_patterns(last_result, n)

        elif choice == "8":

            folder = input("\n  Folder path: ").strip()

            batch_analyze(folder)

        elif choice == "9":

            if last_result:

                save_report(last_result)

            else:

                print("  No analysis data. Parse a file first.")

        elif choice == "0":

            print("\n  Goodbye!\n")

            break

        else:

            print("  Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

    main()

Loan EMI Calculator

import math

import json

import csv

import os

from datetime import datetime, date

from pathlib import Path

from dateutil.relativedelta import relativedelta

# Try importing dateutil

try:

    from dateutil.relativedelta import relativedelta

    DATEUTIL_OK = True

except ImportError:

    DATEUTIL_OK = False

# ============================================================

# CONFIGURATION

# ============================================================

HISTORY_FILE  = "emi_history.json"

CURRENCY_SYM  = "₹"

# ============================================================

# FORMAT HELPERS

# ============================================================

def fmt(amount):

    return f"{CURRENCY_SYM}{amount:,.2f}"

def fmt_plain(amount):

    return f"{amount:,.2f}"

def draw_bar(value, max_val, width=30, fill="█", empty="░"):

    if max_val == 0:

        return ""

    filled = int((min(value, max_val) / max_val) * width)

    return fill * filled + empty * (width - filled)

# ============================================================

# CORE EMI CALCULATION

# ============================================================

def calculate_emi(principal, annual_rate, tenure_months):

    """

    EMI = P × r × (1+r)^n / ((1+r)^n - 1)

    Where:

        P = Principal

        r = Monthly interest rate (annual_rate / 12 / 100)

        n = Tenure in months

    """

    if annual_rate == 0:

        return round(principal / tenure_months, 2)

    r   = annual_rate / 12 / 100

    n   = tenure_months

    emi = principal * r * math.pow(1 + r, n) / (math.pow(1 + r, n) - 1)

    return round(emi, 2)

def calculate_summary(principal, annual_rate, tenure_months):

    """Return full summary of loan calculations."""

    emi           = calculate_emi(principal, annual_rate, tenure_months)

    total_payment = round(emi * tenure_months, 2)

    total_interest = round(total_payment - principal, 2)

    interest_pct  = round((total_interest / principal) * 100, 2)

    return {

        "principal":       principal,

        "annual_rate":     annual_rate,

        "tenure_months":   tenure_months,

        "tenure_years":    round(tenure_months / 12, 2),

        "emi":             emi,

        "total_payment":   total_payment,

        "total_interest":  total_interest,

        "interest_pct":    interest_pct,

    }

# ============================================================

# AMORTIZATION TABLE

# ============================================================

def generate_amortization(principal, annual_rate, tenure_months,

                          start_date=None):

    """

    Generate month-by-month amortization schedule.

    Returns list of dicts with payment breakdown per month.

    """

    emi       = calculate_emi(principal, annual_rate, tenure_months)

    r         = annual_rate / 12 / 100

    balance   = principal

    schedule  = []

    if start_date is None:

        start_date = date.today()

    for month in range(1, tenure_months + 1):

        interest_component  = round(balance * r, 2)

        principal_component = round(emi - interest_component, 2)

        # Last payment adjustment for rounding

        if month == tenure_months:

            principal_component = round(balance, 2)

            emi_actual          = round(principal_component + interest_component, 2)

        else:

            emi_actual = emi

        balance = round(balance - principal_component, 2)

        if balance < 0:

            balance = 0.0

        # Calculate payment date

        if DATEUTIL_OK:

            pay_date = (start_date + relativedelta(months=month)).strftime("%b %Y")

        else:

            m = (start_date.month + month - 1) % 12 + 1

            y = start_date.year + (start_date.month + month - 1) // 12

            pay_date = f"{date(y, m, 1).strftime('%b %Y')}"

        schedule.append({

            "month":     month,

            "pay_date":  pay_date,

            "emi":       emi_actual,

            "principal": principal_component,

            "interest":  interest_component,

            "balance":   balance,

        })

    return schedule

# ============================================================

# DISPLAY SUMMARY

# ============================================================

def display_summary(summary, label="LOAN SUMMARY"):

    p   = summary["principal"]

    ti  = summary["total_interest"]

    tp  = summary["total_payment"]

    # Pie-style ASCII breakdown

    p_bar  = draw_bar(p,  tp, width=25)

    ti_bar = draw_bar(ti, tp, width=25)

    print("\n" + "="*58)

    print(f"  {label}")

    print("="*58)

    print(f"  Principal Amount   : {fmt(summary['principal'])}")

    print(f"  Annual Interest    : {summary['annual_rate']}%")

    print(f"  Tenure             : {summary['tenure_months']} months "

          f"({summary['tenure_years']} years)")

    print("-"*58)

    print(f"  Monthly EMI        : {fmt(summary['emi'])}")

    print(f"  Total Payment      : {fmt(summary['total_payment'])}")

    print(f"  Total Interest     : {fmt(summary['total_interest'])}  "

          f"({summary['interest_pct']}% of principal)")

    print("-"*58)

    print(f"  Principal  {fmt_plain(p):>14}  {draw_bar(p,  tp, 20)}")

    print(f"  Interest   {fmt_plain(ti):>14}  {draw_bar(ti, tp, 20)}")

    print(f"  Total      {fmt_plain(tp):>14}")

    print("="*58)

# ============================================================

# DISPLAY AMORTIZATION TABLE

# ============================================================

def display_amortization(schedule, show_all=False):

    total_months = len(schedule)

    print("\n" + "="*72)

    print(f"  AMORTIZATION SCHEDULE  ({total_months} months)")

    print("="*72)

    print(f"  {'Mo':<4} {'Date':<10} {'EMI':>12} {'Principal':>12} "

          f"{'Interest':>12} {'Balance':>12}")

    print("  " + "-"*68)

    # Decide which months to show

    if show_all or total_months <= 24:

        rows = schedule

    else:

        # Show first 6, middle hint, last 6

        rows = schedule[:6]

        mid  = total_months // 2

        rows_display = schedule[:6]

        print_middle_hint = True

    

    if show_all or total_months <= 24:

        for row in schedule:

            print(f"  {row['month']:<4} {row['pay_date']:<10} "

                  f"{fmt_plain(row['emi']):>12} "

                  f"{fmt_plain(row['principal']):>12} "

                  f"{fmt_plain(row['interest']):>12} "

                  f"{fmt_plain(row['balance']):>12}")

    else:

        # First 6 months

        for row in schedule[:6]:

            print(f"  {row['month']:<4} {row['pay_date']:<10} "

                  f"{fmt_plain(row['emi']):>12} "

                  f"{fmt_plain(row['principal']):>12} "

                  f"{fmt_plain(row['interest']):>12} "

                  f"{fmt_plain(row['balance']):>12}")

        print(f"\n  ... {total_months - 12} more months ...\n")

        # Last 6 months

        for row in schedule[-6:]:

            print(f"  {row['month']:<4} {row['pay_date']:<10} "

                  f"{fmt_plain(row['emi']):>12} "

                  f"{fmt_plain(row['principal']):>12} "

                  f"{fmt_plain(row['interest']):>12} "

                  f"{fmt_plain(row['balance']):>12}")

    # Totals

    total_emi  = sum(r["emi"]       for r in schedule)

    total_prin = sum(r["principal"] for r in schedule)

    total_int  = sum(r["interest"]  for r in schedule)

    print("  " + "-"*68)

    print(f"  {'TOTAL':<15} {fmt_plain(total_emi):>12} "

          f"{fmt_plain(total_prin):>12} {fmt_plain(total_int):>12}")

    print("="*72)

# ============================================================

# YEARLY SUMMARY

# ============================================================

def display_yearly_summary(schedule):

    yearly = {}

    for row in schedule:

        year = row["pay_date"].split()[-1]

        if year not in yearly:

            yearly[year] = {"principal": 0, "interest": 0, "emi": 0}

        yearly[year]["principal"] += row["principal"]

        yearly[year]["interest"]  += row["interest"]

        yearly[year]["emi"]       += row["emi"]

    print("\n" + "="*58)

    print("  YEARLY SUMMARY")

    print("="*58)

    print(f"  {'YEAR':<8} {'EMI PAID':>12} {'PRINCIPAL':>12} {'INTEREST':>12}")

    print("  " + "-"*50)

    for year, vals in sorted(yearly.items()):

        print(f"  {year:<8} {fmt_plain(vals['emi']):>12} "

              f"{fmt_plain(vals['principal']):>12} "

              f"{fmt_plain(vals['interest']):>12}")

    print("="*58)

# ============================================================

# EMI COMPARISON (Multiple Rates / Tenures)

# ============================================================

def compare_options(principal):

    print(f"\n  EMI COMPARISON for {fmt(principal)}")

    print("  " + "="*70)

    rates   = [6, 7, 8, 9, 10, 11, 12, 14]

    tenures = [12, 24, 36, 60, 84, 120, 180, 240]

    # Header

    print(f"  {'RATE':<6}", end="")

    for t in tenures:

        y = t // 12

        print(f"  {str(y)+'yr':>9}", end="")

    print()

    print("  " + "-"*70)

    for rate in rates:

        print(f"  {rate}%   ", end="")

        for t in tenures:

            emi = calculate_emi(principal, rate, t)

            print(f"  {fmt_plain(emi):>9}", end="")

        print()

    print("  " + "="*70)

    print("  (Values show monthly EMI in same currency)")

# ============================================================

# PREPAYMENT IMPACT

# ============================================================

def prepayment_impact(principal, annual_rate, tenure_months, prepay_amount, prepay_month):

    """

    Calculate how a lump-sum prepayment affects

    total interest and remaining tenure.

    """

    # Without prepayment

    orig = calculate_summary(principal, annual_rate, tenure_months)

    # With prepayment — recalculate from prepay month

    schedule_before = generate_amortization(principal, annual_rate, tenure_months)

    if prepay_month >= tenure_months:

        print("  Prepayment month exceeds tenure.")

        return

    balance_at_prepay = schedule_before[prepay_month - 1]["balance"]

    new_principal     = max(0, balance_at_prepay - prepay_amount)

    if new_principal <= 0:

        print(f"\n  Prepayment fully closes the loan at month {prepay_month}!")

        interest_paid_so_far = sum(

            r["interest"] for r in schedule_before[:prepay_month]

        )

        total_paid = (prepay_month * orig["emi"]) + prepay_amount

        saved      = orig["total_payment"] - total_paid

        print(f"  Total paid     : {fmt(total_paid)}")

        print(f"  Interest saved : {fmt(orig['total_interest'] - interest_paid_so_far)}")

        return

    remaining_months = tenure_months - prepay_month

    new_summary      = calculate_summary(new_principal, annual_rate, remaining_months)

    interest_before  = sum(r["interest"] for r in schedule_before[:prepay_month])

    total_interest_new = interest_before + new_summary["total_interest"]

    interest_saved     = round(orig["total_interest"] - total_interest_new, 2)

    months_saved       = tenure_months - (prepay_month + remaining_months)

    print("\n" + "="*55)

    print("  PREPAYMENT IMPACT ANALYSIS")

    print("="*55)

    print(f"  Prepayment Amount  : {fmt(prepay_amount)} at month {prepay_month}")

    print(f"  Balance Before     : {fmt(balance_at_prepay)}")

    print(f"  Balance After      : {fmt(new_principal)}")

    print("-"*55)

    print(f"  Original Interest  : {fmt(orig['total_interest'])}")

    print(f"  New Total Interest : {fmt(total_interest_new)}")

    print(f"  Interest Saved     : {fmt(interest_saved)}")

    print(f"  New Monthly EMI    : {fmt(new_summary['emi'])}")

    print(f"  Old EMI            : {fmt(orig['emi'])}")

    print(f"  Months Saved       : {months_saved}")

    print("="*55)

# ============================================================

# EXPORT TO CSV

# ============================================================

def export_to_csv(schedule, summary, filename=None):

    if not filename:

        filename = f"emi_schedule_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"

    with open(filename, "w", newline="", encoding="utf-8") as f:

        writer = csv.writer(f)

        # Summary header

        writer.writerow(["LOAN EMI SCHEDULE"])

        writer.writerow(["Principal", fmt_plain(summary["principal"])])

        writer.writerow(["Annual Rate (%)", summary["annual_rate"]])

        writer.writerow(["Tenure (months)", summary["tenure_months"]])

        writer.writerow(["Monthly EMI", fmt_plain(summary["emi"])])

        writer.writerow(["Total Payment", fmt_plain(summary["total_payment"])])

        writer.writerow(["Total Interest", fmt_plain(summary["total_interest"])])

        writer.writerow([])

        # Table header

        writer.writerow(["Month", "Date", "EMI",

                         "Principal", "Interest", "Balance"])

        for row in schedule:

            writer.writerow([

                row["month"], row["pay_date"],

                fmt_plain(row["emi"]),

                fmt_plain(row["principal"]),

                fmt_plain(row["interest"]),

                fmt_plain(row["balance"])

            ])

    print(f"\n  Exported: {filename}")

    return filename

# ============================================================

# SAVE / LOAD HISTORY

# ============================================================

def save_to_history(summary):

    history = []

    if Path(HISTORY_FILE).exists():

        try:

            with open(HISTORY_FILE, "r") as f:

                history = json.load(f)

        except:

            pass

    summary["saved_at"] = datetime.now().strftime("%d-%m-%Y %H:%M")

    history.append(summary)

    history = history[-20:]

    with open(HISTORY_FILE, "w") as f:

        json.dump(history, f, indent=2)

    print("  Saved to history.")

def show_history():

    if not Path(HISTORY_FILE).exists():

        print("\n  No history yet.")

        return

    try:

        with open(HISTORY_FILE, "r") as f:

            history = json.load(f)

    except:

        print("  Could not load history.")

        return

    print("\n" + "="*65)

    print(f"  CALCULATION HISTORY  ({len(history)} entries)")

    print("="*65)

    print(f"  {'DATE':<18} {'PRINCIPAL':>14} {'RATE':>6} "

          f"{'MONTHS':>7} {'EMI':>12}")

    print("  " + "-"*60)

    for h in reversed(history):

        print(f"  {h.get('saved_at',''):<18} "

              f"{fmt_plain(h['principal']):>14}  "

              f"{h['annual_rate']:>5}%  "

              f"{h['tenure_months']:>6}  "

              f"{fmt_plain(h['emi']):>12}")

    print("="*65)

# ============================================================

# GET LOAN INPUT

# ============================================================

def get_loan_input():

    print("\n  Enter Loan Details")

    print("  " + "-"*40)

    try:

        principal = float(input("  Loan Amount       : ").strip().replace(",", ""))

        if principal <= 0:

            print("  Amount must be positive.")

            return None, None, None

        rate = float(input("  Annual Interest % : ").strip())

        if rate < 0 or rate > 100:

            print("  Rate must be between 0 and 100.")

            return None, None, None

        tenure_input = input("  Tenure (months or Xy for years): ").strip()

        if tenure_input.lower().endswith("y"):

            tenure_months = int(float(tenure_input[:-1]) * 12)

        else:

            tenure_months = int(tenure_input)

        if tenure_months <= 0:

            print("  Tenure must be positive.")

            return None, None, None

        return principal, rate, tenure_months

    except ValueError:

        print("  Invalid input.")

        return None, None, None

# ============================================================

# MAIN MENU

# ============================================================

def print_menu():

    print("\n" + "-"*48)

    print("  LOAN EMI CALCULATOR")

    print("-"*48)

    print("  1. Calculate EMI & summary")

    print("  2. Full amortization table")

    print("  3. Yearly payment summary")

    print("  4. Compare rates & tenures")

    print("  5. Prepayment impact analysis")

    print("  6. Export schedule to CSV")

    print("  7. View calculation history")

    print("  0. Exit")

    print("-"*48)

def main():

    print("\n" + "="*55)

    print("     LOAN EMI CALCULATOR")

    print("="*55)

    print("\n  Calculate EMI for Home, Car, Personal loans.")

    print("  Generate full amortization & prepayment analysis.\n")

    last_summary  = None

    last_schedule = None

    while True:

        print_menu()

        choice = input("  > ").strip()

        if choice in ["1", "2", "3", "5", "6"]:

            if choice in ["2", "3", "5", "6"] and last_summary:

                reuse = input("\n  Use last loan details? (y/n): ").strip().lower()

                if reuse == "n":

                    last_summary = last_schedule = None

            if not last_summary:

                p, r, t = get_loan_input()

                if p is None:

                    continue

                last_summary  = calculate_summary(p, r, t)

                last_schedule = generate_amortization(p, r, t)

        if choice == "1":

            display_summary(last_summary)

            save_to_history(last_summary.copy())

        elif choice == "2":

            display_summary(last_summary)

            show_all = input("\n  Show ALL months? (y/n): ").strip().lower()

            display_amortization(last_schedule, show_all == "y")

        elif choice == "3":

            display_yearly_summary(last_schedule)

        elif choice == "4":

            try:

                p = float(input("\n  Loan amount for comparison: ")

                          .strip().replace(",", ""))

                compare_options(p)

            except ValueError:

                print("  Invalid amount.")

        elif choice == "5":

            if not last_summary:

                p, r, t = get_loan_input()

                if p is None:

                    continue

                last_summary  = calculate_summary(p, r, t)

                last_schedule = generate_amortization(p, r, t)

            display_summary(last_summary)

            try:

                prepay_amt   = float(input("\n  Prepayment amount : ").strip().replace(",", ""))

                prepay_month = int(input("  At which month    : ").strip())

                prepayment_impact(

                    last_summary["principal"],

                    last_summary["annual_rate"],

                    last_summary["tenure_months"],

                    prepay_amt, prepay_month

                )

            except ValueError:

                print("  Invalid input.")

        elif choice == "6":

            if last_summary and last_schedule:

                fname = input("  Filename (Enter for auto): ").strip() or None

                export_to_csv(last_schedule, last_summary, fname)

            else:

                print("  No data to export. Calculate EMI first.")

        elif choice == "7":

            show_history()

        elif choice == "0":

            print("\n  Goodbye!\n")

            break

        else:

            print("  Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

    main()