fxn 0.0.42__tar.gz → 0.0.43__tar.gz

{fxn-0.0.42 → fxn-0.0.43}/PKG-INFO

@@ -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 → fxn-0.0.43}/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-0.0.42 → fxn-0.0.43}/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-0.0.43/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-0.0.42 → fxn-0.0.43}/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-0.0.43/fxn/cli/predictors.py

@@ -0,0 +1,49 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+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.")
+):
+    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-0.0.43/fxn/client.py

@@ -0,0 +1,119 @@
+#
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from json import loads, JSONDecodeError
+from pydantic import BaseModel, TypeAdapter
+from requests import request
+from typing import AsyncGenerator, Literal, Type, TypeVar
+
+T = TypeVar("T", bound=BaseModel)
+
+class FunctionClient:
+    
+    def __init__(self, access_key: str, api_url: str | None) -> None:
+        self.access_key = access_key
+        self.api_url = api_url or "https://api.fxn.ai/v1"
+
+    def request (
+        self,
+        *,
+        method: Literal["GET", "POST", "PATCH", "DELETE"],
+        path: str,
+        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}",
+            json=body,
+            headers={ "Authorization": f"Bearer {self.access_key}" }
+        )
+        data = response.text
+        try:
+            data = response.json()
+        except JSONDecodeError:
+            pass
+        if response.ok:
+            return response_type(**data) if response_type is not None else None
+        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):
+
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+    def __str__(self):
+        return f"FunctionAPIError: {self.message} (Status Code: {self.status_code})"
+    
+class _APIError (BaseModel):
+    message: str
+
+class _ErrorResponse (BaseModel):
+    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-0.0.42/fxn/compile → fxn-0.0.43/fxn}/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-0.0.43/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