devspace 0.1.0__py3-none-any.whl

devspace/__init__.py

@@ -0,0 +1,4 @@
+"""devspace package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

devspace/cli.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .config import create_space, load_project_config
+from .orchestrator import launch_workspace, quick_run, run_session_launch, status_ribbon
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="devspace",
+        description="Create and manage devspace project workspaces.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    create_parser = subparsers.add_parser("create", help="Create a new devspace")
+    create_parser.add_argument("name", help="Name of the devspace to create")
+
+    load_parser = subparsers.add_parser("load", help="Load a .devspace.toml file")
+    load_parser.add_argument("project", nargs="?", default=".", help="Project directory or space name to inspect")
+
+    launch_parser = subparsers.add_parser("launch", help="Launch the configured workspace sessions")
+    launch_parser.add_argument("project", nargs="?", default=".", help="Project directory or space name")
+
+    status_parser = subparsers.add_parser("status", help="Open the lightweight status ribbon")
+    status_parser.add_argument("project", nargs="?", default=".", help="Project directory or space name")
+
+    quick_parser = subparsers.add_parser("quick-run", help="Run a quick project command from the config")
+    quick_parser.add_argument("project", nargs="?", default=".", help="Project directory or space name")
+    quick_parser.add_argument("index", nargs="?", default="0", help="Zero-based index of the quick run command")
+
+    args = parser.parse_args(argv)
+
+    if args.command == "create":
+        project_dir = create_space(args.name)
+        print(f"Created devspace '{args.name}' at {project_dir}")
+        return 0
+
+    if args.command == "load":
+        project = Path(args.project)
+        try:
+            config = load_project_config(project)
+        except FileNotFoundError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        print(json.dumps(config, indent=2, sort_keys=True))
+        return 0
+
+    if args.command == "launch":
+        project = Path(args.project)
+        try:
+            config = load_project_config(project)
+        except FileNotFoundError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        plan = launch_workspace(project, config)
+        run_session_launch(project, config)
+        print(json.dumps(plan, indent=2, sort_keys=True))
+        return 0
+
+    if args.command == "status":
+        project = Path(args.project)
+        try:
+            config = load_project_config(project)
+        except FileNotFoundError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        status_ribbon(project, config)
+        return 0
+
+    if args.command == "quick-run":
+        project = Path(args.project)
+        try:
+            config = load_project_config(project)
+        except FileNotFoundError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+        return quick_run(project, config, int(args.index))
+
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

devspace/config.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+import tomllib
+
+
+def create_space(name: str, base_dir: str | Path = ".") -> Path:
+    """Create a new devspace directory with a starter .devspace.toml config."""
+    project_dir = Path(base_dir) / name
+    project_dir.mkdir(parents=True, exist_ok=False)
+
+    commands = [
+        "pwd",
+        "echo 'devspace ready'",
+    ]
+    browser_targets = [
+        "https://example.com",
+    ]
+    config = f"""
+[project]
+name = "{name}"
+root = "."
+venv = ".venv"
+
+[windows]
+count = 2
+layout = "grid"
+commands = {json.dumps(commands)}
+
+[open]
+urls = {json.dumps(browser_targets)}
+terminals = ["bash -lc 'pwd'", "bash -lc 'echo devspace ready'"]
+
+[[open.actions]]
+type = "terminal"
+command = "bash -lc 'pwd'"
+
+[[open.actions]]
+type = "browser"
+url = "https://example.com"
+
+[[open.actions]]
+type = "command"
+command = "bash -lc 'echo devspace ready'"
+
+[status]
+ports = ["8000", "8080"]
+
+[quickrun]
+commands = ["pytest -q", "python -m http.server 8000"]
+""".strip()
+
+    config_path = project_dir / ".devspace.toml"
+    config_path.write_text(config + "\n", encoding="utf-8")
+    return project_dir
+
+
+def resolve_project_path(project_arg: str | Path) -> Path:
+    """Resolve a devspace project path from a name or file path."""
+    project_path = Path(project_arg)
+    if project_path.is_dir() and (project_path / ".devspace.toml").exists():
+        return project_path
+    if project_path.name == ".devspace.toml":
+        return project_path.parent
+    if project_path.suffix == ".toml":
+        return project_path.parent
+    if project_path.exists() and project_path.is_dir():
+        return project_path
+    return project_path
+
+
+def load_project_config(project_dir: str | Path = ".") -> dict[str, Any]:
+    """Load a project's .devspace.toml configuration file."""
+    project_path = resolve_project_path(project_dir)
+    config_path = project_path if project_path.name == ".devspace.toml" else project_path / ".devspace.toml"
+
+    if not config_path.exists():
+        raise FileNotFoundError(f"No .devspace.toml file found in {project_path}")
+
+    with config_path.open("rb") as handle:
+        return tomllib.load(handle)

devspace/orchestrator.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import os
+import shutil
+import socket
+import subprocess
+from pathlib import Path
+from typing import Any
+
+
+def _district_env(project_dir: Path, config: dict[str, Any]) -> dict[str, str]:
+    env = os.environ.copy()
+    env["DEVSPACE_PROJECT_ROOT"] = str(project_dir.resolve())
+    env["DEVSPACE_PROJECT_NAME"] = str(config.get("project", {}).get("name", project_dir.name))
+    env["DEVSPACE_VENV"] = str(config.get("project", {}).get("venv", ".venv"))
+    return env
+
+
+def _open_linux_url(url: str) -> None:
+    candidates = [
+        ["xdg-open", url],
+        ["x-www-browser", url],
+        ["www-browser", url],
+        ["sensible-browser", url],
+        ["/usr/bin/open", url],
+    ]
+    browser = os.environ.get("BROWSER")
+    if browser:
+        candidates.insert(0, [browser, url])
+
+    for command in candidates:
+        if shutil.which(command[0]) is None:
+            continue
+        subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        return
+
+    python_bin = shutil.which("python3") or shutil.which("python")
+    if python_bin:
+        subprocess.Popen([python_bin, "-m", "webbrowser", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def _port_is_open(port: str | int) -> bool:
+    port_int = int(port)
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.5)
+        return sock.connect_ex(("127.0.0.1", port_int)) == 0
+
+
+def _run_open_action(project_dir: Path, env: dict[str, str], action: dict[str, Any]) -> None:
+    action_type = str(action.get("type", "command")).lower()
+    if action_type == "browser":
+        url = action.get("url") or action.get("target")
+        if url:
+            _open_linux_url(str(url))
+        return
+
+    if action_type == "terminal":
+        command = action.get("command") or action.get("cmd") or "bash"
+        subprocess.Popen(["bash", "-lc", str(command)], cwd=str(project_dir), env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+        return
+
+    command = action.get("command") or action.get("cmd") or action.get("shell")
+    if command:
+        subprocess.Popen(["bash", "-lc", str(command)], cwd=str(project_dir), env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+
+
+def launch_workspace(project_dir: str | Path, config: dict[str, Any]) -> dict[str, Any]:
+    """Create a lightweight workspace launch plan from the config."""
+    project_path = Path(project_dir)
+    windows = int(config.get("windows", {}).get("count", 1))
+    commands = config.get("windows", {}).get("commands", [])
+    if not commands:
+        commands = ["pwd"] * max(windows, 1)
+    env = _district_env(project_path, config)
+
+    session = []
+    for idx in range(max(windows, 1)):
+        cmd = commands[idx] if idx < len(commands) else "pwd"
+        session.append({
+            "index": idx,
+            "command": cmd,
+            "cwd": str(project_path),
+            "env": env,
+        })
+
+    opens = config.get("open", {})
+    urls = opens.get("urls", [])
+    terminals = opens.get("terminals", [])
+    explicit_actions = opens.get("actions", [])
+    plan = {
+        "project": project_path.name,
+        "windows": windows,
+        "sessions": session,
+        "status": "ready",
+        "opens": {
+            "urls": urls,
+            "terminals": terminals,
+            "actions": explicit_actions,
+        },
+    }
+
+    for url in urls:
+        _open_linux_url(url)
+    for terminal in terminals:
+        subprocess.Popen(["bash", "-lc", terminal], cwd=str(project_path), env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+    for action in explicit_actions:
+        _run_open_action(project_path, env, action)
+
+    return plan
+
+
+def quick_run(project_dir: str | Path, config: dict[str, Any], index: int = 0) -> int:
+    """Execute a quick command configured in the project."""
+    project_path = Path(project_dir)
+    commands = config.get("quickrun", {}).get("commands", [])
+    if not commands:
+        print("No quickrun commands are configured for this space.")
+        return 1
+    if index < 0 or index >= len(commands):
+        print(f"Quick-run index {index} out of range for {len(commands)} commands.")
+        return 1
+
+    cmd = commands[index]
+    print(f"Running: {cmd}")
+    completed = subprocess.run(
+        cmd,
+        shell=True,
+        cwd=str(project_path),
+        env=_district_env(project_path, config),
+        executable="/bin/bash",
+    )
+    return completed.returncode
+
+
+def status_ribbon(project_dir: str | Path, config: dict[str, Any]) -> None:
+    """Print a lightweight status ribbon that mimics a desktop panel."""
+    project_path = Path(project_dir)
+    ports = config.get("status", {}).get("ports", [])
+    port_status = []
+    for port in ports:
+        port_status.append(f"{port}: {'open' if _port_is_open(port) else 'down'}")
+    print(f"Project: {config.get('project', {}).get('name', project_path.name)}")
+    print("Active context: ready")
+    print(f"Ports: {', '.join(port_status) if port_status else 'none configured'}")
+    print("Scratchpad: ready")
+
+
+def run_session_launch(project_dir: str | Path, config: dict[str, Any]) -> None:
+    """Run the configured launch commands in terminal sessions."""
+    project_path = Path(project_dir)
+    plan = launch_workspace(project_path, config)
+    for session in plan["sessions"]:
+        subprocess.Popen(
+            ["/bin/bash", "-lc", session["command"]],
+            cwd=session["cwd"],
+            env=session["env"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )

devspace-0.1.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: devspace
+Version: 0.1.0
+Summary: A clean workflow and context orchestrator for minimalist Linux setups.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# devspace
+
+Core Features to Build1. Context Orchestration (devspace load <project>)When you fire up a project workspace, the Python script reads a .devspace.toml file from your project root and uses wmctrl to:Spin up a designated number of terminal windows arranged exactly how you like them.Automatically activate your project’s specific Python venv in those terminals.Open your project's local documentation or API references in a lightweight X11 browser (like surf or luakit).Launch your background mock databases or docker containers.2. The Persistent "Status Ribbon" (The GUI Element)Instead of a huge dashboard, it generates a tiny, elegant, borderless X11 window using tkinter that docks right into your Fluxbox setup (acting like a secondary panel). It display blocks like:Active Project Context: How long you've been working on the current session.Local Micro-Status: Are your local development ports (e.g., localhost:8000) alive or throwing 500 errors?Scratchpad Dropdown: A clean, markdown-supported text box that drops down via a global hotkey to jot down notes without opening a heavy text editor.3. Ephemeral Quick-RunnerA search-bar style pop-up launcher (similar to Rofi, but built tailored to developers) that indexes only your project-specific actions. Pressing Ctrl + Space brings up a fast, modern input field where you can type project shortcuts (e.g., run tests, deploy staging, tail logs) defined entirely in your Python package config.How to Structure and Build ItSince you are running inside a venv on a minimal Debian installation, keep the library dependencies incredibly lean to preserve that lightning-fast Fluxbox feel.Recommended PyPI Stack:pyyaml or standard tomli (built-in for Python 3.11+ on Debian 12) — For reading configurations. [1] (/goto?url=CAESZgHrOzAVc1CuWOZEerWcsyLbIQ4xAc5OzLZy-x_xhIdkLz9lH-_iKIXDaiOu2dgKvFA_E4ieHUojoxzuFneBUUqoE6oz5a6EPSUOCjO1tHVovktc5q9Q40FFbkfB3ahORHpuT8VZrQ)Textual — If you decide to go the terminal UI route; it looks gorgeous, behaves like a modern GUI, but runs completely inside your terminal emulator.customtkinter — If you choose a GUI route; it upgrades standard Tkinter with gorgeous dark/light mode widgets without requiring heavy Qt or GTK packages.python-xlib or sh — For executing shell bindings safely to arrange window states.Example pyproject.toml layout:toml[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devspace"
+version = "0.1.0"
+description = "A clean workflow and context orchestrator for minimalist Linux setups."
+dependencies = [
+    "customtkinter>=5.2.0",
+    "sh>=2.0.0"
+]
+
+[project.scripts]
+devspace = "devspace.cli:main"
+Use code with caution.Why this will be ImpressiveIt moves away from standard fluff projects and directly solves a universal developer friction point: environment setup and switching fatigue. Showing off a tool that handles window management, local port monitoring, and isolated project execution on a clean, snappy Linux architecture demonstrates a strong grasp of OS-level automation, config parsing, and clean desktop architecture.

devspace-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+devspace/__init__.py,sha256=z64AcJqso1ZBwsdlLC6brIxqH7iiA6sX8tnoUWWvxNU,73
+devspace/cli.py,sha256=bQIisEA3iMkZsNSQdmQKfqPgYZcN7KAOIthwoLMHiDY,3231
+devspace/config.py,sha256=bteQgLP1v_TVKeoDeHM3Z7oo94rLFyHTxWs6oqiCdmA,2216
+devspace/orchestrator.py,sha256=W7fBX1b8BVSfBTA3oytOfxnycHOTlPYOx1B44pQRZ70,5725
+devspace-0.1.0.dist-info/METADATA,sha256=1ECHWmCMc8mBWS8B-ZTVibTzUvY5QCIT4gpoLJnMXf4,3321
+devspace-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+devspace-0.1.0.dist-info/entry_points.txt,sha256=6Dt6_HfPx68Ebb_GLYnQq4_vxsedhIGfFFfbQIr4oEg,47
+devspace-0.1.0.dist-info/top_level.txt,sha256=oBiP-5GGc9nTTqiWDai2U7caMg81SvF11-adGLYgwa0,9
+devspace-0.1.0.dist-info/RECORD,,

devspace-0.1.0.dist-info/WHEEL

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

devspace-0.1.0.dist-info/entry_points.txt

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

devspace-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devspace