sujithx 0.1.0__py3-none-any.whl

sujithx/__init__.py

@@ -0,0 +1,80 @@
+"""
+SUJITHX - The Ultimate Python Toolkit
+"""
+
+_version_ = "0.1.0"
+_author_ = "Sujith"
+
+
+def hello(name="Developer"):
+    """Return a personalized greeting."""
+    return f"Hello, {name}! Welcome to SUJITHX."
+
+
+def add(a, b):
+    """Add two numbers."""
+    return a + b
+
+
+def multiply(a, b):
+    """Multiply two numbers."""
+    return a * b
+
+
+def percentage(value, total):
+    """Calculate a percentage safely."""
+    if total == 0:
+        raise ValueError("Total cannot be zero.")
+
+    return (value / total) * 100
+from .files import (
+    search_files,
+    analyze_folder,
+    find_duplicates,
+    largest_files,
+    format_bytes,
+)
+from .security import (
+    sha256_text,
+    sha256_file,
+    generate_token,
+    generate_password,
+    check_password_strength,
+)
+from .colors import (
+    color_text,
+    success,
+    error,
+    warning,
+    info,
+    banner,
+    progress_bar,
+    print_progress,
+)
+from .logger import (
+    create_logger,
+    log_info,
+    log_warning,
+    log_error,
+    log_debug,
+)
+from .automation import (
+    ensure_directory,
+    list_files,
+    get_file_info,
+    copy_file,
+    read_text,
+    write_text,
+    file_exists,
+)
+from .system_info import (
+    get_system_info,
+    get_disk_info,
+    display_system_info,
+)
+from .network import (
+    get_hostname,
+    get_local_ip,
+    check_internet,
+    get_network_info,
+)

sujithx/automation.py

@@ -0,0 +1,96 @@
+"""Safe file and folder automation utilities for SUJITHX."""
+
+from pathlib import Path
+import shutil
+
+
+def ensure_directory(folder):
+    """Create a folder if it does not already exist."""
+    path = Path(folder).expanduser()
+    path.mkdir(parents=True, exist_ok=True)
+    return str(path.resolve())
+
+
+def list_files(folder, pattern="*"):
+    """List files inside a folder and its subfolders."""
+    root = Path(folder).expanduser()
+
+    if not root.is_dir():
+        raise NotADirectoryError(f"Folder not found: {root}")
+
+    return sorted(
+        (str(path) for path in root.rglob(pattern) if path.is_file()),
+        key=str.lower,
+    )
+
+
+def get_file_info(file_path):
+    """Return basic information about a file."""
+    path = Path(file_path).expanduser()
+
+    if not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    details = path.stat()
+
+    return {
+        "name": path.name,
+        "path": str(path.resolve()),
+        "extension": path.suffix.lower(),
+        "size_bytes": details.st_size,
+        "size_kb": round(details.st_size / 1024, 2),
+    }
+
+
+def copy_file(source, destination, overwrite=False):
+    """Copy a file without overwriting an existing file by default."""
+    source_path = Path(source).expanduser()
+    destination_path = Path(destination).expanduser()
+
+    if not source_path.is_file():
+        raise FileNotFoundError(f"Source file not found: {source_path}")
+
+    if destination_path.exists() and not overwrite:
+        raise FileExistsError(
+            f"Destination already exists: {destination_path}"
+        )
+
+    destination_path.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source_path, destination_path)
+
+    return str(destination_path.resolve())
+
+
+def read_text(file_path, encoding="utf-8"):
+    """Read a UTF-8 text file."""
+    path = Path(file_path).expanduser()
+
+    if not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    return path.read_text(encoding=encoding)
+
+
+def write_text(file_path, content, overwrite=False, encoding="utf-8"):
+    """Write a text file, refusing to overwrite by default."""
+    path = Path(file_path).expanduser()
+
+    if path.exists() and not overwrite:
+        raise FileExistsError(
+            f"File already exists: {path}. Set overwrite=True to replace it."
+        )
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if overwrite:
+        path.write_text(content, encoding=encoding)
+    else:
+        with path.open("x", encoding=encoding) as file:
+            file.write(content)
+
+    return str(path.resolve())
+
+
+def file_exists(file_path):
+    """Check whether a file exists."""
+    return Path(file_path).expanduser().is_file()

sujithx/cli.py

@@ -0,0 +1,132 @@
+"""SUJITHX - Unified Python Toolkit Command Center."""
+
+from . import (
+    hello,
+    analyze_folder,
+    search_files,
+    find_duplicates,
+    largest_files,
+    format_bytes,
+    generate_token,
+    generate_password,
+    check_password_strength,
+    ensure_directory,
+    get_file_info,
+    banner,
+    success,
+    error,
+    info,
+    display_system_info,
+    get_network_info,
+    create_logger,
+)
+
+
+def show_menu():
+    print("\n1. Welcome")
+    print("2. Analyze folder")
+    print("3. Search files")
+    print("4. Find duplicate files")
+    print("5. Show largest files")
+    print("6. Generate secure token")
+    print("7. Generate password")
+    print("8. Check password strength")
+    print("9. Create folder")
+    print("10. Get file information")
+    print("11. System information")
+    print("12. Network information")
+    print("13. Logging demonstration")
+    print("0. Exit")
+
+
+def main():
+    print(banner("SUJITHX COMMAND CENTER"))
+    logger = create_logger("SUJITHX_CLI", "sujithx_cli.log")
+
+    while True:
+        show_menu()
+        choice = input("\nChoose an option: ").strip()
+
+        try:
+            if choice == "1":
+                name = input("Your name: ").strip() or "Developer"
+                print(success(hello(name)))
+
+            elif choice == "2":
+                folder = input("Folder path: ").strip().strip('"')
+                result = analyze_folder(folder)
+                print("Folder:", result["folder"])
+                print("Files:", result["file_count"])
+                print("Size:", format_bytes(result["total_bytes"]))
+                print("Extensions:", result["extensions"])
+
+            elif choice == "3":
+                folder = input("Folder path: ").strip().strip('"')
+                pattern = input("Pattern (default ): ").strip() or ""
+                results = search_files(folder, pattern)
+                for path in results:
+                    print(path)
+                print(f"Found {len(results)} file(s).")
+
+            elif choice == "4":
+                folder = input("Folder path: ").strip().strip('"')
+                groups = find_duplicates(folder)
+                if not groups:
+                    print(success("No duplicates found."))
+                else:
+                    for group in groups:
+                        print("\nDuplicate group:")
+                        for path in group:
+                            print(" ", path)
+
+            elif choice == "5":
+                folder = input("Folder path: ").strip().strip('"')
+                for path, size in largest_files(folder, 10):
+                    print(f"{format_bytes(size):>12}  {path}")
+
+            elif choice == "6":
+                print("Generated token:", generate_token())
+
+            elif choice == "7":
+                print("Generated password:", generate_password())
+
+            elif choice == "8":
+                password = input("Password to evaluate: ")
+                result = check_password_strength(password)
+                print("Rating:", result["rating"])
+                print("Checks:", result["checks"])
+
+            elif choice == "9":
+                folder = input("Folder path to create: ").strip().strip('"')
+                print(success(ensure_directory(folder)))
+
+            elif choice == "10":
+                path = input("File path: ").strip().strip('"')
+                for key, value in get_file_info(path).items():
+                    print(f"{key}: {value}")
+
+            elif choice == "11":
+                display_system_info()
+
+            elif choice == "12":
+                for key, value in get_network_info().items():
+                    print(f"{key.replace('_', ' ').title()}: {value}")
+
+            elif choice == "13":
+                logger.info("SUJITHX logging demonstration.")
+                logger.warning("This is a sample warning.")
+                print(success("Log messages written to sujithx_cli.log"))
+
+            elif choice == "0":
+                print(success("SUJITHX closed. Goodbye!"))
+                break
+
+            else:
+                print(error("Choose a number from 0 to 13."))
+
+        except (OSError, ValueError, TypeError) as exc:
+            print(error(str(exc)))
+
+
+if __name__ == "__main__":
+    main()

sujithx/colors.py

@@ -0,0 +1,85 @@
+"""Terminal styling utilities for SUJITHX."""
+
+import shutil
+import sys
+
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+
+COLORS = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "white": "\033[37m",
+}
+
+
+def color_text(text, color="cyan", bold=False):
+    """Return text with ANSI terminal colors."""
+    if color not in COLORS:
+        raise ValueError(f"Unsupported color: {color}")
+
+    style = COLORS[color]
+    if bold:
+        style += BOLD
+
+    return f"{style}{text}{RESET}"
+
+
+def success(message):
+    """Format a success message."""
+    return color_text(f"[SUCCESS] {message}", "green", True)
+
+
+def error(message):
+    """Format an error message."""
+    return color_text(f"[ERROR] {message}", "red", True)
+
+
+def warning(message):
+    """Format a warning message."""
+    return color_text(f"[WARNING] {message}", "yellow", True)
+
+
+def info(message):
+    """Format an information message."""
+    return color_text(f"[INFO] {message}", "cyan")
+
+
+def banner(title="SUJITHX"):
+    """Create a centered terminal banner."""
+    width = max(40, min(shutil.get_terminal_size((80, 20)).columns, 100))
+    border = "=" * width
+    heading = f" {title} ".center(width, "=")
+
+    return (
+        color_text(border, "magenta", True)
+        + "\n"
+        + color_text(heading, "cyan", True)
+        + "\n"
+        + color_text(border, "magenta", True)
+    )
+
+
+def progress_bar(percent, width=30):
+    """Display a simple text progress bar."""
+    if not 0 <= percent <= 100:
+        raise ValueError("percent must be between 0 and 100")
+
+    if width < 1:
+        raise ValueError("width must be at least 1")
+
+    filled = round(width * percent / 100)
+    bar = "#" * filled + "-" * (width - filled)
+
+    return f"[{bar}] {percent:.1f}%"
+
+
+def print_progress(percent, width=30):
+    """Print a progress bar on the terminal."""
+    print(progress_bar(percent, width), file=sys.stdout)

sujithx/files.py

@@ -0,0 +1,108 @@
+"""File intelligence utilities for SUJITHX."""
+
+from pathlib import Path
+from collections import Counter
+import hashlib
+
+
+def search_files(folder, pattern="*"):
+    """Search for files recursively."""
+    root = Path(folder).expanduser()
+
+    if not root.is_dir():
+        raise NotADirectoryError(f"Folder not found: {root}")
+
+    return sorted(
+        (p for p in root.rglob(pattern) if p.is_file()),
+        key=lambda p: str(p).lower()
+    )
+
+
+def analyze_folder(folder):
+    """Analyze files and folders."""
+    root = Path(folder).expanduser()
+
+    if not root.is_dir():
+        raise NotADirectoryError(f"Folder not found: {root}")
+
+    files = [p for p in root.rglob("*") if p.is_file()]
+    extensions = Counter(
+        p.suffix.lower() or "[no extension]" for p in files
+    )
+
+    total_bytes = 0
+
+    for path in files:
+        try:
+            total_bytes += path.stat().st_size
+        except OSError:
+            pass
+
+    return {
+        "folder": str(root.resolve()),
+        "file_count": len(files),
+        "total_bytes": total_bytes,
+        "total_mb": round(total_bytes / (1024 * 1024), 2),
+        "extensions": dict(extensions),
+    }
+
+
+def find_duplicates(folder):
+    """Find duplicate files using SHA-256 hashes."""
+    root = Path(folder).expanduser()
+
+    if not root.is_dir():
+        raise NotADirectoryError(f"Folder not found: {root}")
+
+    hashes = {}
+
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+
+        try:
+            digest = hashlib.sha256()
+
+            with path.open("rb") as file:
+                for chunk in iter(lambda: file.read(1024 * 1024), b""):
+                    digest.update(chunk)
+
+            hashes.setdefault(digest.hexdigest(), []).append(str(path))
+
+        except OSError:
+            continue
+
+    return [paths for paths in hashes.values() if len(paths) > 1]
+
+
+def largest_files(folder, limit=10):
+    """Find the largest files."""
+    if limit < 1:
+        raise ValueError("limit must be at least 1")
+
+    root = Path(folder).expanduser()
+
+    if not root.is_dir():
+        raise NotADirectoryError(f"Folder not found: {root}")
+
+    files = []
+
+    for path in root.rglob("*"):
+        try:
+            if path.is_file():
+                files.append((str(path), path.stat().st_size))
+        except OSError:
+            continue
+
+    return sorted(files, key=lambda item: item[1], reverse=True)[:limit]
+
+
+def format_bytes(size):
+    """Convert bytes to a readable size."""
+    if size < 0:
+        raise ValueError("size cannot be negative")
+
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.2f} {unit}"
+        size /= 1024

sujithx/logger.py

@@ -0,0 +1,79 @@
+"""Professional logging utilities for SUJITHX."""
+
+import logging
+from pathlib import Path
+
+
+def create_logger(
+    name="SUJITHX",
+    log_file="sujithx.log",
+    level="INFO",
+):
+    """Create a logger that writes to both console and file."""
+
+    valid_levels = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL,
+    }
+
+    level_name = level.upper()
+
+    if level_name not in valid_levels:
+        raise ValueError(
+            "level must be DEBUG, INFO, WARNING, ERROR, or CRITICAL"
+        )
+
+    logger = logging.getLogger(name)
+    logger.setLevel(valid_levels[level_name])
+    logger.propagate = False
+
+    # Avoid adding duplicate handlers when called repeatedly.
+    if logger.handlers:
+        return logger
+
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(valid_levels[level_name])
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    if log_file:
+        path = Path(log_file).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        file_handler = logging.FileHandler(
+            path,
+            encoding="utf-8",
+        )
+        file_handler.setLevel(valid_levels[level_name])
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    return logger
+
+
+def log_info(message, logger=None):
+    """Log an informational message."""
+    (logger or create_logger()).info(message)
+
+
+def log_warning(message, logger=None):
+    """Log a warning message."""
+    (logger or create_logger()).warning(message)
+
+
+def log_error(message, logger=None):
+    """Log an error message."""
+    (logger or create_logger()).error(message)
+
+
+def log_debug(message, logger=None):
+    """Log a debug message."""
+    (logger or create_logger(level="DEBUG")).debug(message)

sujithx/network.py

@@ -0,0 +1,42 @@
+"""Basic, read-only network utilities for SUJITHX."""
+
+import socket
+import urllib.error
+import urllib.request
+
+
+def get_hostname():
+    """Return this computer's hostname."""
+    return socket.gethostname()
+
+
+def get_local_ip():
+    """Return the local IP address when available."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.connect(("192.0.2.1", 80))
+            return sock.getsockname()[0]
+    except OSError:
+        return "Unavailable"
+
+
+def check_internet(timeout=3):
+    """Check whether an HTTPS connection can be established."""
+    try:
+        request = urllib.request.Request(
+            "https://www.google.com/generate_204",
+            method="GET",
+        )
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.status in (200, 204)
+    except (OSError, urllib.error.URLError, TimeoutError):
+        return False
+
+
+def get_network_info():
+    """Return basic network information."""
+    return {
+        "hostname": get_hostname(),
+        "local_ip": get_local_ip(),
+        "internet_available": check_internet(),
+    }

sujithx/security.py

@@ -0,0 +1,85 @@
+"""Security utilities for the SUJITHX Python toolkit."""
+
+import hashlib
+import secrets
+import string
+from pathlib import Path
+
+
+def sha256_text(text):
+    """Return the SHA-256 hash of text."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def sha256_file(file_path):
+    """Calculate a file's SHA-256 hash."""
+    digest = hashlib.sha256()
+
+    with Path(file_path).open("rb") as file:
+        for chunk in iter(lambda: file.read(1024 * 1024), b""):
+            digest.update(chunk)
+
+    return digest.hexdigest()
+
+
+def generate_token(length=32):
+    """Generate a cryptographically secure hexadecimal token."""
+    if length < 16:
+        raise ValueError("Token length must be at least 16 characters.")
+
+    return secrets.token_hex((length + 1) // 2)[:length]
+
+
+def generate_password(length=16):
+    """Generate a secure password with varied character types."""
+    if length < 12:
+        raise ValueError("Password length must be at least 12.")
+
+    groups = [
+        string.ascii_lowercase,
+        string.ascii_uppercase,
+        string.digits,
+        "!@#$%^&*()-_=+",
+    ]
+
+    # Guarantee at least one character from each group.
+    password = [secrets.choice(group) for group in groups]
+    alphabet = "".join(groups)
+
+    password.extend(
+        secrets.choice(alphabet) for _ in range(length - len(password))
+    )
+
+    # Securely shuffle the password characters.
+    secrets.SystemRandom().shuffle(password)
+
+    return "".join(password)
+
+
+def check_password_strength(password):
+    """Provide a basic password-strength assessment."""
+    if not isinstance(password, str):
+        raise TypeError("Password must be a string.")
+
+    checks = {
+        "length": len(password) >= 12,
+        "lowercase": any(c.islower() for c in password),
+        "uppercase": any(c.isupper() for c in password),
+        "digit": any(c.isdigit() for c in password),
+        "symbol": any(not c.isalnum() for c in password),
+    }
+
+    score = sum(checks.values())
+
+    if score <= 2:
+        rating = "Weak"
+    elif score <= 4:
+        rating = "Moderate"
+    else:
+        rating = "Strong"
+
+    return {
+        "rating": rating,
+        "score": score,
+        "checks": checks,
+    }

sujithx/system_info.py

@@ -0,0 +1,57 @@
+"""Read-only system information utilities for SUJITHX."""
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+
+
+def get_system_info():
+    """Return basic computer and Python information."""
+    return {
+        "computer_name": platform.node() or "Unknown",
+        "operating_system": platform.system(),
+        "os_release": platform.release(),
+        "architecture": platform.machine(),
+        "python_version": platform.python_version(),
+        "python_executable": sys.executable,
+        "current_directory": str(Path.cwd()),
+        "cpu_count": os.cpu_count(),
+    }
+
+
+def get_disk_info(path="."):
+    """Return storage capacity information for a drive or folder."""
+    target = Path(path).expanduser()
+
+    if not target.exists():
+        raise FileNotFoundError(f"Path not found: {target}")
+
+    usage = shutil.disk_usage(target.resolve())
+
+    return {
+        "path": str(target.resolve()),
+        "total_bytes": usage.total,
+        "used_bytes": usage.used,
+        "free_bytes": usage.free,
+        "total_gb": round(usage.total / (1024 ** 3), 2),
+        "used_gb": round(usage.used / (1024 ** 3), 2),
+        "free_gb": round(usage.free / (1024 ** 3), 2),
+    }
+
+
+def display_system_info():
+    """Print system information in a readable format."""
+    print("\n=== SUJITHX SYSTEM INFORMATION ===")
+
+    for key, value in get_system_info().items():
+        print(f"{key.replace('_', ' ').title()}: {value}")
+
+    print("\n=== DISK INFORMATION ===")
+
+    try:
+        for key, value in get_disk_info().items():
+            print(f"{key.replace('_', ' ').title()}: {value}")
+    except OSError as exc:
+        print(f"Could not read disk information: {exc}")

sujithx-0.1.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: sujithx
+Version: 0.1.0
+Summary: A multipurpose Python toolkit for files, security, automation, and system utilities
+Author: Sujith
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+SUJITHX — The Ultimate Python Toolkit
+
+
+
+SUJITHX is a modular Python toolkit that combines file management, security utilities, automation, terminal styling, logging, system information, and network checks in one command-line application.
+
+
+
+Features
+
+
+
+\- File Intelligence: Search files, analyze folders, identify duplicates, and find large files.
+
+\- Security Utilities: Generate random tokens and passwords, calculate SHA-256 hashes, and perform basic password-strength checks.
+
+\- Automation: Create directories, inspect files, read text, and copy files safely without overwriting by default.
+
+\- Terminal Styling: Colored messages, banners, and progress bars.
+
+\- Logging: Write structured log messages to the console and log files.
+
+\- System Information: Inspect Python, operating system, and disk usage information.
+
+\- Network Utilities: Retrieve hostname and local IP information and check internet connectivity.
+
+\- Command Center: Access the tools through an interactive menu.
+
+
+
+Requirements
+
+
+
+\- Python 3.12 or newer
+
+\- Windows, macOS, or Linux
+
+\- No third-party runtime dependencies
+
+
+
+Installation
+
+
+
+Clone the repository, enter its folder, and install it in editable mode:
+
+
+
+git clone YOUR\_GITHUB\_REPOSITORY\_URL
+
+cd SUJITHX
+
+python -m venv .venv
+
+
+
+Activate the environment on Windows:
+
+
+
+.venv\\Scripts\\activate
+
+
+
+Install SUJITHX:
+
+
+
+python -m pip install -e .
+
+
+
+Run
+
+
+
+Launch the command center:
+
+
+
+python -m sujithx.cli
+
+
+
+After installation, you can also run:
+
+
+
+sujithx
+
+
+
+Example
+
+
+
+from sujithx import (
+
+    hello,
+
+    generate\_token,
+
+    analyze\_folder,
+
+)
+
+
+
+print(hello("Developer"))
+
+print(generate\_token())
+
+print(analyze\_folder("."))
+
+
+
+Security Notes
+
+
+
+\- Tokens and passwords are generated using Python's "secrets" module.
+
+\- SHA-256 functions calculate file or text hashes; they do not encrypt data.
+
+\- The password-strength checker is a basic heuristic, not a complete security assessment.
+
+\- Review file paths before running file operations.
+
+\- Keep generated passwords and tokens private.
+
+
+
+Project Status
+
+
+
+Version: 0.1.0
+
+
+
+This project is under active development. Contributions, suggestions, and bug reports are welcome.
+
+
+
+Author
+
+
+
+Sujith
+
+
+
+License
+
+
+
+MIT License.
+

sujithx-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+sujithx/__init__.py,sha256=7WzNX0W97QaSjvPhDxUQ3FBi1UvAJO70fPLuRqpkvAk,1432
+sujithx/_init_.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sujithx/automation.py,sha256=xKIkMXv1YQRj3l48-L_vi4O4vu4kONByYrndIFv7hb8,2795
+sujithx/cli.py,sha256=ft7JrcnQIzcTPLWFIRsxkBR44h3M1-f4RssnbNWDpHc,4402
+sujithx/colors.py,sha256=utv2wFK1d37hB2hJu2E8mF9js0t982Zfek0uSARoeVo,2087
+sujithx/files.py,sha256=Q_cTjcF1QCQSe7_o_ipswF5AnrfspFjPpsjKj-KPMHw,2811
+sujithx/logger.py,sha256=ytwXDZAr3BoSar86ajlNFYh7C3nfOWPL6U5nnRbSOiA,2119
+sujithx/network.py,sha256=6grrYNjBuFxHt2XZ8_XJX3xiJSPwlgJ6jNlZ7wwC--Q,1186
+sujithx/security.py,sha256=gc-GuBmx2T_LNjoErmoE8S5gaa20VJUCuOJUASxYE4s,2291
+sujithx/system_info.py,sha256=h8t4k4J0WLosEEDgngyQQ0HG9H_fLj-cRhdI9zLKxfo,1759
+sujithx-0.1.0.dist-info/licenses/LICENSE.txt,sha256=XW_tPU-gZnH4YJXgI2W2g7fmqfyhotu6y3GdPHBGt88,819
+sujithx-0.1.0.dist-info/METADATA,sha256=sHYRRVu90uwvj6EW0BxWjKELtZ6NqENrNFkxL_y2Byc,2718
+sujithx-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+sujithx-0.1.0.dist-info/entry_points.txt,sha256=PKIro9f7u4-RZoyuGZ9FkFYbCLf-mXpZYK5qi9iubQE,45
+sujithx-0.1.0.dist-info/top_level.txt,sha256=utVaqKJ4Ll-Dg-xSPaiciSNXxiulfH2Z6BAVH9v9iuo,8
+sujithx-0.1.0.dist-info/RECORD,,

sujithx-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sujithx-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sujithx = sujithx.cli:main

sujithx-0.1.0.dist-info/licenses/LICENSE.txt

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

sujithx-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sujithx