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

fxn/cli/predictors.py

@@ -1,66 +1,49 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from rich import print_json
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from typer import Argument, Option
+from typer import Argument
 
 from ..function import Function
-from ..types import PredictorStatus
+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 list_predictors (
-    owner: str=Option(None, help="Predictor owner. This defaults to the current user."),
-    status: PredictorStatus=Option(PredictorStatus.Active, help="Predictor status. This defaults to `ACTIVE`."),
-    offset: int=Option(None, help="Pagination offset."),
-    count: int=Option(None, help="Pagination count.")
-):
-    fxn = Function(get_access_key())
-    predictors = fxn.predictors.list(
-        owner=owner,
-        status=status,
-        offset=offset,
-        count=count
-    )
-    predictors = [predictor.model_dump() for predictor in predictors] if predictors is not None else None
-    print_json(data=predictors)
-
-def search_predictors (
-    query: str=Argument(..., help="Search query."),
-    offset: int=Option(None, help="Pagination offset."),
-    count: int=Option(None, help="Pagination count.")
-):
-    fxn = Function(get_access_key())
-    predictors = fxn.predictors.search(query=query, offset=offset, count=count)
-    predictors = [predictor.model_dump() for predictor in predictors]
-    print_json(data=predictors)
-
-def delete_predictor (
+def archive_predictor (
     tag: str=Argument(..., help="Predictor tag.")
 ):
-    with Progress(
-        SpinnerColumn(spinner_name="dots"),
-        TextColumn("[progress.description]{task.description}"),
-        transient=True
-    ) as progress:
-        progress.add_task(description="Deleting Function...", total=None)
-        fxn = Function(get_access_key())
-        result = fxn.predictors.delete(tag)
-        print_json(data=result)
+    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 archive_predictor (
+def delete_predictor (
     tag: str=Argument(..., help="Predictor tag.")
 ):
-    fxn = Function(get_access_key())
-    predictor = fxn.predictors.archive(tag)
-    print_json(data=predictor.model_dump())
+    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

@@ -1,10 +1,14 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
+from json import loads, JSONDecodeError
+from pydantic import BaseModel, TypeAdapter
 from requests import request
-from typing import Any, Literal
+from typing import AsyncGenerator, Literal, Type, TypeVar
+
+T = TypeVar("T", bound=BaseModel)
 
 class FunctionClient:
     
@@ -15,25 +19,83 @@ class FunctionClient:
     def request (
         self,
         *,
-        method: Literal["GET", "POST", "DELETE"],
+        method: Literal["GET", "POST", "PATCH", "DELETE"],
         path: str,
-        body: dict[str, Any]=None
-    ) -> dict[str, Any] | list[Any]:
+        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 = None
+        data = response.text
         try:
             data = response.json()
-        except Exception as ex:
-            raise FunctionAPIError(str(ex), response.status_code)
-        if not response.ok:
-            error = data["errors"][0]["message"] if "errors" in data else str(ex)
+        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)
-        return data
+        
+    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):
 
@@ -43,4 +105,15 @@ class FunctionAPIError (Exception):
         self.status_code = status_code
 
     def __str__(self):
-        return f"FunctionAPIError: {self.message} (Status Code: {self.status_code})"
+        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/compile.py

@@ -0,0 +1,76 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from collections.abc import Callable
+from functools import wraps
+from inspect import isasyncgenfunction, iscoroutinefunction
+from pathlib import Path
+from pydantic import BaseModel, Field
+
+from .sandbox import Sandbox
+from .types import AccessMode
+
+class PredictorSpec (BaseModel):
+    """
+    Descriptor of a predictor to be compiled.
+    """
+    tag: str = Field(description="Predictor tag.")
+    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.")
+    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.")
+
+def compile (
+    tag: str,
+    *,
+    description: str,
+    sandbox: Sandbox=None,
+    access: AccessMode=AccessMode.Private,
+    card: str | Path=None,
+    media: Path=None,
+    license: str=None,
+):
+    """
+    Create a predictor by compiling a stateless function.
+
+    Parameters:
+        tag (str): Predictor tag.
+        description (str): Predictor description. MUST be less than 100 characters long.
+        sandbox (Sandbox): Sandbox to compile the function.
+        access (AccessMode): Predictor access.
+        card (str | Path): Predictor card markdown string or path to card.
+        media (Path): Predictor thumbnail image (jpeg or png) path.
+        license (str): Predictor license URL. This is required for public predictors.
+    """
+    def decorator (func: Callable):
+        # Check type
+        if not callable(func):
+            raise TypeError("Cannot compile non-function objects")
+        if isasyncgenfunction(func) or iscoroutinefunction(func):
+            raise TypeError(f"Function '{func.__name__}' must be a regular function or generator")            
+        # Gather metadata
+        if isinstance(card, Path):
+            with open(card_content, "r") as f:
+                card_content = f.read()
+        else:
+            card_content = card
+        spec = PredictorSpec(
+            tag=tag,
+            description=description,
+            sandbox=sandbox if sandbox is not None else Sandbox(),
+            access=access,
+            card=card_content,
+            media=None, # INCOMPLETE
+            license=license
+        )
+        # Wrap
+        @wraps(func)
+        def wrapper (*args, **kwargs):
+            return func(*args, **kwargs)
+        wrapper.__predictor_spec = spec
+        return wrapper
+    return decorator

fxn/function.py

@@ -1,10 +1,11 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from os import environ
 
+from .beta.client import BetaClient
 from .client import FunctionClient
 from .services import PredictionService, PredictorService, UserService
 
@@ -17,6 +18,7 @@ class Function:
         users (UserService): Manage users.
         predictors (PredictorService): Manage predictors.
         predictions (PredictionService): Manage predictions.
+        beta (BetaClient): Beta client for incubating features.
 
     Constructor:
         access_key (str): Function access key.
@@ -26,6 +28,7 @@ class Function:
     users: UserService
     predictors: PredictorService
     predictions: PredictionService
+    beta: BetaClient
 
     def __init__ (self, access_key: str=None, api_url: str=None):
         access_key = access_key or environ.get("FXN_ACCESS_KEY", None)
@@ -33,4 +36,5 @@ class Function:
         self.client = FunctionClient(access_key, api_url)
         self.users = UserService(self.client)
         self.predictors = PredictorService(self.client)
-        self.predictions = PredictionService(self.client)
+        self.predictions = PredictionService(self.client)
+        self.beta = BetaClient(self.client)

fxn/lib/__init__.py

@@ -1,4 +1,4 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #

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