dancealgorithm 0.1.0__py3-none-any.whl

dancealgorithm/assignments/__init__.py

@@ -0,0 +1,65 @@
+"""
+DanceAlgorithm Bundled Problem Sheets & Assignments Vault.
+Contains all 24 DAA algorithms and problem sheets.
+"""
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any, Dict, List
+
+ASSIGNMENTS_DIR = Path(__file__).resolve().parent
+
+REGISTRY: Dict[Any, Any] = {}
+SHEETS: List[Any] = []
+DAA_ASSIGNMENTS: Dict[str, Any] = {}
+
+ORDERED_NAMES = [
+    "MS - Customer",
+    "MS - Commerce",
+    "MS - Library",
+    "QS - Movie",
+    "QS - Commerce",
+    "QS - Online",
+    "FK - Emergency",
+    "FK - Electric",
+    "FK - Advertisement",
+    "DA - Smart",
+    "DA - Campus",
+    "DA - Flight",
+    "MSG - Logistics",
+    "MSG - Skyconnect",
+    "MSG - Emergency",
+    "K - Disaster",
+    "K - Hospital",
+    "K - Cloud",
+    "GC - Classroom",
+    "GC - Interference",
+    "GC - University",
+    "LC - Delivery",
+    "LC - Drilling",
+    "LC - Flight",
+]
+
+for idx, name in enumerate(ORDERED_NAMES, 1):
+    folder = ASSIGNMENTS_DIR / name
+    if folder.is_dir():
+        try:
+            mod = importlib.import_module(f".{name}", package=__name__)
+            globals()[name] = mod
+            SHEETS.append(mod)
+
+            REGISTRY[idx] = mod
+            REGISTRY[f"ps{idx}"] = mod
+            REGISTRY[f"PS{idx}"] = mod
+            REGISTRY[f"ps{idx:02d}"] = mod
+            REGISTRY[f"PS{idx:02d}"] = mod
+
+            norm = name.lower().replace(" ", "").replace("-", "").replace("_", "")
+            DAA_ASSIGNMENTS[norm] = mod
+            REGISTRY[name] = mod
+            REGISTRY[norm] = mod
+        except Exception:
+            pass
+
+__all__ = ["REGISTRY", "SHEETS", "DAA_ASSIGNMENTS", "ASSIGNMENTS_DIR"]

dancealgorithm/cli.py

@@ -0,0 +1,349 @@
+"""
+CLI interface for DanceAlgorithm.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from dancealgorithm import __version__
+from dancealgorithm.config import (
+    get_branch,
+    get_destination,
+    get_repo,
+    get_token,
+    load_config,
+    reset_config,
+    set_branch,
+    set_destination,
+    set_repo,
+)
+from dancealgorithm.downloader import (
+    BUNDLED_DIR,
+    DanceAlgorithmError,
+    extract_archive,
+    extract_bundled,
+    fetch_archive,
+    inspect_archive,
+    parse_repo_string,
+)
+
+# Reconfigure console streams on Windows to prevent cp1252 charmap errors
+if sys.platform == "win32":
+    try:
+        if hasattr(sys.stdout, "reconfigure"):
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        if hasattr(sys.stderr, "reconfigure"):
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+
+def run_install(
+    destination: Path,
+    subject: Optional[str] = None,
+    repo_str: Optional[str] = None,
+    branch: Optional[str] = None,
+    token: Optional[str] = None,
+    force: bool = True,
+    quiet: bool = False,
+) -> int:
+    """
+    Executes assignment extraction and outputs the destination path.
+    """
+    target_path = destination.resolve()
+
+    try:
+        if repo_str:
+            owner, repo = parse_repo_string(repo_str)
+            branch = branch or get_branch()
+            archive_data = fetch_archive(
+                owner=owner,
+                repo=repo,
+                branch=branch,
+                token=token,
+                silent=True,
+            )
+            extracted = extract_archive(
+                archive_data=archive_data,
+                destination=destination,
+                subject_filter=subject,
+                overwrite=force,
+            )
+        else:
+            extracted = extract_bundled(
+                destination=destination,
+                subject_filter=subject,
+                overwrite=force,
+            )
+
+    except DanceAlgorithmError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        return 1
+
+    if not extracted:
+        if not quiet:
+            if subject:
+                print(f"Error: No problem sheets found matching '{subject}'.", file=sys.stderr)
+            else:
+                print("Error: No files were extracted.", file=sys.stderr)
+        return 1
+
+    if not quiet:
+        out_path = target_path
+        if subject and extracted:
+            try:
+                sub_parts = [
+                    p.relative_to(target_path).parts
+                    for p in extracted
+                    if len(p.relative_to(target_path).parts) > 1
+                ]
+                if sub_parts:
+                    out_path = target_path / sub_parts[0][0]
+            except Exception:
+                out_path = target_path
+        print(out_path)
+
+    return 0
+
+
+def check_and_display_text(target: str) -> bool:
+    """
+    If target matches an algorithm notes .txt file (e.g. DA.txt, da, ms.txt, etc.),
+    print its contents directly to the terminal screen without extracting any files.
+    """
+    if not BUNDLED_DIR.exists():
+        return False
+
+    clean_target = target.strip().replace("/", "\\").split("\\")[-1]
+    norm = clean_target.lower().replace("-", "").replace("_", "").replace(" ", "")
+    norm_base = norm.removesuffix(".txt")
+
+    for f in BUNDLED_DIR.glob("*.txt"):
+        f_norm = f.name.lower().replace("-", "").replace("_", "").replace(" ", "")
+        f_base = f_norm.removesuffix(".txt")
+        if norm == f_norm or norm == f_base or norm_base == f_base:
+            try:
+                print(f.read_text(encoding="utf-8"))
+                return True
+            except Exception:
+                pass
+    return False
+
+
+def handle_download(args: argparse.Namespace) -> int:
+    subject = " ".join(args.subject).strip() if isinstance(args.subject, list) else (args.subject or "").strip()
+    if not subject:
+        subject = None
+
+    if subject:
+        if check_and_display_text(subject):
+            return 0
+
+    destination = get_destination(args.output)
+    repo = get_repo(args.repo)
+    branch = get_branch(args.branch)
+    token = get_token(args.token)
+    return run_install(
+        destination=destination,
+        subject=subject,
+        repo_str=repo,
+        branch=branch,
+        token=token,
+        force=args.force,
+        quiet=args.quiet,
+    )
+
+
+def handle_list(args: argparse.Namespace) -> int:
+    repo_str = get_repo(args.repo)
+    if not repo_str:
+        print("📚 Available Bundled DAA Problem Sheets:\n")
+        if BUNDLED_DIR.exists():
+            for folder in sorted(
+                [f for f in BUNDLED_DIR.iterdir() if f.is_dir() and not f.name.startswith((".", "__")) and f.name != "__pycache__"],
+                key=lambda p: p.name,
+            ):
+                files = [
+                    f.relative_to(folder).as_posix()
+                    for f in folder.rglob("*")
+                    if f.is_file()
+                    and "__pycache__" not in f.parts
+                    and not f.name.endswith((".pyc", ".class"))
+                    and f.name != "__init__.py"
+                ]
+                print(f"📁 {folder.name} ({len(files)} files)")
+                for f in files:
+                    print(f"   ├── {f}")
+
+            txt_files = sorted(list(BUNDLED_DIR.glob("*.txt")))
+            if txt_files:
+                print("\n📝 Available Algorithm Notes & Complexities:")
+                for tf in txt_files:
+                    print(f"   • {tf.name}  (run: dance {tf.name})")
+
+        print("\n💡 Tip: Run 'dance <folder-name>' (e.g. 'dance MSG - Logistics') to extract only that folder.")
+        print("💡 Tip: Run 'dance <ALGO.txt>' (e.g. 'dance DA.txt') to display algorithm notes directly on screen.")
+        return 0
+
+    try:
+        owner, repo = parse_repo_string(repo_str)
+        branch = get_branch(args.branch)
+        token = get_token(args.token)
+        print(f"🔍 Inspecting remote catalogue in {owner}/{repo} (branch: {branch})...\n")
+        archive_data = fetch_archive(owner=owner, repo=repo, branch=branch, token=token, silent=True)
+        structure = inspect_archive(archive_data)
+        print("📚 Available Problem Sheets & Lab Files:")
+        for subject, files in sorted(structure.items()):
+            print(f"\n📁 {subject} ({len(files)} files)")
+            for f in files[:8]:
+                print(f"   ├── {f}")
+            if len(files) > 8:
+                print(f"   └── ... and {len(files) - 8} more files")
+        return 0
+    except DanceAlgorithmError as e:
+        print(f"❌ Error: {e}")
+        return 1
+
+
+def handle_config(args: argparse.Namespace) -> int:
+    if args.reset:
+        reset_config()
+        print("✅ Configuration reset to defaults.")
+        return 0
+
+    if args.set_dest:
+        set_destination(args.set_dest)
+        print(f"✅ Default destination set to: '{get_destination()}'")
+
+    if args.set_repo:
+        try:
+            parse_repo_string(args.set_repo)
+            set_repo(args.set_repo)
+            print(f"✅ Default GitHub repo set to: '{args.set_repo}'")
+        except DanceAlgorithmError as e:
+            print(f"❌ {e}")
+            return 1
+
+    if args.set_branch:
+        set_branch(args.set_branch)
+        print(f"✅ Default branch set to: '{args.set_branch}'")
+
+    cfg = load_config()
+    print("\n⚙️  DanceAlgorithm Configuration:")
+    print(f"   • Destination: {get_destination()} {'(custom)' if 'destination' in cfg else '(system default)'}")
+    print(f"   • Remote Repo: {get_repo() or 'None (using bundled offline vault)'}")
+    print(f"   • Config File: {Path.home() / '.dancealgorithm' / 'config.json'}\n")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="dancealgorithm",
+        description="DanceAlgorithm: Instant DAA Algorithms, Lab Problem Sheets, Datasets & Code Vault.",
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # download subcommand (default action)
+    p_dl = subparsers.add_parser("download", help="Download / extract problem sheets or view notes")
+    p_dl.add_argument(
+        "subject",
+        nargs="*",
+        default=[],
+        help="Problem sheet or notes (e.g. 'MSG - Logistics', 'DA - Smart', 'DA.txt')",
+    )
+    p_dl.add_argument(
+        "-o",
+        "--output",
+        default=None,
+        help="Target folder (default: C:\\DAA_Assignments)",
+    )
+    p_dl.add_argument(
+        "-r",
+        "--repo",
+        default=None,
+        help="Remote GitHub repository ('owner/repo')",
+    )
+    p_dl.add_argument(
+        "-b",
+        "--branch",
+        default=None,
+        help="Branch name (default: main)",
+    )
+    p_dl.add_argument(
+        "-t",
+        "--token",
+        default=None,
+        help="GitHub PAT for private repos",
+    )
+    p_dl.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=True,
+        help="Overwrite existing files",
+    )
+    p_dl.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Run silently without output",
+    )
+    p_dl.set_defaults(func=handle_download)
+
+    # list subcommand
+    p_list = subparsers.add_parser("list", help="List available problem sheets and notes")
+    p_list.add_argument("-r", "--repo", default=None, help="Remote GitHub repository")
+    p_list.add_argument("-b", "--branch", default=None, help="Branch name")
+    p_list.add_argument("-t", "--token", default=None, help="GitHub PAT for private repos")
+    p_list.set_defaults(func=handle_list)
+
+    # config subcommand
+    p_cfg = subparsers.add_parser("config", help="View or modify saved settings")
+    p_cfg.add_argument("--set-dest", metavar="PATH", help="Set default destination directory")
+    p_cfg.add_argument("--set-repo", metavar="OWNER/REPO", help="Set default remote repository")
+    p_cfg.add_argument("--set-branch", metavar="BRANCH", help="Set default branch")
+    p_cfg.add_argument("--reset", action="store_true", help="Reset configuration back to defaults")
+    p_cfg.set_defaults(func=handle_config)
+
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+    else:
+        argv = list(argv)
+
+    subcommands = {"download", "list", "config", "-h", "--help", "-v", "--version"}
+
+    # Seamless shortcut routing:
+    # 1. `dance` -> `dance download`
+    # 2. `dance MSG - Logistics` -> `dance download MSG - Logistics`
+    # 3. `dance DA.txt` -> `dance download DA.txt`
+    # 4. `dance -o <path>` -> `dance download -o <path>`
+    if not argv:
+        argv = ["download"]
+    elif argv[0] not in subcommands:
+        if not argv[0].startswith("-"):
+            argv = ["download"] + argv
+        elif argv[0] not in {"-h", "--help", "-v", "--version"}:
+            argv = ["download"] + argv
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dancealgorithm/config.py

@@ -0,0 +1,125 @@
+"""
+Configuration management for DanceAlgorithm.
+Supports user configuration stored in ~/.dancealgorithm/config.json,
+environment variables, and command-line overrides.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+CONFIG_DIR = Path.home() / ".dancealgorithm"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def get_system_default_destination() -> Path:
+    r"""
+    Default target folder for assignments:
+    - Windows: C:\DAA_Assignments (falls back to ~/DAA_Assignments if C:\ is not writable)
+    - macOS / Linux: ~/DAA_Assignments
+    """
+    if sys.platform == "win32":
+        candidate = Path("C:/DAA_Assignments")
+        try:
+            candidate.mkdir(parents=True, exist_ok=True)
+            return candidate
+        except (PermissionError, OSError):
+            return Path.home() / "DAA_Assignments"
+    return Path.home() / "DAA_Assignments"
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from ~/.dancealgorithm/config.json."""
+    if not CONFIG_FILE.exists():
+        return {}
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data if isinstance(data, dict) else {}
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save configuration to ~/.dancealgorithm/config.json."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_destination(cli_dest: str | None = None) -> Path:
+    r"""
+    Resolve target directory for problem sheets:
+    1. CLI argument (--output / -o)
+    2. Environment variable DANCEALGORITHM_DEST
+    3. User saved config
+    4. System default (C:\DAA_Assignments on Windows)
+    """
+    if cli_dest:
+        return Path(cli_dest)
+
+    env_dest = os.environ.get("DANCEALGORITHM_DEST")
+    if env_dest:
+        return Path(env_dest)
+
+    cfg = load_config()
+    if "destination" in cfg and cfg["destination"]:
+        return Path(cfg["destination"])
+
+    return get_system_default_destination()
+
+
+def set_destination(dest_path: str) -> Path:
+    """Persist a new default target folder in ~/.dancealgorithm/config.json."""
+    target = Path(dest_path).expanduser().resolve()
+    cfg = load_config()
+    cfg["destination"] = str(target)
+    save_config(cfg)
+    return target
+
+
+def get_repo(cli_repo: str | None = None) -> str | None:
+    if cli_repo:
+        return cli_repo
+    env_repo = os.environ.get("DANCEALGORITHM_REPO")
+    if env_repo:
+        return env_repo
+    cfg = load_config()
+    return cfg.get("repo")
+
+
+def set_repo(repo_str: str) -> None:
+    cfg = load_config()
+    cfg["repo"] = repo_str.strip()
+    save_config(cfg)
+
+
+def get_branch(cli_branch: str | None = None) -> str:
+    if cli_branch:
+        return cli_branch
+    env_branch = os.environ.get("DANCEALGORITHM_BRANCH")
+    if env_branch:
+        return env_branch
+    cfg = load_config()
+    return cfg.get("branch", "main")
+
+
+def set_branch(branch_str: str) -> None:
+    cfg = load_config()
+    cfg["branch"] = branch_str.strip()
+    save_config(cfg)
+
+
+def get_token(cli_token: str | None = None) -> str | None:
+    if cli_token:
+        return cli_token
+    return os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+
+
+def reset_config() -> None:
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()