hecaton 0.1.0__tar.gz

hecaton-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: hecaton
+Version: 0.1.0
+Summary: Hecaton distributed compute framework
+Author-email: Just1duc <aworld068@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: platformdirs
+Requires-Dist: typer
+Requires-Dist: prompt_toolkit
+Requires-Dist: click
+Requires-Dist: docker
+
+# hecaton
+A solution for self-hosted GPU access from a source that isn't deployed

hecaton-0.1.0/README.md

@@ -0,0 +1,2 @@
+# hecaton
+A solution for self-hosted GPU access from a source that isn't deployed

hecaton-0.1.0/hecaton/client/argparser.py

@@ -0,0 +1,17 @@
+import argparse
+
+parser = argparse.ArgumentParser(
+    prog="Hecaton Client",
+    description="A simple cli to use the Hecaton Server"
+)
+# The login is done in CLI
+# Saved in .cache/hecaton
+# The logout should also be available
+# The usage of a server is done in the cli
+
+# CLI
+# connect [SERVER]
+# new_job, new [filepath] -> job id
+# status_job, status [ID] -> (STATUS, results|None)
+# get_jobs, get -> Return all running jobs (from the server)
+# delete_job, del -> Put a job in failed and free a GPU

hecaton-0.1.0/hecaton/client/cli.py

@@ -0,0 +1,257 @@
+import shlex, typer, os
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import ANSI
+from hecaton.client.managers import ServerManager, ImageManager, JobManager, apps
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.completion import Completer, Completion
+from typer.main import get_command
+from typing import Iterable, List, Tuple, Optional
+import click
+import importlib
+
+app = typer.Typer()
+
+_original_echo = typer.echo
+
+def _indented_echo(message="", indent=4, **kwargs):
+    prefix = " " * indent
+    msg = "\n".join(prefix + line for line in str(message).splitlines())
+    _original_echo(msg, **kwargs)
+
+
+shared_context = {
+    "server_mgr"    : ServerManager(),
+    "job_mgr"       : JobManager(),
+    "image_mgr"     : ImageManager()
+}
+def _split_args(text: str):
+    try:
+        return click.parser.split_arg_string(text)
+    except Exception:
+        return text.split()
+
+def _resolve_chain(root_cmd, root_ctx, args):
+    cmd, ctx, rest = root_cmd, root_ctx, list(args)
+    # print("start rest", rest)
+    while isinstance(cmd, click.MultiCommand) and rest:
+        name, sub_cmd, rest2 = cmd.resolve_command(ctx, rest)
+        if not sub_cmd:
+            break
+        ctx = sub_cmd.make_context(
+            info_name=name,
+            args=rest2,
+            parent=ctx,
+            resilient_parsing=True,
+            obj=ctx.obj,
+        )
+        cmd, rest = sub_cmd, rest[1:]
+    # print("rest end", rest)
+    return cmd, ctx, rest
+
+def _match_option(token: str, options: List[click.Option]) -> Optional[click.Option]:
+    for opt in options:
+        if token in opt.opts or token in opt.secondary_opts:
+            return opt
+    return None
+
+def _consume_tokens_for_option(opt: click.Option, tokens: List[str], i: int) -> int:
+    
+    t = tokens[i]
+    
+    if "=" in t and t.startswith("-"):
+        return i + 1
+    
+    if opt.nargs == 0:
+        return i + 1
+    
+    return min(i + 1 + opt.nargs, len(tokens))
+
+def determine_active_param(
+    leaf_cmd: click.Command,
+    args_after_leaf: List[str],
+    completing_option_name: bool,
+) -> Tuple[str, Optional[click.Parameter], int]:
+    """
+    Returns (kind, param, pos_index)
+      kind ∈ {"option_name", "option_value", "positional", "none"}
+      param: the active click.Option or click.Argument (or None)
+      pos_index: index of active positional (or -1)
+    """
+    params = leaf_cmd.params
+    opt_params = [p for p in params if isinstance(p, click.Option)]
+    pos_params = [p for p in params if isinstance(p, click.Argument)]
+
+    if completing_option_name:
+        return ("option_name", None, -1)
+
+    i = 0
+    pos_i = 0
+    while i < len(args_after_leaf):
+        tok = args_after_leaf[i]
+        # Option with attached value: --opt=value → treat as fully consumed
+        if tok.startswith("--") and "=" in tok:
+            i += 1
+            continue
+        # Option name?
+        opt = _match_option(tok, opt_params) if tok.startswith("-") else None
+        if opt is not None:
+            i = _consume_tokens_for_option(opt, args_after_leaf, i)
+            continue
+        # Otherwise this token belongs to current positional
+        if pos_i < len(pos_params):
+            arg = pos_params[pos_i]
+            # default nargs is 1; Typer uses 1 unless you set it
+            nargs = getattr(arg, "nargs", 1)
+            if nargs in (1, None):
+                pos_i += 1
+                i += 1
+            elif nargs == -1:  # variadic: all remaining go here
+                # Since we’re *before* the incomplete token, all remaining are consumed
+                # and we remain on this positional
+                i = len(args_after_leaf)
+            else:  # fixed >1
+                # consume up to nargs tokens into this positional
+                take = min(nargs, len(args_after_leaf) - i)
+                pos_i += 1
+                i += take
+        else:
+            # extra tokens; move on
+            i += 1
+
+    if args_after_leaf:
+        last = args_after_leaf[-1]
+        last_opt = _match_option(last, opt_params)
+        if last_opt is not None and last_opt.nargs != 0:
+            return ("option_value", last_opt, -1)
+
+    if pos_i < len(pos_params):
+        return ("positional", pos_params[pos_i], pos_i)
+
+    return ("none", None, -1)
+
+class TyperCompleter(Completer):
+    def __init__(self, typer_app, make_root_ctx):
+        self.root_cmd = get_command(typer_app)
+        self.make_root_ctx = make_root_ctx
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        args = _split_args(text)
+        incomplete = "" if text.endswith((" ", "\t")) else (args.pop() if args else "")
+        # print(args)
+
+        root_ctx = self.make_root_ctx()
+        leaf_cmd, leaf_ctx, rest = _resolve_chain(self.root_cmd, root_ctx, args)
+
+        args_after_leaf = rest
+        # IMPORTANT: call on the LEAF command with (ctx, incomplete)
+        # print("Command name", leaf_cmd.name)
+        items = list(leaf_cmd.shell_complete(leaf_ctx, incomplete))
+
+        if not items:
+            # Decide what we’re completing
+            kind, param, pos_index = determine_active_param(
+                leaf_cmd,
+                args_after_leaf=args_after_leaf,
+                completing_option_name=incomplete.startswith("-"),
+            )
+
+            if kind == "option_name":
+                # suggest option switches
+                for p in (pp for pp in leaf_cmd.params if isinstance(pp, click.Option)):
+                    for sw in (*p.opts, *p.secondary_opts):
+                        if sw.startswith(incomplete):
+                            items.append(click.shell_completion.CompletionItem(sw))
+
+            elif kind == "option_value" and param is not None:
+                # OPTION value completion → param or its type
+                if getattr(param, "shell_complete", None):
+                    items = list(param.shell_complete(leaf_ctx, incomplete))
+                elif getattr(param.type, "shell_complete", None):
+                    items = list(param.type.shell_complete(leaf_ctx, param, incomplete))
+
+            elif kind == "positional" and param is not None:
+                # POSITIONAL completion → param or its type
+                if getattr(param, "shell_complete", None):
+                    items = list(param.shell_complete(leaf_ctx, incomplete))
+                elif getattr(param.type, "shell_complete", None):
+                    items = list(param.type.shell_complete(leaf_ctx, param, incomplete))
+
+            # print("DBG", {
+            # "args_after_leaf": args_after_leaf,
+            # "kind": kind,
+            # "param": getattr(param, "name", None),
+            # "pos_index": pos_index,
+            # "incomplete": incomplete,
+            # })
+
+        # yield items
+        start = -len(incomplete)
+        for it in items:
+            yield Completion(it.value, start_position=start,
+                            display=it.value, display_meta=(it.help or ""))
+
+@app.callback()
+def main(ctx: typer.Context):
+    ctx.obj = shared_context
+
+app.add_typer(apps.job_app, name="job")
+app.add_typer(apps.image_app, name="image")
+app.add_typer(apps.server_app, name="server")
+
+@app.command("ls")
+def list_files():
+    print(*["    " + f for f in os.listdir(".")], sep="\n")
+    
+@app.command("cd")
+def change_dir(dir):
+    os.chdir(dir)
+
+@app.command("help")
+def greet():
+    with importlib.resources.open_text("hecaton", "../help.txt") as f:
+        typer.echo(f.read())
+
+@app.command()
+def unknown():
+    typer.echo(f"Unknown command")
+
+def run_shell():
+    logo = importlib.resources.open_text("hecaton", "../logo_hecaton.txt").read()
+    # logo = open("logo_hecaton.txt", encoding="utf-8").read()
+    typer.echo(logo)
+
+    root_click_cmd = get_command(app)
+    def make_root_ctx():
+        return root_click_cmd.make_context(
+            info_name="", args=[], resilient_parsing=True, obj=shared_context
+        )
+    completer = TyperCompleter(app, make_root_ctx)
+    
+    typer.echo = _indented_echo
+    session = PromptSession(
+        completer=completer,
+        complete_while_typing=True
+    )
+    while True:
+        try:
+            line = session.prompt(ANSI(f"    \x1b[36;1mhecaton\x1b[0m ({shared_context['server_mgr'].selected_server or 'Not connected'}) \x1b[35m›\x1b[0m "))
+        except (EOFError, KeyboardInterrupt):
+            break
+        if not line.strip(): 
+            continue
+        if line.strip() in {"quit", "exit"}:
+            break
+        try:
+            # Run Typer/Click without sys.exit()
+            app(standalone_mode=False, args=shlex.split(line))
+        except SystemExit:
+            pass
+        except Exception as e:
+            typer.echo(f"error: {e}")
+
+def main():
+    run_shell()
+
+if __name__ == "__main__":
+    main()

hecaton-0.1.0/hecaton/client/managers/__init__.py

@@ -0,0 +1,11 @@
+from hecaton.client.managers.image  import ImageManager, image_app
+from hecaton.client.managers.server import ServerManager, server_app
+from hecaton.client.managers.job    import JobManager, job_app
+
+class Apps:
+    
+    image_app = image_app
+    server_app = server_app
+    job_app = job_app
+    
+apps = Apps()

hecaton-0.1.0/hecaton/client/managers/api.py

@@ -0,0 +1,131 @@
+# File that contain the class that communicates with the hecaton's server
+import requests
+from typing import Optional, List, Tuple
+
+class HecatonServer:
+    
+    str_to_method = {
+        "GET" : requests.get,
+        "POST": requests.post,
+        "PUT" : requests.put,
+        "DELETE" : requests.delete
+    }
+    
+    def call_endpoint(
+        ip : str,
+        secret : str,
+        method : str,
+        endpoint : str,
+        payload : dict | None = None
+    ):
+        ip = ip if ip.startswith('http') else f'http://{ip}'
+        result = HecatonServer.str_to_method[method](f"{ip}{endpoint}",
+            headers = { "Authorization" : secret },
+            **({"json" : payload} if method != "GET" else {})
+        )
+        return result
+    
+    def list_jobs(
+        ip : str,
+        secret : str
+    ):
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="GET",
+            endpoint="/jobs"
+        )
+        if results.ok:
+            return results.json()
+        return results.json()["detail"]
+    
+    def list_images(
+        ip : str,
+        secret : str
+    ):
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="GET",
+            endpoint="/images"
+        )
+        if results.ok:
+            return results.json()
+        return results.json()["detail"]
+
+    def new_job(
+        ip : str,
+        secret : str,
+        file_path : str,
+        image : str
+    ):
+        file_content = open(file_path, "r").read()
+        
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="POST",
+            endpoint="/jobs/new",
+            payload={
+                "payload" : file_content,
+                "image" : image
+            }
+        )
+        if results.ok:
+            return results.json()["job_id"]
+        return results.json()["detail"]
+    
+    def update_image(
+        ip,
+        secret,
+        image : str,
+        env : List[Tuple[str, str]] | None = None,
+        description : Optional[str] = None
+    ):
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="POST",
+            endpoint="/images/update",
+            payload={
+                "image_name" : image,
+                **({"env" : [{"key" : var[0], "value" : var[1]} for var in env]} if env else {}),
+                **({"description" : description} if description else {}) 
+            }
+        )
+        if results.ok:
+            return results.json()["message"]
+        return results.json()["detail"]
+            
+    def new_image(
+        ip : str,
+        secret : str,
+        image : str
+    ):
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="POST",
+            endpoint="/images/new",
+            payload={
+                "image_name" : image,
+            }
+        )
+        if results.ok:
+            return results.json()["message"]
+        return results.json()["detail"]
+
+    def get_job(
+        ip : str,
+        secret : str,
+        jid : str
+    ):
+        results = HecatonServer.call_endpoint(
+            ip=ip,
+            secret=secret,
+            method="GET",
+            endpoint=f"/jobs/{jid}"
+        )
+        if results.ok:
+            return results.json()
+        return results.json()["detail"]

hecaton-0.1.0/hecaton/client/managers/db.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+
+from typing import List
+from pathlib import Path
+from datetime import datetime
+from filelock import FileLock
+from contextlib import contextmanager
+from platformdirs import user_data_path
+from pydantic import BaseModel, EmailStr, Field
+
+SCHEMA_VERSION = 1
+
+class ServerInfo(BaseModel):
+    ip: str
+    name: str
+    secret: str
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+class Database(BaseModel):
+    version: int = SCHEMA_VERSION
+    servers: List[ServerInfo] = Field(default_factory=list)
+
+APP_NAME = "hecaton"
+APP_AUTHOR = "Just1truc"
+
+def data_dir() -> Path:
+    d = user_data_path(appname=APP_NAME, appauthor=APP_AUTHOR, roaming=False)
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+def db_path() -> Path:
+    return data_dir() / "db.json"
+
+def lock_path() -> Path:
+    return data_dir() / "db.lock"
+
+def load_db() -> Database:
+    p = db_path()
+    if not p.exists():
+        return Database()
+    raw = json.loads(p.read_text(encoding="utf-8"))
+    return Database.model_validate(raw)
+
+def _atomic_write(path: Path, data: str) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(data, encoding="utf-8")
+    tmp.replace(path)
+
+def save_db(db: Database) -> None:
+    text = db.model_dump_json(indent=2, by_alias=True)
+    _atomic_write(db_path(), text)
+
+@contextmanager
+def with_locked_db(mutate: bool = False):
+    """Read DB under a lock; optionally write back on exit if mutate=True."""
+    lock = FileLock(str(lock_path()))
+    with lock:
+        db = load_db()
+        yield db
+        if mutate:
+            save_db(db)

hecaton-0.1.0/hecaton/client/managers/image.py

@@ -0,0 +1,129 @@
+import typer
+import os
+import click
+from typing import Optional, List, Tuple
+from hecaton.client.managers.api import HecatonServer
+from hecaton.client.managers.server import ServerManager, ServerInfo
+
+image_app = typer.Typer()
+
+class ImageManager:
+    
+    def list_images(
+        self,
+        ip,
+        secret
+    ):
+        return HecatonServer.list_images(ip, secret)
+    
+    def new_image(
+        self,
+        ip,
+        secret,
+        image
+    ):
+        return HecatonServer.new_image(ip, secret, image)
+    
+    def update_image(
+        self,
+        ip,
+        secret,
+        image : str,
+        env : List[Tuple[str, str]] | None = None,
+        description : Optional[str] = None
+    ):
+        return HecatonServer.update_image(ip, secret, image, env, description)
+        
+    
+@image_app.command("list")
+def list_image(
+    ctx : typer.Context
+):
+    mgr : ImageManager = ctx.obj["image_mgr"]
+    server_mgr : ServerManager = ctx.obj["server_mgr"]
+    server_info : ServerInfo = server_mgr.connected_server()
+    
+    images = mgr.list_images(server_info.ip, server_info.secret)
+    for image in images:
+        typer.echo(image[1])
+    
+@image_app.command("new")
+def new_image(
+    ctx : typer.Context,
+    image : str
+):
+    mgr : ImageManager = ctx.obj["image_mgr"]
+    server_mgr : ServerManager = ctx.obj["server_mgr"]
+    server_info : ServerInfo = server_mgr.connected_server()
+    
+    typer.echo(mgr.new_image(server_info.ip, server_info.secret, image))
+
+
+def complete_image_name(ctx : typer.Context, param: click.Parameter, incomplete : str) -> List[str]:
+    
+    mgr : ImageManager = ctx.obj["image_mgr"]
+    server_mgr : ServerManager = ctx.obj["server_mgr"]
+    server_info : ServerInfo = server_mgr.connected_server()
+    
+    images = mgr.list_images(server_info.ip, server_info.secret)
+    return [image[1] for image in images if image[1].startswith(incomplete)]
+
+def prompt_optional(label: str, *, hide: bool = False):
+    def _cb(ctx: click.Context, param: click.Parameter, value: Optional[str]):
+        # Don't prompt during shell completion / help rendering
+        if ctx.resilient_parsing:
+            return value
+        if value is not None:
+            return value
+        # Prompt once; empty -> None
+        ans = typer.prompt(label, default="", show_default=False, hide_input=hide)
+        return ans if ans.strip() else None
+    return _cb
+
+@image_app.command("update")
+def update_image(
+    ctx : typer.Context,
+    image : str = typer.Argument(..., shell_complete=complete_image_name),
+    env_file_path : Optional[str] = typer.Option(
+        None,
+        "--fp",
+        callback=prompt_optional("    New_env_path (Press Enter to keep current variables)"),
+        help="Env Path",
+        show_default=False,
+    ),
+    description : Optional[str] = typer.Option(
+        None,
+        "--desc",
+        callback=prompt_optional("    Description (Press Enter to keep current value)"),
+        help="Description",
+        show_default=False,
+    )
+):
+    mgr : ImageManager = ctx.obj["image_mgr"]
+    server_mgr : ServerManager = ctx.obj["server_mgr"]
+    server_info : ServerInfo = server_mgr.connected_server()
+    
+    env = None
+    if env_file_path and not os.path.isfile(env_file_path):
+        typer.echo(f"error: Invalid filepath {env_file_path}")
+        return
+    elif os.path.isfile(env_file_path):
+        env = [line.split("=") for line in open(env_file_path, "r").read().split() if "=" in line]
+    
+    typer.echo(mgr.update_image(server_info.ip, server_info.secret, image, env, description))
+
+@image_app.command("show")
+def image_info(
+    ctx : typer.Context,
+    image : str = typer.Argument(..., shell_complete=complete_image_name)
+):
+    mgr : ImageManager = ctx.obj["image_mgr"]
+    server_mgr : ServerManager = ctx.obj["server_mgr"]
+    server_info : ServerInfo = server_mgr.connected_server()
+    
+    images = mgr.list_images(server_info.ip, server_info.secret)
+    for im in images:
+        if im[1] == image:
+            typer.echo(f'name: \t\t {im[1]}')
+            typer.echo(f'description: \t\t {im[2] or "No Description yet..."}')
+            typer.echo(f'env: \t\t {im[3]}')