import os
from datetime import datetime

def parse_log(log_path):
    """Read a log file and return counts and recent errors."""
    counts    = {"INFO": 0, "WARNING": 0, "ERROR": 0}
    error_lines = []

    with open(log_path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            for level in counts:
                if level in line:
                    counts[level] += 1
                    if level == "ERROR":
                        error_lines.append(line)
                    break

    return counts, error_lines[-5:]    # last 5 errors

def write_summary(log_path, counts, recent_errors, out_path):
    """Write a plain-text summary report."""
    ts        = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    log_name  = os.path.basename(log_path)
    total     = sum(counts.values())

    with open(out_path, "w", encoding="utf-8") as f:
        f.write(f"Log Analysis Report\n")
        f.write(f"Generated : {ts}\n")
        f.write(f"Source    : {log_name}\n")
        f.write(f"{'─' * 40}\n\n")
        f.write(f"Total lines : {total}\n")
        for level, count in counts.items():
            pct = (count / total * 100) if total else 0
            f.write(f"  {level:8}: {count:>4} ({pct:.1f}%)\n")

        if recent_errors:
            f.write(f"\nRecent errors ({len(recent_errors)}):\n")
            for err in recent_errors:
                f.write(f"  {err}\n")

# ── Run ──
log_file = "app.log"
out_file = "log_summary.txt"
counts, recent_errors = parse_log(log_file)
write_summary(log_file, counts, recent_errors, out_file)

print(f"Summary written to {out_file}")
print(f"Errors: {counts['ERROR']}  Warnings: {counts['WARNING']}")

import csv

def load_employees(filepath):
    """Load CSV into a list of dicts with type conversion."""
    employees = []
    with open(filepath, "r", encoding="utf-8", newline="") as f:
        for row in csv.DictReader(f):
            employees.append({
                "emp_id":     row["emp_id"],
                "name":       row["name"],
                "department": row["department"],
                "salary":     int(row["salary"]),
                "active":     row["active"].lower() == "true",
            })
    return employees

def filter_active_above(employees, min_salary):
    """Return active employees earning at or above min_salary."""
    return [e for e in employees
            if e["active"] and e["salary"] >= min_salary]

def dept_totals(employees):
    """Return dict of department → total salary."""
    totals = {}
    for e in employees:
        totals[e["department"]] = totals.get(e["department"], 0) + e["salary"]
    return totals

def write_report_csv(employees, filepath):
    """Write filtered employees to a new CSV file."""
    fields = ["emp_id", "name", "department", "salary"]
    with open(filepath, "w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(employees)

# ── Run ──
all_emp   = load_employees("employees.csv")
filtered  = filter_active_above(all_emp, min_salary=75000)
totals    = dept_totals(filtered)

write_report_csv(filtered, "high_earners.csv")

print(f"Filtered {len(filtered)} of {len(all_emp)} employees → high_earners.csv")
print("\nDepartment payroll (active, ≥₹75,000):")
for dept, total in sorted(totals.items()):
    print(f"  {dept:12}: ₹{total:,}")

import json
import os
from datetime import datetime

REQUIRED_FIELDS = ["app_name", "version", "environments"]

def load_deployment_config(path):
    """Load and validate a JSON deployment config. Returns dict or raises."""
    if not os.path.isfile(path):
        raise FileNotFoundError(f"Config not found: {path}")

    with open(path, "r", encoding="utf-8") as f:
        config = json.load(f)

    missing = [k for k in REQUIRED_FIELDS if k not in config]
    if missing:
        raise ValueError(f"Config missing required fields: {missing}")

    return config

def deploy(config, target_env):
    """Simulate deployment: update config with timestamp and env info."""
    if target_env not in config["environments"]:
        raise KeyError(f"Unknown environment: {target_env}")

    env_cfg = config["environments"][target_env]
    config["last_deployed"] = {
        "environment": target_env,
        "timestamp":   datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
        "replicas":    env_cfg["replicas"],
        "db_host":     env_cfg["db_host"],
    }
    return config

def save_config(config, path):
    """Write config back to disk as indented JSON."""
    with open(path, "w", encoding="utf-8") as f:
        json.dump(config, f, indent=2)

# ── Run ──
config_path = "deployment.json"
target      = "staging"

config = load_deployment_config(config_path)
print(f"Loaded config for {config['app_name']} v{config['version']}")

config = deploy(config, target)
save_config(config, config_path)

dep = config["last_deployed"]
print(f"Deployed to {dep['environment']} at {dep['timestamp']}")
print(f"DB host  : {dep['db_host']}")
print(f"Replicas : {dep['replicas']}")
print(f"Config saved → {os.path.abspath(config_path)}")

import os
import csv
import json
from datetime import datetime

def inspect_csv(filepath):
    """Return column names and row count for a CSV file."""
    with open(filepath, "r", encoding="utf-8", newline="") as f:
        reader = csv.DictReader(f)
        columns = reader.fieldnames or []
        row_count = sum(1 for _ in reader)
    return list(columns), row_count

def build_manifest(data_dir, output_path):
    """
    Scan data_dir for CSV files and write a JSON manifest.

    Args:
        data_dir    (str): Directory containing CSV training files.
        output_path (str): Where to write the manifest JSON.
    """
    if not os.path.isdir(data_dir):
        raise NotADirectoryError(f"Not a directory: {data_dir}")

    datasets = []
    for filename in sorted(os.listdir(data_dir)):
        if not filename.endswith(".csv"):
            continue
        filepath  = os.path.join(data_dir, filename)
        size_kb   = os.path.getsize(filepath) / 1024
        cols, rows = inspect_csv(filepath)
        name, _   = os.path.splitext(filename)

        datasets.append({
            "name":        name,
            "filename":    filename,
            "rows":        rows,
            "columns":     cols,
            "column_count": len(cols),
            "size_kb":     round(size_kb, 2),
        })

    manifest = {
        "generated_at": datetime.now().strftime("%Y-%m-%dT%H:%M:%S"),
        "data_dir":     os.path.abspath(data_dir),
        "total_files":  len(datasets),
        "total_rows":   sum(d["rows"] for d in datasets),
        "datasets":     datasets,
    }

    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(manifest, f, indent=2)

    return manifest

# ── Run ──
manifest = build_manifest("training_data", "dataset_manifest.json")

print(f"Manifest built: {manifest['total_files']} files, "
      f"{manifest['total_rows']} total rows")
print()
for ds in manifest["datasets"]:
    print(f"  {ds['name']:25} {ds['rows']:>6} rows  "
          f"{ds['column_count']} cols  {ds['size_kb']} KB")

import configparser
import os
from datetime import datetime

# Simulated server data (in a real script this comes from an API or SSH)
FLEET = [
    {"name": "prod-web-01", "cpu": 88, "mem": 72, "disk": 55},
    {"name": "prod-db-01",  "cpu": 62, "mem": 91, "disk": 83},
    {"name": "prod-api-01", "cpu": 44, "mem": 60, "disk": 40},
]

def load_config(ini_path):
    """Load and return the config. Raises if file is missing."""
    if not os.path.isfile(ini_path):
        raise FileNotFoundError(f"Config file not found: {ini_path}")
    cfg = configparser.ConfigParser()
    cfg.read(ini_path, encoding="utf-8")
    return cfg

def check_alerts(servers, cpu_thresh, mem_thresh):
    """Return list of alert strings for servers breaching thresholds."""
    alerts = []
    for s in servers:
        if s["cpu"] > cpu_thresh:
            alerts.append(f"CPU ALERT  {s['name']}: {s['cpu']}% (threshold {cpu_thresh}%)")
        if s["mem"] > mem_thresh:
            alerts.append(f"MEM ALERT  {s['name']}: {s['mem']}% (threshold {mem_thresh}%)")
    return alerts

def write_report(cfg, servers, alerts):
    """Write the daily report to the configured output directory."""
    out_dir    = cfg.get("reporting", "output_dir")
    fmt        = cfg.get("reporting", "filename_fmt")
    filename   = datetime.now().strftime(fmt)
    report_path = os.path.join(out_dir, filename)

    os.makedirs(out_dir, exist_ok=True)

    with open(report_path, "w", encoding="utf-8") as f:
        f.write(f"Daily Server Report — {datetime.now().strftime('%d %b %Y %H:%M')}\n")
        f.write(f"Database : {cfg['database']['host']} / {cfg['database']['name']}\n")
        f.write(f"{'─' * 50}\n\n")

        f.write(f"{'Server':18} {'CPU':>5} {'Mem':>5} {'Disk':>6}\n")
        f.write(f"{'─' * 40}\n")
        for s in servers:
            f.write(f"{s['name']:18} {s['cpu']:>4}% {s['mem']:>4}% {s['disk']:>5}%\n")

        f.write(f"\nAlerts ({len(alerts)}):\n")
        if alerts:
            for a in alerts:
                f.write(f"  ⚠ {a}\n")
        else:
            f.write("  No alerts.\n")

    return report_path

# ── Run ──
cfg     = load_config("monitor.ini")
alerts  = check_alerts(
    FLEET,
    cpu_thresh = cfg.getint("reporting", "alert_cpu"),
    mem_thresh = cfg.getint("reporting", "alert_mem")
)
path = write_report(cfg, FLEET, alerts)
print(f"Report written: {path}")
print(f"Alerts: {len(alerts)}")
for a in alerts:
    print(f"  {a}")