fxn 0.0.42__py3-none-any.whl → 0.0.43__py3-none-any.whl

fxn/__init__.py

@@ -4,7 +4,8 @@
 #
 
 from .client import FunctionAPIError
-from .compile import *
+from .compile import compile
 from .function import Function
+from .sandbox import Sandbox
 from .types import *
 from .version import *

fxn/cli/__init__.py

@@ -6,10 +6,10 @@
 from typer import Typer
 
 from .auth import app as auth_app
-#from .compile import compile_predictor
+from .compile import compile_predictor
 from .misc import cli_options
 from .predictions import create_prediction
-from .predictors import retrieve_predictor
+from .predictors import archive_predictor, delete_predictor, retrieve_predictor
 from ..version import __version__
 
 # Define CLI
@@ -33,11 +33,13 @@ app.command(
     help="Make a prediction.",
     context_settings={ "allow_extra_args": True, "ignore_unknown_options": True }
 )(create_prediction)
-# app.command(
-#     name="compile",
-#     help="Create a predictor by compiling a Python function."
-# )(compile_predictor)
+app.command(
+    name="compile",
+    help="Create a predictor by compiling a Python function."
+)(compile_predictor)
 app.command(name="retrieve", help="Retrieve a predictor.")(retrieve_predictor)
+app.command(name="archive", help="Archive a predictor.")(archive_predictor)
+app.command(name="delete", help="Delete a predictor.")(delete_predictor)
 
 # Run
 if __name__ == "__main__":

fxn/cli/compile.py

@@ -0,0 +1,141 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from asyncio import run as run_async
+from importlib.util import module_from_spec, spec_from_file_location
+from inspect import getmembers, getmodulename, isfunction
+from pathlib import Path
+from pydantic import BaseModel
+from re import sub
+from rich import print as print_rich
+from rich.progress import SpinnerColumn, TextColumn
+import sys
+from typer import Argument, Option
+from typing import Callable, Literal
+from urllib.parse import urlparse, urlunparse
+
+from ..compile import PredictorSpec
+from ..function import Function
+from ..sandbox import EntrypointCommand
+from ..logging import CustomProgress, CustomProgressTask
+from .auth import get_access_key
+
+def compile_predictor (
+    path: str=Argument(..., help="Predictor path.")
+):
+    run_async(_compile_predictor_async(path))
+
+async def _compile_predictor_async (path: str):
+    fxn = Function(get_access_key())
+    path: Path = Path(path).resolve()
+    with CustomProgress(
+        SpinnerColumn(spinner_name="dots", finished_text="[bold green]✔[/bold green]"),
+        TextColumn("[progress.description]{task.description}"),
+    ):
+        # Load
+        with CustomProgressTask(loading_text="Loading predictor...") as task:
+            func = _load_predictor_func(path)
+            entrypoint = EntrypointCommand(from_path=str(path), to_path="./", name=func.__name__)
+            spec: PredictorSpec = func.__predictor_spec
+            task.finish(f"Loaded prediction function: [bold cyan]{spec.tag}[/bold cyan]")
+        # Populate
+        sandbox = spec.sandbox
+        sandbox.commands.append(entrypoint)
+        with CustomProgressTask(loading_text="Uploading sandbox...", done_text="Uploaded sandbox"):
+            sandbox.populate(fxn=fxn)
+        # Compile
+        with CustomProgressTask(loading_text="Running codegen...", done_text="Completed codegen"):
+            with CustomProgressTask(loading_text="Creating predictor..."):
+                predictor = fxn.client.request(
+                    method="POST",
+                    path="/predictors",
+                    body=spec.model_dump(mode="json"),
+                    response_type=_Predictor
+                )
+            with ProgressLogQueue() as task_queue:
+                async for event in fxn.client.stream(
+                    method="POST",
+                    path=f"/predictors/{predictor.tag}/compile",
+                    body={ },
+                    response_type=_LogEvent | _ErrorEvent
+                ):
+                    if isinstance(event, _LogEvent):
+                        task_queue.push_log(event)
+                    elif isinstance(event, _ErrorEvent):
+                        task_queue.push_error(event)
+                        raise RuntimeError(event.data.error)
+    predictor_url = _compute_predictor_url(fxn.client.api_url, spec.tag)
+    print_rich(f"\n[bold spring_green3]🎉 Predictor is now being compiled.[/bold spring_green3] Check it out at {predictor_url}")
+
+def _load_predictor_func (path: str) -> Callable[...,object]:
+    if "" not in sys.path:
+        sys.path.insert(0, "")
+    path: Path = Path(path).resolve()
+    sys.path.insert(0, str(path.parent))
+    name = getmodulename(path)
+    spec = spec_from_file_location(name, path)
+    module = module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    main_func = next(func for _, func in getmembers(module, isfunction) if hasattr(func, "__predictor_spec"))
+    return main_func
+
+def _compute_predictor_url (api_url: str, tag: str) -> str:
+    parsed_url = urlparse(api_url)
+    hostname_parts = parsed_url.hostname.split(".")
+    if hostname_parts[0] == "api":
+        hostname_parts.pop(0)
+    hostname = ".".join(hostname_parts)
+    netloc = hostname if not parsed_url.port else f"{hostname}:{parsed_url.port}"
+    predictor_url = urlunparse(parsed_url._replace(netloc=netloc, path=f"{tag}"))
+    return predictor_url
+
+class _Predictor (BaseModel):
+    tag: str
+
+class _LogData (BaseModel):
+    message: str
+    level: int = 0
+
+class _LogEvent (BaseModel):
+    event: Literal["log"]
+    data: _LogData
+
+class _ErrorData (BaseModel):
+    error: str
+
+class _ErrorEvent (BaseModel):
+    event: Literal["error"]
+    data: _ErrorData
+
+class ProgressLogQueue:
+
+    def __init__ (self):
+        self.queue: list[tuple[int, CustomProgressTask]] = []
+
+    def push_log (self, event: _LogEvent):
+        while self.queue:
+            current_level, current_task = self.queue[-1]
+            if event.data.level > current_level:
+                break
+            current_task.__exit__(None, None, None)
+            self.queue.pop()
+        message = sub(r"`([^`]+)`", r"[hot_pink italic]\1[/hot_pink italic]", event.data.message)
+        task = CustomProgressTask(loading_text=message)
+        task.__enter__()
+        self.queue.append((event.data.level, task))
+
+    def push_error (self, error: _ErrorEvent):
+        while self.queue:
+            _, current_task = self.queue.pop()
+            current_task.__exit__(RuntimeError, None, None)
+
+    def __enter__ (self):
+        return self
+    
+    def __exit__ (self, exc_type, exc_value, traceback):
+        while self.queue:
+            _, current_task = self.queue.pop()
+            current_task.__exit__(None, None, None)

fxn/cli/predictions.py

@@ -9,11 +9,11 @@ from numpy import array_repr, ndarray
 from pathlib import Path, PurePath
 from PIL import Image
 from rich import print_json
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from tempfile import mkstemp
 from typer import Argument, Context, Option
 
 from ..function import Function
+from ..logging import CustomProgress, CustomProgressTask
 from ..types import Prediction
 from .auth import get_access_key
 
@@ -26,18 +26,21 @@ def create_prediction (
 
 async def _predict_async (tag: str, quiet: bool, context: Context):
     # Preload
-    fxn = Function(get_access_key())
-    fxn.predictions.create(tag, inputs={ }, verbose=not quiet)
-    # Predict
-    with Progress(
-        SpinnerColumn(spinner_name="dots"),
-        TextColumn("[progress.description]{task.description}"),
-        transient=True
-    ) as progress:
-        progress.add_task(description="Running Function...", total=None)
-        inputs = { context.args[i].replace("-", ""): _parse_value(context.args[i+1]) for i in range(0, len(context.args), 2) }
-        prediction = fxn.predictions.create(tag, inputs=inputs)
-        _log_prediction(prediction)
+    with CustomProgress(transient=True, disable=quiet):
+        fxn = Function(get_access_key())
+        with CustomProgressTask(
+            loading_text="Preloading predictor...",
+            done_text="Preloaded predictor"
+        ):
+            fxn.predictions.create(tag, inputs={ })
+        with CustomProgressTask(loading_text="Making prediction..."):
+            inputs = { }
+            for i in range(0, len(context.args), 2):
+                name = context.args[i].replace("-", "")
+                value = _parse_value(context.args[i+1])
+                inputs[name] = value
+            prediction = fxn.predictions.create(tag, inputs=inputs)
+    _log_prediction(prediction)
 
 def _parse_value (value: str):
     """

fxn/cli/predictors.py

@@ -7,12 +7,43 @@ from rich import print_json
 from typer import Argument
 
 from ..function import Function
+from ..logging import CustomProgress, CustomProgressTask
 from .auth import get_access_key
 
 def retrieve_predictor (
     tag: str=Argument(..., help="Predictor tag.")
 ):
-    fxn = Function(get_access_key())
-    predictor = fxn.predictors.retrieve(tag)
-    predictor = predictor.model_dump() if predictor else None
-    print_json(data=predictor)
+    with CustomProgress(transient=True):
+        with CustomProgressTask(loading_text="Retrieving predictor..."):
+            fxn = Function(get_access_key())
+            predictor = fxn.predictors.retrieve(tag)
+            predictor = predictor.model_dump() if predictor else None
+            print_json(data=predictor)
+
+def archive_predictor (
+    tag: str=Argument(..., help="Predictor tag.")
+):
+    with CustomProgress():
+        with CustomProgressTask(
+            loading_text="Archiving predictor...",
+            done_text=f"Archived predictor: [bold dark_orange]{tag}[/bold dark_orange]"
+        ):
+            fxn = Function(get_access_key())
+            fxn.client.request(
+                method="POST",
+                path=f"/predictors/{tag}/archive"
+            )
+
+def delete_predictor (
+    tag: str=Argument(..., help="Predictor tag.")
+):
+    with CustomProgress():
+        with CustomProgressTask(
+            loading_text="Deleting predictor...",
+            done_text=f"Deleted predictor: [bold red]{tag}[/bold red]"
+        ):
+            fxn = Function(get_access_key())
+            fxn.client.request(
+                method="DELETE",
+                path=f"/predictors/{tag}"
+            )

fxn/client.py

@@ -4,9 +4,9 @@
 #
 
 from json import loads, JSONDecodeError
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 from requests import request
-from typing import Any, Literal, Type, TypeVar
+from typing import AsyncGenerator, Literal, Type, TypeVar
 
 T = TypeVar("T", bound=BaseModel)
 
@@ -19,11 +19,20 @@ class FunctionClient:
     def request (
         self,
         *,
-        method: Literal["GET", "POST", "DELETE"],
+        method: Literal["GET", "POST", "PATCH", "DELETE"],
         path: str,
-        body: dict[str, Any]=None,
+        body: dict[str, object]=None,
         response_type: Type[T]=None
     ) -> T:
+        """
+        Make a request to a REST endpoint.
+
+        Parameters:
+            method (str): Request method.
+            path (str): Endpoint path.
+            body (dict): Request JSON body.
+            response_type (Type): Response type.
+        """
         response = request(
             method=method,
             url=f"{self.api_url}{path}",
@@ -40,6 +49,53 @@ class FunctionClient:
         else:
             error = _ErrorResponse(**data).errors[0].message if isinstance(data, dict) else data
             raise FunctionAPIError(error, response.status_code)
+        
+    async def stream (
+        self,
+        *,
+        method: Literal["GET", "POST", "PATCH", "DELETE"],
+        path: str,
+        body: dict[str, object]=None,
+        response_type: Type[T]=None
+    ) -> AsyncGenerator[T, None]:
+        """
+        Make a request to a REST endpoint and consume the response as a server-sent events stream.
+
+        Parameters:
+            method (str): Request method.
+            path (str): Endpoint path.
+            body (dict): Request JSON body.
+            response_type (Type): Response type.
+        """
+        response = request(
+            method=method,
+            url=f"{self.api_url}{path}",
+            json=body,
+            headers={
+                "Accept": "text/event-stream",
+                "Authorization": f"Bearer {self.access_key}"
+            },
+            stream=True
+        )
+        event = None
+        data: str = ""
+        for line in response.iter_lines(decode_unicode=True):
+            if line is None:
+                break
+            line: str = line.strip()
+            if line:
+                if line.startswith("event:"):
+                    event = line[len("event:"):].strip()
+                elif line.startswith("data:"):
+                    line_data = line[len("data:"):].strip()
+                    data = f"{data}\n{line_data}"
+                continue
+            if event is not None:
+                yield _parse_sse_event(event, data, response_type)
+            event = None
+            data = ""
+        if event or data:
+            yield _parse_sse_event(event, data, response_type)
 
 class FunctionAPIError (Exception):
 
@@ -55,4 +111,9 @@ class _APIError (BaseModel):
     message: str
 
 class _ErrorResponse (BaseModel):
-    errors: list[_APIError]
+    errors: list[_APIError]
+
+def _parse_sse_event (event: str, data: str, type: Type[T]=None) -> T:
+    result = { "event": event, "data": loads(data) }
+    result = TypeAdapter(type).validate_python(result) if type is not None else result
+    return result

fxn/{compile/compile.py → compile.py}

@@ -5,12 +5,12 @@
 
 from collections.abc import Callable
 from functools import wraps
+from inspect import isasyncgenfunction, iscoroutinefunction
 from pathlib import Path
 from pydantic import BaseModel, Field
 
-from ..types import AccessMode, Signature
 from .sandbox import Sandbox
-from .signature import get_function_type, infer_function_signature, FunctionType
+from .types import AccessMode
 
 class PredictorSpec (BaseModel):
     """
@@ -20,7 +20,6 @@ class PredictorSpec (BaseModel):
     description: str = Field(description="Predictor description. MUST be less than 100 characters long.", min_length=4, max_length=100)
     sandbox: Sandbox = Field(description="Sandbox to compile the function.")
     access: AccessMode = Field(description="Predictor access.")
-    signature: Signature = Field(description="Predictor signature.")
     card: str | None = Field(default=None, description="Predictor card (markdown).")
     media: str | None = Field(default=None, description="Predictor media URL.")
     license: str | None = Field(default=None, description="Predictor license URL. This is required for public predictors.")
@@ -51,11 +50,9 @@ def compile (
         # Check type
         if not callable(func):
             raise TypeError("Cannot compile non-function objects")
-        func_type = get_function_type(func)
-        if func_type not in { FunctionType.Function, FunctionType.Generator }:
-            raise TypeError(f"Function '{func.__name__}' must be a regular function or generator")
+        if isasyncgenfunction(func) or iscoroutinefunction(func):
+            raise TypeError(f"Function '{func.__name__}' must be a regular function or generator")            
         # Gather metadata
-        signature = infer_function_signature(func) # throws
         if isinstance(card, Path):
             with open(card_content, "r") as f:
                 card_content = f.read()
@@ -66,7 +63,6 @@ def compile (
             description=description,
             sandbox=sandbox if sandbox is not None else Sandbox(),
             access=access,
-            signature=signature,
             card=card_content,
             media=None, # INCOMPLETE
             license=license

fxn/logging.py

@@ -0,0 +1,137 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from contextvars import ContextVar
+from rich.progress import BarColumn, Progress, ProgressColumn, SpinnerColumn, TextColumn
+from typing import Literal
+
+current_progress = ContextVar("current_progress", default=None)
+progress_task_stack = ContextVar("progress_task_stack", default=[])
+
+class CustomProgress(Progress):
+
+    def __init__ (
+        self,
+        *columns: ProgressColumn,
+        console=None,
+        auto_refresh=True,
+        refresh_per_second = 10,
+        speed_estimate_period=30,
+        transient=False,
+        redirect_stdout=True,
+        redirect_stderr=True,
+        get_time=None,
+        disable=False,
+        expand=False
+    ):
+        default_columns = list(columns) if len(columns) > 0 else [
+            SpinnerColumn(spinner_name="dots", finished_text="[bold green]✔[/bold green]"),
+            TextColumn("[progress.description]{task.description}"),
+        ]
+        super().__init__(
+            *default_columns,
+            console=console,
+            auto_refresh=auto_refresh,
+            refresh_per_second=refresh_per_second,
+            speed_estimate_period=speed_estimate_period,
+            transient=transient,
+            redirect_stdout=redirect_stdout,
+            redirect_stderr=redirect_stderr,
+            get_time=get_time,
+            disable=disable,
+            expand=expand
+        )
+        self.default_columns = default_columns
+
+    def __enter__ (self):
+        self._token = current_progress.set(self)
+        self._stack_token = progress_task_stack.set([])
+        return super().__enter__()
+
+    def __exit__ (self, exc_type, exc_val, exc_tb):
+        current_progress.reset(self._token)
+        progress_task_stack.reset(self._stack_token)
+        return super().__exit__(exc_type, exc_val, exc_tb)
+    
+    def get_renderables (self):
+        for task in self.tasks:
+            task_columns = task.fields.get("columns") or list()
+            self.columns = self.default_columns + task_columns
+            yield self.make_tasks_table([task])
+
+class CustomProgressTask:
+
+    def __init__ (
+        self,
+        *,
+        loading_text: str,
+        done_text: str=None,
+        columns: list[ProgressColumn]=None
+    ):
+        self.loading_text = loading_text
+        self.done_text = done_text if done_text is not None else loading_text
+        self.task_id = None
+        self.columns = columns
+
+    def __enter__ (self):
+        progress = current_progress.get()
+        indent_level = len(progress_task_stack.get())
+        indent = self.__get_indent(indent_level)
+        if progress is not None:
+            self.task_id = progress.add_task(
+                f"{indent}{self.loading_text}",
+                total=1,
+                columns=self.columns
+            )
+            current_stack = progress_task_stack.get()
+            progress_task_stack.set(current_stack + [self.task_id])
+        return self
+
+    def __exit__ (self, exc_type, exc_val, exc_tb):
+        progress = current_progress.get()
+        if progress is not None and self.task_id is not None:
+            indent_level = len(progress_task_stack.get()) - 1
+            indent = self.__get_indent(indent_level)
+            if exc_type is None:
+                total = progress._tasks[self.task_id].total
+                progress.update(
+                    self.task_id,
+                    description=f"{indent}{self.done_text}",
+                    completed=total
+                )
+            else:
+                progress.update(
+                    self.task_id,
+                    description=f"{indent}[bright_red]✘ {self.loading_text}[/bright_red]",
+                )
+            current_stack = progress_task_stack.get()
+            if current_stack:
+                progress_task_stack.set(current_stack[:-1])
+        self.task_id = None
+        return False
+
+    def update (self, **kwargs):
+        progress = current_progress.get()
+        if progress is None or self.task_id is None:
+            return
+        if "description" in kwargs:
+            stack = progress_task_stack.get()
+            try:
+                index = stack.index(self.task_id)
+            except ValueError:
+                index = len(stack) - 1
+            indent = self.__get_indent(index)
+            description = kwargs["description"]
+            kwargs["description"] = f"{indent}{description}"
+        progress.update(self.task_id, **kwargs)
+
+    def finish (self, message: str):
+        self.done_text = message
+
+    def __get_indent (self, level: int) -> str:
+        if level == 0:
+            return ""
+        indicator = "└── "
+        return " " * len(indicator) * (level - 1) + indicator

fxn/{compile/sandbox.py → sandbox.py}

@@ -4,13 +4,16 @@
 #
 
 from __future__ import annotations
+from abc import ABC, abstractmethod
 from hashlib import sha256
 from pathlib import Path
 from pydantic import BaseModel
 from requests import put
+from rich.progress import BarColumn, TextColumn
 from typing import Literal
 
-from ..function import Function
+from .function import Function
+from .logging import CustomProgressTask
 
 class WorkdirCommand (BaseModel):
     kind: Literal["workdir"] = "workdir"
@@ -20,17 +23,35 @@ class EnvCommand (BaseModel):
     kind: Literal["env"] = "env"
     env: dict[str, str]
 
-class UploadFileCommand (BaseModel):
-    kind: Literal["upload_file"] = "upload_file"
+class UploadableCommand (BaseModel, ABC):
     from_path: str
     to_path: str
     manifest: dict[str, str] | None = None
 
-class UploadDirectoryCommand (BaseModel):
+    @abstractmethod
+    def get_files (self) -> list[Path]:
+        pass
+
+class UploadFileCommand (UploadableCommand):
+    kind: Literal["upload_file"] = "upload_file"
+    
+    def get_files (self) -> list[Path]:
+        return [Path(self.from_path).resolve()]
+
+class UploadDirectoryCommand (UploadableCommand):
     kind: Literal["upload_dir"] = "upload_dir"
-    from_path: str
-    to_path: str
-    manifest: dict[str, str] | None = None
+
+    def get_files (self) -> list[Path]:
+        from_path = Path(self.from_path)
+        assert from_path.is_absolute(), "Cannot upload directory because directory path must be absolute"
+        return [file for file in from_path.rglob("*") if file.is_file()]
+    
+class EntrypointCommand (UploadableCommand):
+    kind: Literal["entrypoint"] = "entrypoint"
+    name: str
+
+    def get_files (self) -> list[Path]:
+        return [Path(self.from_path).resolve()]
 
 class PipInstallCommand (BaseModel):
     kind: Literal["pip_install"] = "pip_install"
@@ -40,10 +61,6 @@ class AptInstallCommand (BaseModel):
     kind: Literal["apt_install"] = "apt_install"
     packages: list[str]
 
-class EntrypointCommand (BaseModel):
-    kind: Literal["entrypoint"] = "entrypoint"
-    path: str
-
 Command = (
     WorkdirCommand          |
     EnvCommand              |
@@ -68,16 +85,14 @@ class Sandbox (BaseModel):
             path (str | Path): Path to change to.
         """
         command = WorkdirCommand(path=str(path))
-        self.commands.append(command)
-        return self
+        return Sandbox(commands=self.commands + [command])
 
     def env (self, **env: str) -> Sandbox:
         """
         Set environment variables in the sandbox.
         """
         command = EnvCommand(env=env)
-        self.commands.append(command)
-        return self
+        return Sandbox(commands=self.commands + [command])
 
     def upload_file (
         self,
@@ -92,8 +107,7 @@ class Sandbox (BaseModel):
             to_path (str | Path): Remote path to upload file to.
         """
         command = UploadFileCommand(from_path=str(from_path), to_path=str(to_path))
-        self.commands.append(command)
-        return self
+        return Sandbox(commands=self.commands + [command])
 
     def upload_directory (
         self,
@@ -108,8 +122,7 @@ class Sandbox (BaseModel):
             to_path (str | Path): Remote path to upload directory to.
         """
         command = UploadDirectoryCommand(from_path=str(from_path), to_path=str(to_path))
-        self.commands.append(command)
-        return self
+        return Sandbox(commands=self.commands + [command])
 
     def pip_install (self, *packages: str) -> Sandbox:
         """
@@ -119,8 +132,7 @@ class Sandbox (BaseModel):
             packages (list): Packages to install.
         """
         command = PipInstallCommand(packages=packages)
-        self.commands.append(command)
-        return self
+        return Sandbox(commands=self.commands + [command])
 
     def apt_install (self, *packages: str) -> Sandbox:
         """
@@ -130,24 +142,41 @@ class Sandbox (BaseModel):
             packages (list): Packages to install.
         """
         command = AptInstallCommand(packages=packages)
-        self.commands.append(command)
-        return self
-    
-    def populate (self, fxn: Function=None) -> Sandbox:
+        return Sandbox(commands=self.commands + [command])
+
+    def populate (self, fxn: Function=None) -> Sandbox: # CHECK # In place
         """
         Populate all metadata.
         """
         fxn = fxn if fxn is not None else Function()
+        entrypoint = next(cmd for cmd in self.commands if isinstance(cmd, EntrypointCommand))
+        entry_path = Path(entrypoint.from_path).resolve()
         for command in self.commands:
-            if isinstance(command, UploadFileCommand):
-                from_path = Path(command.from_path)
-                to_path = Path(command.to_path)
-                command.manifest = { str(to_path / from_path.name): self.__upload_file(from_path, fxn=fxn) }
-            elif isinstance(command, UploadDirectoryCommand):
+            if isinstance(command, UploadableCommand):
+                cwd = Path.cwd()
                 from_path = Path(command.from_path)
                 to_path = Path(command.to_path)
-                files = [file for file in from_path.rglob("*") if file.is_file()]
-                command.manifest = { str(to_path / file.relative_to(from_path)): self.__upload_file(file, fxn=fxn) for file in files }
+                if not from_path.is_absolute():
+                    from_path = (entry_path / from_path).resolve()
+                    command.from_path = str(from_path)
+                files = command.get_files()
+                name = from_path.relative_to(cwd) if from_path.is_relative_to(cwd) else from_path.resolve()
+                with CustomProgressTask(
+                    loading_text=f"Uploading [light_slate_blue]{name}[/light_slate_blue]...",
+                    done_text=f"Uploaded [light_slate_blue]{name}[/light_slate_blue]",
+                    columns=[
+                        BarColumn(),
+                        TextColumn("{task.completed}/{task.total}")
+                    ]
+                ) as task:
+                    manifest = { }
+                    for idx, file in enumerate(files):
+                        rel_file_path = file.relative_to(from_path) if from_path.is_dir() else file.name
+                        dst_path = to_path / rel_file_path
+                        checksum = self.__upload_file(file, fxn=fxn)
+                        manifest[str(dst_path)] = checksum
+                        task.update(total=len(files), completed=idx+1)
+                    command.manifest = manifest
         return self
 
     def __upload_file (self, path: Path, fxn: Function) -> str:
@@ -172,6 +201,6 @@ class Sandbox (BaseModel):
             for chunk in iter(lambda: f.read(4096), b""):
                 hash.update(chunk)
         return hash.hexdigest()
-    
+
 class _Resource (BaseModel):
     url: str

fxn/services/prediction.py

@@ -11,13 +11,14 @@ from pathlib import Path
 from PIL import Image
 from pydantic import BaseModel
 from requests import get
-from rich.progress import Progress, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
-from tempfile import gettempdir
+from rich.progress import BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
+from tempfile import gettempdir, NamedTemporaryFile
 from typing import Any, AsyncIterator
 from urllib.parse import urlparse
 
 from ..c import Configuration, Predictor, Prediction as CPrediction, Value as CValue, ValueFlags, ValueMap
 from ..client import FunctionClient
+from ..logging import CustomProgressTask
 from ..types import Acceleration, Prediction, PredictionResource
 
 Value = ndarray | str | float | int | bool | list[Any] | dict[str, Any] | Image.Image | BytesIO | memoryview
@@ -50,8 +51,7 @@ class PredictionService:
         acceleration: Acceleration=Acceleration.Auto,
         device=None,
         client_id: str=None,
-        configuration_id: str=None,
-        verbose: bool=False
+        configuration_id: str=None
     ) -> Prediction:
         """
         Create a prediction.
@@ -62,7 +62,6 @@ class PredictionService:
             acceleration (Acceleration): Prediction acceleration.
             client_id (str): Function client identifier. Specify this to override the current client identifier.
             configuration_id (str): Configuration identifier. Specify this to override the current client configuration identifier.
-            verbose (bool): Enable verbose logging.
 
         Returns:
             Prediction: Created prediction.
@@ -78,8 +77,7 @@ class PredictionService:
             acceleration=acceleration,
             device=device,
             client_id=client_id,
-            configuration_id=configuration_id,
-            verbose=verbose
+            configuration_id=configuration_id
         )
         with (
             self.__to_value_map(inputs) as input_map,
@@ -145,8 +143,7 @@ class PredictionService:
         acceleration: Acceleration=Acceleration.Auto,
         device=None,
         client_id: str=None,
-        configuration_id: str=None,
-        verbose: bool=False
+        configuration_id: str=None
     ) -> Predictor:
         if tag in self.__cache:
             return self.__cache[tag]
@@ -155,20 +152,13 @@ class PredictionService:
             client_id=client_id,
             configuration_id=configuration_id
         )
-        with Configuration() as configuration, Progress(
-            TextColumn("[bold blue]{task.fields[filename]}"),
-            BarColumn(),
-            DownloadColumn(),
-            TransferSpeedColumn(),
-            TimeRemainingColumn(),
-            disable=not verbose
-        ) as progress:
+        with Configuration() as configuration:
             configuration.tag = prediction.tag
             configuration.token = prediction.configuration
             configuration.acceleration = acceleration
             configuration.device = device
             for resource in prediction.resources:
-                path = self.__download_resource(resource, progress=progress)
+                path = self.__download_resource(resource)
                 configuration.add_resource(resource.type, path)
             predictor = Predictor(configuration)
         self.__cache[tag] = predictor
@@ -227,12 +217,7 @@ class PredictionService:
         )
         return prediction
     
-    def __download_resource (
-        self,
-        resource: PredictionResource,
-        *,
-        progress: Progress
-    ) -> Path:
+    def __download_resource (self, resource: PredictionResource) -> Path:
         path = self.__get_resource_path(resource)
         if path.exists():
             return path
@@ -241,12 +226,26 @@ class PredictionService:
         response.raise_for_status()
         size = int(response.headers.get("content-length", 0))
         stem = Path(urlparse(resource.url).path).name
-        task = progress.add_task(f"Downloading", filename=stem, total=size)
-        with open(path, "wb") as fp:
+        completed = 0
+        color = "dark_orange" if not resource.type == "dso" else "purple"
+        with (
+            CustomProgressTask(
+                loading_text=f"[{color}]{stem}[/{color}]",
+                columns=[
+                    BarColumn(),
+                    DownloadColumn(),
+                    TransferSpeedColumn(),
+                    TimeRemainingColumn()
+                ]
+            ) as task,
+            NamedTemporaryFile(mode="wb", delete=False) as tmp_file
+        ):
             for chunk in response.iter_content(chunk_size=8192):
                 if chunk:
-                    fp.write(chunk)
-                    progress.update(task, advance=len(chunk))
+                    tmp_file.write(chunk)
+                    completed += len(chunk)
+                    task.update(total=size, completed=completed)
+            Path(tmp_file.name).replace(path)
         return path
 
     def __get_resource_path (self, resource: PredictionResource) -> Path:

fxn/types/predictor.py

@@ -21,7 +21,7 @@ class PredictorStatus (str, Enum):
     """
     Predictor status.
     """
-    Provisioning = "PROVISIONING"
+    Compiling = "COMPILING"
     Active = "ACTIVE"
     Invalid = "INVALID"
     Archived = "ARCHIVED"

fxn/version.py

@@ -3,4 +3,4 @@
 #   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.42"
+__version__ = "0.0.43"

{fxn-0.0.42.dist-info → fxn-0.0.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fxn
-Version: 0.0.42
+Version: 0.0.43
 Summary: Run prediction functions locally in Python. Register at https://fxn.ai.
 Author-email: "NatML Inc." <hi@fxn.ai>
 License:                                  Apache License

{fxn-0.0.42.dist-info → fxn-0.0.43.dist-info}/RECORD

@@ -1,7 +1,10 @@
-fxn/__init__.py,sha256=co_h8b85Oz3gyrT8T30RbwFQZ8Zf0i57ynGC2H44VZs,207
-fxn/client.py,sha256=i56oIr4f4ODjKhnD2EugBWQULVubIIFHqqBsoix23xw,1666
+fxn/__init__.py,sha256=62Jg67pac85KHx1pd0ipJqTZmdd8bOrzCHw7qrSThVw,242
+fxn/client.py,sha256=Deje8eiS1VOHX85tQnV34viv2CPVx2ljwHSbyVB5Z1o,3790
+fxn/compile.py,sha256=v5ZiXZoBmurdbPPIIPyh6uLA3dgDRQK2epKmP31VNjk,2800
 fxn/function.py,sha256=JBZnGaLedgoY-wV5Tg-Rxwpd3tK_ADkD0Qve45NBaA0,1342
-fxn/version.py,sha256=-M_EgT0O4ScSm10y5QibgzW8y3KbHfvkosDKMCfirOQ,95
+fxn/logging.py,sha256=sDEoRiCoVOWwHaoTep5820dS5IAVt0YRL9UI58lyAx0,4728
+fxn/sandbox.py,sha256=w2dnHMBaKOERxFMpeAP11X6_SPqcvnpd6SmX6b_FOYQ,7000
+fxn/version.py,sha256=2DgGAdo8M0eRSYqVhukqPY23jLiNk1bQDMfLzUqoxmg,95
 fxn/beta/__init__.py,sha256=gKoDhuXtXCjdhUYUqmF0gDPMhJfg3UwFgbvMtRB5ipo,111
 fxn/beta/client.py,sha256=x1AVAz0PlX0Wnemi7KXk5XfC8R6HC7vOQaGUviPJLN8,363
 fxn/beta/prediction.py,sha256=9DTBahNF6m0TicLab2o9e8IKpiSV6K7cUSTYaFju0ZU,356
@@ -14,15 +17,12 @@ fxn/c/prediction.py,sha256=-d-5yreFAaRS-nDHzhfabRNtgYcmJGiY_N2dt09gk84,2689
 fxn/c/predictor.py,sha256=48poLj1AthzCgU9n6Wv9gL8o4gFucIlOnBO2wdor6r0,1925
 fxn/c/stream.py,sha256=Y1Xv1Bt3_qlnWg9rCn7NWESpouF1eKMzDiQjhZWbXTg,1105
 fxn/c/value.py,sha256=zkmuKb153UUEnenPO560gXFzxJ_ATvs8_HM-j3OLrJU,7362
-fxn/cli/__init__.py,sha256=OBwaKLyHBqUUqwJD6waGzRRosMwbisLxCPgki0Ye_lU,1126
+fxn/cli/__init__.py,sha256=6HY2vwoR6W6bT3tXYyeVlp1Ap4F_8BdS0APomiwTG98,1303
 fxn/cli/auth.py,sha256=6iGbNbjxfCr8OZT3_neLThXdWeKRBZATwru8vU0XmRw,1688
+fxn/cli/compile.py,sha256=g8u2J58fKL9pyDkMUQe7sX4FMg27npISe0k5tG6GeEY,5307
 fxn/cli/misc.py,sha256=LcJbCj_GAgtGraTRva2zHHOPpNwI6SOFntRksxwlqvM,843
-fxn/cli/predictions.py,sha256=HN7-2BLTgwSn_4LYJQ7Ez9TpTKAZfiEGB62eMF_USaA,3084
-fxn/cli/predictors.py,sha256=t4DYwGTw_3z0dNDSqLmGmWeksPExGVPHyhHsxmVZk48,447
-fxn/compile/__init__.py,sha256=BXIcV2Ghp8YkfYZyhHuZjjV3BCLSuaoiTgu9YeFb-w0,130
-fxn/compile/compile.py,sha256=7PzPEjmHu_mQMoLcRrFOe1TJ11iZMgxcGt4rESqk6fg,3040
-fxn/compile/sandbox.py,sha256=3ewg1C3lST0KETxkx1qmqMuqcj6YJHBMdCVq4ne-2l8,5425
-fxn/compile/signature.py,sha256=QiB546g5p_MfiGt8hRi5BZ-_cmGaZm8vuYs47m2W-XM,6436
+fxn/cli/predictions.py,sha256=ma7wbsKD5CFCRTU_TtJ8N0nN1fgFX2BZPGG8qm8HlNI,3182
+fxn/cli/predictors.py,sha256=bVQAuBue_Jxb79X85RTCzOerWRRT2Ny1oF5DNYAsx4M,1545
 fxn/lib/__init__.py,sha256=-w1ikmmki5NMpzJjERW-O4SwOfBNkimej_0jL8ujYRk,71
 fxn/lib/linux/arm64/libFunction.so,sha256=NU9PEuQNObqtWPr5vXrWeQuYhzBfmX_Z4guaregFjrI,207632
 fxn/lib/linux/x86_64/libFunction.so,sha256=qZNlczayaaHIP_tJ9eeZ1TVpV1Os-ztvSWOoBuY9yWE,236272
@@ -31,17 +31,17 @@ fxn/lib/macos/x86_64/Function.dylib,sha256=qIu4dhx0Xk5dQHgTnZTcm2IpoMYJwRPmKRi9J
 fxn/lib/windows/arm64/Function.dll,sha256=FyL-oipK9wSxXdbD9frc8QFbUKTPMCdtmCkCT8ooIIM,419328
 fxn/lib/windows/x86_64/Function.dll,sha256=iL6w1FwDgBkHlNhQmhE7XgfoeHsiYQgpVGzeGDdHGUw,454656
 fxn/services/__init__.py,sha256=Bif8IttwJ089mSRsd3MFdob7z2eF-MKigKu4ZQFZBCQ,190
-fxn/services/prediction.py,sha256=IKudi7n3bm-RAW26dg188ItDgGnJcW4rcN48LD37CEg,10185
+fxn/services/prediction.py,sha256=zWk1Y35m1a0849xVammTaxrkOfSucB2qEhG-r9cUgTQ,10243
 fxn/services/predictor.py,sha256=Wl_7YKiD5mTpC5x2Zaq4BpatRjwRUX8Th9GIrwd38MA,791
 fxn/services/user.py,sha256=ADl5MFLsk4K0altgKHnI-i64E3g1wU3e56Noq_ciRuk,685
 fxn/types/__init__.py,sha256=MEg71rzbGgoWfgB4Yi5QvxbnovHTZRIzCUZLtWtWP1E,292
 fxn/types/dtype.py,sha256=b0V91aknED2Ql0_BOG_vEg__YJVJByxsgB0cR4rtotE,617
 fxn/types/prediction.py,sha256=YVnRcqm6IPEx0796OuT3dqn_jOPjhWblzuM2lkk-Vzo,2173
-fxn/types/predictor.py,sha256=51hhb1rCYFt_r86pbOIVeV_tXYE6BVhcNP27_xmQG1Q,4006
+fxn/types/predictor.py,sha256=KRGZEuDt7WPMCyRcZvQq4y2FMocfVrLEUNJCJgfDY9Y,4000
 fxn/types/user.py,sha256=Z44TwEocyxSrfKyzcNfmAXUrpX_Ry8fJ7MffSxRn4oU,1071
-fxn-0.0.42.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fxn-0.0.42.dist-info/METADATA,sha256=RM5c7vePEj9cP3OSysoHclvklaV5-byVneeQnhVSKuU,16122
-fxn-0.0.42.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fxn-0.0.42.dist-info/entry_points.txt,sha256=O_AwD5dYaeB-YT1F9hPAPuDYCkw_W0tdNGYbc5RVR2k,45
-fxn-0.0.42.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
-fxn-0.0.42.dist-info/RECORD,,
+fxn-0.0.43.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fxn-0.0.43.dist-info/METADATA,sha256=u2o6KhRYg6lkAeKgHVBnT1-x9pp-0uUK5xtma4CI8rg,16122
+fxn-0.0.43.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+fxn-0.0.43.dist-info/entry_points.txt,sha256=O_AwD5dYaeB-YT1F9hPAPuDYCkw_W0tdNGYbc5RVR2k,45
+fxn-0.0.43.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
+fxn-0.0.43.dist-info/RECORD,,

fxn/compile/__init__.py

@@ -1,7 +0,0 @@
-# 
-#   Function
-#   Copyright © 2025 NatML Inc. All Rights Reserved.
-#
-
-from .compile import compile
-from .sandbox import Sandbox

fxn/compile/signature.py

@@ -1,183 +0,0 @@
-# 
-#   Function
-#   Copyright © 2025 NatML Inc. All Rights Reserved.
-#
-
-from collections.abc import Mapping, Sequence
-from enum import Enum
-from inspect import isasyncgenfunction, iscoroutinefunction, isgeneratorfunction, signature
-from io import BytesIO
-import numpy as np
-from PIL import Image
-from pydantic import BaseModel, TypeAdapter
-from typing import get_type_hints, get_origin, get_args, Any, Dict, List, Union
-
-from ..types import Dtype, EnumerationMember, Parameter, Signature
-
-class FunctionType (str, Enum):
-    Coroutine = "ASYNC_FUNCTION"
-    Function = "FUNCTION"
-    Generator = "GENERATOR"
-    AsyncGenerator = "ASYNC_GENERATOR"
-
-def get_function_type (func) -> FunctionType:
-    if isasyncgenfunction(func):
-        return FunctionType.AsyncGenerator
-    elif iscoroutinefunction(func):
-        return FunctionType.Coroutine
-    elif isgeneratorfunction(func):
-        return FunctionType.Generator
-    else:
-        return FunctionType.Function
-
-def infer_function_signature (func) -> Signature:
-    inputs = _get_input_parameters(func)
-    outputs = _get_output_parameters(func)
-    signature = Signature(inputs=inputs, outputs=outputs)
-    return signature
-
-def _get_input_parameters (func) -> list[Parameter]:
-    sig = signature(func)
-    type_hints = get_type_hints(func)
-    parameters = []
-    for name, param in sig.parameters.items():
-        param_type = type_hints.get(name)
-        if param_type is None:
-            raise TypeError(f"Missing type annotation for parameter '{name}' in function '{func.__name__}'")
-        dtype = _infer_dtype(param_type)
-        enumeration = [EnumerationMember(
-            name=member.name,
-            value=member.value
-        ) for member in param_type] if _is_enum_subclass(param_type) else None
-        value_schema = _get_type_schema(param_type) if dtype in { Dtype.list, Dtype.dict } else None
-        input_param = Parameter(
-            name=name,
-            type=dtype,
-            description=None,
-            optional=param.default != param.empty,
-            range=None,
-            enumeration=enumeration,
-            value_schema=value_schema
-        )
-        parameters.append(input_param)
-    return parameters
-
-def _get_output_parameters (func) -> list[Parameter]:
-    # Check for return annotation
-    sig = signature(func)
-    if sig.return_annotation is sig.empty:
-        raise TypeError(f"Missing return type annotation for function '{func.__name__}'")
-    # Gather return types
-    return_types = []
-    if _is_tuple_type(sig.return_annotation):
-        return_types = get_args(sig.return_annotation)
-        if not return_types or Ellipsis in return_types:
-            raise TypeError(f"Return type of function '{func.__name__}' must be fully typed with generic type arguments.")
-    else:
-        return_types = [sig.return_annotation]
-    # Create parameters
-    parameters = [_get_output_parameter(f"output{idx}", output_type) for idx, output_type in enumerate(return_types)]
-    return parameters
-    
-def _get_output_parameter (name: str, return_type) -> Parameter:
-    dtype = _infer_dtype(return_type)
-    enumeration = [EnumerationMember(
-        name=member.name,
-        value=member.value
-    ) for member in return_type] if _is_enum_subclass(return_type) else None
-    value_schema = _get_type_schema(return_type) if dtype in { Dtype.list, Dtype.dict } else None
-    parameter = Parameter(
-        name=name,
-        type=dtype,
-        description=None,
-        optional=False,
-        range=None,
-        enumeration=enumeration,
-        value_schema=value_schema
-    )
-    return parameter
-
-def _infer_dtype (param_type) -> Dtype:
-    param_type = _strip_optional(param_type)
-    origin = get_origin(param_type)
-    args = get_args(param_type)
-    if origin is None:
-        if param_type is np.ndarray:
-            return Dtype.float32
-        elif param_type is Image.Image:
-            return Dtype.image
-        elif param_type in { bytes, bytearray, memoryview, BytesIO }:
-            return Dtype.binary
-        elif param_type is int:
-            return Dtype.int32
-        elif param_type is float:
-            return Dtype.float32
-        elif param_type is bool:
-            return Dtype.bool
-        elif param_type is str:
-            return Dtype.string
-        elif _is_enum_subclass(param_type):
-            return Dtype.string
-        elif param_type is list:
-            return Dtype.list
-        elif param_type is dict:
-            return Dtype.dict
-        elif _is_pydantic_model(param_type):
-            return Dtype.dict
-        else:
-            raise TypeError(f"Unsupported parameter type: {param_type}")
-    else:
-        if origin in { list, List, Sequence }:
-            return Dtype.list
-        elif origin in { dict, Dict, Mapping }:
-            return Dtype.dict
-        elif origin is np.ndarray:
-            if args:
-                dtype_arg = args[0]
-                dtype = _numpy_to_fxn_dtype(dtype_arg)
-                if dtype is not None:
-                    return dtype
-            return Dtype.float32
-        else:
-            raise TypeError(f"Unsupported parameter type: {param_type}")
-
-def _is_enum_subclass (cls) -> bool:
-    return isinstance(cls, type) and issubclass(cls, Enum)
-
-def _is_pydantic_model (cls) -> bool:
-    return isinstance(cls, type) and issubclass(cls, BaseModel)
-
-def _is_tuple_type (param_type) -> bool:
-    origin = get_origin(param_type)
-    return origin is tuple
-
-def _strip_optional (param_type):
-    if get_origin(param_type) is Union:
-        args = get_args(param_type)
-        non_none_args = [arg for arg in args if arg is not type(None)]
-        if len(non_none_args) == 1:
-            return non_none_args[0]
-    return param_type
-
-def _numpy_to_fxn_dtype (dtype) -> Dtype | None:
-    dtype_mapping = {
-        np.int8:    Dtype.int8,
-        np.int16:   Dtype.int16,
-        np.int32:   Dtype.int32,
-        np.int64:   Dtype.int64,
-        np.uint8:   Dtype.uint8,
-        np.uint16:  Dtype.uint16,
-        np.uint32:  Dtype.uint32,
-        np.uint64:  Dtype.uint64,
-        np.float16: Dtype.float16,
-        np.float32: Dtype.float32,
-        np.float64: Dtype.float64,
-        np.bool_:   Dtype.bool,
-    }
-    return dtype_mapping.get(dtype, None)
-
-def _get_type_schema (param_type) -> dict[str, Any] | None:
-    try:
-        return TypeAdapter(param_type).json_schema(mode="serialization")
-    except Exception:
-        return None