fxn 0.0.9__tar.gz → 0.0.11__tar.gz

{fxn-0.0.9 → fxn-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fxn
-Version: 0.0.9
+Version: 0.0.11
 Summary: Run on-device and cloud AI prediction functions in Python. Register at https://hub.fxn.ai.
 Home-page: https://fxn.ai
 Author: NatML Inc.

{fxn-0.0.9 → fxn-0.0.11}/fxn/api/__init__.py

@@ -6,9 +6,8 @@
 from .dtype import Dtype
 from .environment import EnvironmentVariable
 from .feature import Feature
-from .featureinput import FeatureInput
 from .prediction import CloudPrediction, EdgePrediction, Prediction
-from .predictor import Acceleration, AccessMode, Parameter, Predictor, PredictorStatus, PredictorType, Signature
+from .predictor import Acceleration, AccessMode, EnumerationMember, Parameter, Predictor, PredictorStatus, PredictorType, Signature
 from .profile import Profile
 from .storage import Storage, UploadType
 from .user import User

{fxn-0.0.9 → fxn-0.0.11}/fxn/api/dtype.py

@@ -28,5 +28,5 @@ class Dtype (str, Enum):
     image = "image"
     video = "video"
     audio = "audio"
-    _3d = "3d"
+    model = "model"
     binary = "binary"

fxn-0.0.11/fxn/api/feature.py

@@ -0,0 +1,184 @@
+#
+#   Function
+#   Copyright © 2023 NatML Inc. All Rights Reserved.
+#
+
+from __future__ import annotations
+from dataclasses import asdict, dataclass, is_dataclass
+from filetype import guess_mime
+from io import BytesIO
+from json import loads, dumps
+from numpy import array, float32, frombuffer, int32, ndarray
+from pathlib import Path
+from PIL import Image
+from requests import get
+from tempfile import NamedTemporaryFile
+from typing import Dict, List, Optional, Union
+from urllib.request import urlopen
+
+from .dtype import Dtype
+from .storage import Storage, UploadType
+
+@dataclass(frozen=True)
+class Feature:
+    """
+    Prediction feature.
+
+    Members:
+        data (str): Feature data URL. This can be a web URL or a data URL.
+        type (Dtype): Feature data type.
+        shape (list): Feature shape. This is `None` if shape information is not available or applicable.
+    """
+    data: str
+    type: Dtype
+    shape: Optional[List[int]] = None
+
+    def to_value (
+        self,
+        return_binary_path: bool=True
+    ) -> Union[str, float, int, bool, ndarray, list, dict, Image.Image, Path]:
+        """
+        Convert a feature to a plain Python value.
+
+        Parameters:
+            return_binary_path (str): Write binary features to file and return a `Path` instead of returning `BytesIO` instance.
+
+        Returns:
+            str | float | int | bool | ndarray | list | dict | Image.Image | Path: Feature value.
+        """
+        buffer = Feature.__download_feature_data(self.data)
+        # Array
+        if self.type in [
+            Dtype.int8, Dtype.int16, Dtype.int32, Dtype.int64,
+            Dtype.uint8, Dtype.uint16, Dtype.uint32, Dtype.uint64,
+            Dtype.float16, Dtype.float32, Dtype.float64, Dtype.bool
+        ]:
+            assert self.shape is not None, "Array feature must have a shape specified"
+            array = frombuffer(buffer.getbuffer(), dtype=self.type).reshape(self.shape)
+            return array if len(self.shape) > 0 else array.item()
+        # String
+        if self.type == Dtype.string:
+            return buffer.getvalue().decode("utf-8")
+        # List
+        if self.type == Dtype.list:
+            return loads(buffer.getvalue().decode("utf-8"))
+        # Dict
+        if self.type == Dtype.dict:
+            return loads(buffer.getvalue().decode("utf-8"))
+        # Image
+        if self.type == Dtype.image:
+            return Image.open(buffer)
+        # Binary
+        if return_binary_path:
+            with NamedTemporaryFile(mode="wb", delete=False) as f:
+                f.write(buffer.getbuffer())
+            return Path(f.name)
+        # Return
+        return buffer
+
+    @classmethod
+    def from_value (
+        cls,
+        value: Union[str, float, int, bool, ndarray, List, Dict[str, any], Path, Image.Image],
+        name: str,
+        type: Dtype=None,
+        min_upload_size: int=4096,
+        key: str=None
+    ) -> Feature:
+        """
+        Create a feature input from a given value.
+
+        Parameters:
+            value (str | float | int | bool | ndarray | list | dict | dataclass | Path | PIL.Image): Value.
+            name (str): Feature name.
+            type (Dtype): Feature data type override.
+            min_upload_size (int): Features larger than this size in bytes will be uploaded.
+
+        Returns:
+            Feature: Feature.
+        """
+        # Feature
+        if isinstance(value, Feature):
+            return value
+        # Array
+        if isinstance(value, ndarray):
+            buffer = BytesIO(value.tobytes())
+            data = Storage.upload(buffer, UploadType.Feature, name=name, data_url_limit=min_upload_size, key=key)
+            type = type or value.dtype.name
+            return Feature(data, type, shape=list(value.shape))
+        # String
+        if isinstance(value, str):
+            buffer = BytesIO(value.encode("utf-8"))
+            data = Storage.upload(buffer, UploadType.Feature, name=name, data_url_limit=min_upload_size, key=key)
+            type = type or Dtype.string
+            return Feature(data, type)
+        # Float
+        if isinstance(value, float):
+            value = array(value, dtype=float32)
+            return cls.from_value(value, name, type=type, min_upload_size=min_upload_size, key=key)
+        # Boolean
+        if isinstance(value, bool):
+            value = array(value, dtype=bool)
+            return cls.from_value(value, name, type=type, min_upload_size=min_upload_size, key=key)
+        # Integer
+        if isinstance(value, int):
+            value = array(value, dtype=int32)
+            return cls.from_value(value, name, type=type, min_upload_size=min_upload_size, key=key)
+        # List
+        if isinstance(value, list):
+            value = dumps(value)
+            type = type or Dtype.list
+            return cls.from_value(value, name, type=type, min_upload_size=min_upload_size, key=key)
+        # Dict
+        if isinstance(value, dict):
+            value = dumps(value)
+            type = type or Dtype.dict
+            return cls.from_value(value, name, type=type, min_upload_size=min_upload_size, key=key)
+        # Dataclass # https://docs.python.org/3/library/dataclasses.html#dataclasses.is_dataclass
+        if is_dataclass(value) and not isinstance(value, type):
+            value = asdict(value)
+            type = type or Dtype.dict
+            return cls.from_value(value, name=name, type=type, min_upload_size=min_upload_size, key=key)
+        # Image
+        if isinstance(value, Image.Image):
+            buffer = BytesIO()
+            format = "PNG" if value.mode == "RGBA" else "JPEG"
+            value.save(buffer, format=format)
+            data = Storage.upload(buffer, UploadType.Feature, name=name, data_url_limit=min_upload_size, key=key)
+            type = type or Dtype.image
+            return Feature(data, type)
+        # Path
+        if isinstance(value, Path):
+            assert value.is_file(), "Feature path must point to a file, not a directory"
+            value = value.expanduser().resolve()
+            data = Storage.upload(value, UploadType.Feature, name=name, data_url_limit=min_upload_size, key=key)
+            type = type or cls.__get_file_dtype(value)
+            return Feature(data, type)
+        # Unsupported
+        raise RuntimeError(f"Cannot create feature '{name}' for value {value} of type {type(value)}")
+
+    @classmethod
+    def __get_file_dtype (cls, path: Path) -> Dtype:
+        mime = guess_mime(str(path))
+        if not mime:
+            return Dtype.binary
+        if mime.startswith("image"):
+            return Dtype.image
+        if mime.startswith("video"):
+            return Dtype.video
+        if mime.startswith("audio"):
+            return Dtype.audio
+        if path.suffix in [".obj", ".gltf", ".glb", ".fbx", ".usd", ".usdz", ".blend"]:
+            return Dtype._3d
+        return Dtype.binary
+
+    @classmethod
+    def __download_feature_data (cls, url: str) -> BytesIO:
+        # Check if data URL
+        if url.startswith("data:"):
+            with urlopen(url) as response:
+                return BytesIO(response.read())
+        # Download
+        response = get(url)
+        result = BytesIO(response.content)
+        return result

fxn-0.0.11/fxn/api/prediction.py

@@ -0,0 +1,132 @@
+#
+#   Function
+#   Copyright © 2023 NatML Inc. All Rights Reserved.
+#
+
+from __future__ import annotations
+from dataclasses import asdict, dataclass
+from numpy import ndarray
+from pathlib import Path
+from PIL import Image
+from platform import system
+from typing import Any, Dict, List, Union
+from uuid import uuid4
+
+from .api import query
+from .feature import Feature
+from .predictor import PredictorType
+
+@dataclass(frozen=True)
+class Prediction:
+    """
+    Prediction.
+
+    Members:
+        id (str): Prediction ID.
+        tag (str): Predictor tag.
+        type (PredictorType): Prediction type.
+        created (str): Date created.
+    """
+    id: str
+    tag: str
+    type: PredictorType
+    created: str
+    FIELDS = f"""
+    id
+    tag
+    type
+    created
+    ... on CloudPrediction {{
+        results {{
+            data
+            type
+            shape
+        }}
+        latency
+        error
+        logs
+    }}
+    """
+
+    @classmethod
+    def create (
+        cls,
+        tag: str,
+        raw_outputs: bool=False,
+        return_binary_path: bool=True,
+        data_url_limit: int=None,
+        access_key: str=None,
+        **inputs: Dict[str, Union[ndarray, str, float, int, bool, List, Dict[str, Any], Path, Image.Image, Feature]],
+    ) -> Union[CloudPrediction, EdgePrediction]:
+        """
+        Create a prediction.
+
+        Parameters:
+            tag (str): Predictor tag.
+            raw_outputs (bool): Skip parsing output features into Pythonic data types.
+            return_binary_path (bool): Write binary features to file and return a `Path` instead of returning `BytesIO` instance.
+            data_url_limit (int): Return a data URL if a given output feature is smaller than this size in bytes. Only applies to `CLOUD` predictions.
+            access_key (str): Function access key.
+            inputs (dict): Input features. Only applies to `CLOUD` predictions.
+
+        Returns:
+            CloudPrediction | EdgePrediction: Created prediction.
+        """
+        # Collect inputs
+        key = uuid4().hex
+        inputs = { name: Feature.from_value(value, name, key=key) for name, value in inputs.items() }
+        inputs = [{ "name": name, **asdict(feature) } for name, feature in inputs.items()]
+        # Query
+        response = query(f"""
+            mutation ($input: CreatePredictionInput!) {{
+                createPrediction (input: $input) {{
+                    {cls.FIELDS}
+                }}
+            }}""",
+            { "input": { "tag": tag, "client": cls.__get_client(), "inputs": inputs, "dataUrlLimit": data_url_limit } },
+            access_key=access_key
+        )
+        # Check
+        prediction = response["createPrediction"]
+        if not prediction:
+            return None
+        # Parse results
+        if "results" in prediction and prediction["results"] is not None:
+            prediction["results"] = [Feature(**feature).to_value(return_binary_path=return_binary_path) if not raw_outputs else Feature(**feature) for feature in prediction["results"]]
+        # Create
+        prediction = CloudPrediction(**prediction) if prediction["type"] == PredictorType.Cloud else EdgePrediction(**prediction)
+        # Return
+        return prediction
+
+    @classmethod
+    def __get_client (cls) -> str:
+        id = system()
+        if id == "Darwin":
+            return "macos"
+        if id == "Linux":
+            return "linux"
+        if id == "Windows":
+            return "windows"
+        raise RuntimeError(f"Function cannot make predictions on the {id} platform")
+
+@dataclass(frozen=True)
+class CloudPrediction (Prediction):
+    """
+    Cloud prediction.
+
+    Members:
+        results (list): Prediction results.
+        latency (float): Prediction latency in milliseconds.
+        error (str): Prediction error. This is `null` if the prediction completed successfully.
+        logs (str): Prediction logs.
+    """
+    results: List[Feature] = None
+    latency: float = None
+    error: str = None
+    logs: str = None
+
+@dataclass(frozen=True)
+class EdgePrediction (Prediction):
+    """
+    Edge prediction.
+    """

{fxn-0.0.9 → fxn-0.0.11}/fxn/api/predictor.py

@@ -65,10 +65,11 @@ class Predictor:
             description
             range
             optional
-            string_default: stringDefault
-            float_default: floatDefault
-            int_default: intDefault
-            bool_default: boolDefault
+            enumeration {{
+                name
+                value
+            }}
+            default_value: defaultValue
         }}
         outputs {{
             name
@@ -118,6 +119,54 @@ class Predictor:
         # Return
         return predictor
     
+    @classmethod
+    def list (
+        cls,
+        owner: str=None,
+        status: PredictorStatus=None,
+        offset: int=None,
+        count: int=None,
+        access_key: str=None
+    ) -> List[Predictor]:
+        """
+        List the current user's predictors.
+
+        Parameters:
+            owner (str): Predictor owner. This defaults to the current user.
+            status (PredictorStatus): Predictor status. This defaults to `ACTIVE`.
+            offset (int): Pagination offset.
+            count (int): Pagination count.
+            access_key (str): Function access key.
+
+        Returns:
+            list: User predictors.
+        """
+        # Query
+        response = query(f"""
+            query ($user: UserInput, $predictors: UserPredictorsInput) {{
+                user (input: $user) {{
+                    predictors (input: $predictors) {{
+                        {cls.FIELDS}
+                    }}
+                }}
+            }}
+            """,
+            {
+                "user": { "username": owner } if owner else None,
+                "predictors": { "status": status, "offset": offset, "count": count }
+            },
+            access_key=access_key
+        )
+        # Check
+        user = response["user"]
+        if not user:
+            return None
+        # Create predictors
+        predictors = response["user"]["predictors"]
+        predictors = [Predictor(**predictor) for predictor in predictors]
+        # Return
+        return predictors
+    
     @classmethod
     def search (
         cls,
@@ -131,6 +180,8 @@ class Predictor:
 
         Parameters:
             query (str): Search query.
+            offset (int): Pagination offset.
+            count (int): Pagination count.
             access_key (str): Function access key.
 
         Returns:
@@ -312,20 +363,32 @@ class Parameter:
         description (str): Parameter description.
         optional (bool): Parameter is optional.
         range (tuple): Parameter value range for numeric parameters.
-        stringDefault (str): Parameter default string value.
-        floatDefault (float): Parameter default float value.
-        intDefault (int): Parameter default integer value.
-        boolDefault (bool): Parameter default boolean value.
+        enumeration (list): Parameter value choices for enumeration parameters.
+        default_value (str | float | int | bool): Parameter default value.
     """
     name: Optional[str] = None
     type: Optional[Dtype] = None
     description: Optional[str] = None
     optional: Optional[bool] = None
     range: Optional[Tuple[float, float]] = None
-    string_default: Optional[str] = None
-    float_default: Optional[float] = None
-    int_default: Optional[int] = None
-    bool_default: Optional[bool] = None
+    enumeration: Optional[List[EnumerationMember]] = None
+    default_value: Optional[Union[str, float, int, bool]] = None
+
+    def __post_init__ (self):
+        enumeration = [EnumerationMember(**member) if isinstance(member, dict) else member for member in self.enumeration] if self.enumeration else self.enumeration
+        object.__setattr__(self, "enumeration", enumeration)
+
+@dataclass(frozen=True)
+class EnumerationMember:
+    """
+    Prediction parameter enumeration member.
+
+    Members:
+        name (str): Enumeration member name.
+        value (str | float | int): Enumeration member value.
+    """
+    name: str
+    value: Union[str, float, int]
 
 class Acceleration (str, Enum):
     """

fxn-0.0.11/fxn/api/storage.py

@@ -0,0 +1,146 @@
+# 
+#   Function
+#   Copyright © 2023 NatML Inc. All Rights Reserved.
+#
+
+from base64 import b64encode
+from enum import Enum
+from io import BytesIO
+from filetype import guess_mime
+from pathlib import Path
+from requests import put
+from rich.progress import open as open_progress, wrap_file
+from typing import Union
+
+from .api import query
+
+class UploadType (str, Enum):
+    """
+    Upload URL type.
+    """
+    Feature = "FEATURE"
+    Media = "MEDIA"
+    Notebook = "NOTEBOOK"
+
+class Storage:
+    """
+    Upload and download files.
+    """
+
+    @classmethod
+    def create_upload_url (
+        cls,
+        name: str,
+        type: UploadType,
+        key: str=None
+    ) -> str:
+        """
+        Create an upload URL.
+
+        Parameters:
+            name (str): File name.
+            type (UploadType): Upload type.
+            key (str): File key. This is useful for grouping related files.
+
+        Returns:
+            str: File upload URL.
+        """
+        # Query
+        response = query(f"""
+            mutation ($input: CreateUploadUrlInput!) {{
+                createUploadUrl (input: $input)
+            }}
+            """,
+            { "input": { "type": type, "name": name, "key": key } }
+        )
+        url = response["createUploadUrl"]
+        # Return
+        return url
+
+    @classmethod
+    def upload (
+        cls,
+        file: Union[str, Path, BytesIO],
+        type: UploadType,
+        name: str=None,
+        data_url_limit: int=None,
+        key: str=None,
+        verbose: bool=False
+    ) -> str:
+        """
+        Upload a file and return the URL.
+
+        Parameters:
+            file (str | Path | BytesIO): File path.
+            type (UploadType): File type.
+            name (str): File name. This MUST be provided if `file` is not a file path.
+            data_url_limit (int): Return a data URL if the output feature is smaller than this limit (in bytes).
+            key (str): File key. This is useful for grouping related files.
+            verbose (bool): Print a progress bar for the upload.
+
+        Returns:
+            str: Upload URL.
+        """
+        file = Path(file) if isinstance(file, str) else file
+        if isinstance(file, Path):
+            return cls.__upload_file(file, type, name=name, key=key, data_url_limit=data_url_limit, verbose=verbose)
+        else:
+            return cls.__upload_buffer(file, type, name=name, key=key, data_url_limit=data_url_limit, verbose=verbose)
+    
+    @classmethod
+    def __upload_file (
+        cls,
+        file: Path,
+        type: UploadType,
+        name: str=None,
+        key: str=None,
+        data_url_limit: int=None,
+        verbose: bool=False
+    ) -> str:
+        # Check file
+        assert file.exists(), f"Cannot upload {file.name} because the file does not exist"
+        assert file.is_file(), f"Cannot upload {file.name} becaause it does not point to a file"   
+        # Create data URL
+        mime = guess_mime(file) or "application/octet-stream"
+        if file.stat().st_size <= (data_url_limit or 0):
+            with open(file, mode="rb") as f:
+                buffer = BytesIO(f.read())
+            return cls.__create_data_url(buffer, mime)
+        # Upload
+        name = name or file.name
+        url = cls.create_upload_url(name, type, key=key)
+        with open_progress(file, mode="rb", description=name, disable=not verbose) as f:
+            put(url, data=f, headers={ "Content-Type": mime }).raise_for_status()
+        # Return
+        return url
+    
+    @classmethod
+    def __upload_buffer (
+        cls,
+        file: BytesIO,
+        type: UploadType,
+        name: str=None,
+        key: str=None,
+        data_url_limit: int=None,
+        verbose: bool=False
+    ) -> str:
+        # Check name
+        assert name, "You must specify the file `name` if the `file` is not a path"
+        # Create data URL
+        file.seek(0)
+        mime = guess_mime(file) or "application/octet-stream"
+        size = file.getbuffer().nbytes
+        if size <= (data_url_limit or 0):
+            return cls.__create_data_url(file, mime)
+        # Upload
+        url = cls.create_upload_url(name, type, key=key)
+        with wrap_file(file, total=size, description=name, disable=not verbose) as f:
+            put(url, data=f, headers={ "Content-Type": mime }).raise_for_status()
+        # Return
+        return url
+    
+    @classmethod
+    def __create_data_url (cls, file: BytesIO, mime: str) -> str:
+        encoded_data = b64encode(file.getvalue()).decode("ascii")
+        url = f"data:{mime};base64,{encoded_data}"
+        return url

{fxn-0.0.9 → fxn-0.0.11}/fxn/cli/__init__.py

@@ -9,7 +9,7 @@ from .auth import app as auth_app
 from .env import app as env_app
 from .misc import cli_options
 from .predict import predict
-from .predictors import archive_predictor, create_predictor, delete_predictor, retrieve_predictor, search_predictors
+from .predictors import archive_predictor, create_predictor, delete_predictor, list_predictors, retrieve_predictor, search_predictors
 from ..version import __version__
 
 # Define CLI
@@ -32,6 +32,7 @@ app.add_typer(env_app, name="env", help="Manage predictor environment variables.
 app.command(name="create", help="Create a predictor.")(create_predictor)
 app.command(name="delete", help="Delete a predictor.")(delete_predictor)
 app.command(name="predict", help="Make a prediction.", context_settings={ "allow_extra_args": True, "ignore_unknown_options": True })(predict)
+app.command(name="list", help="List predictors.")(list_predictors)
 app.command(name="search", help="Search predictors.")(search_predictors)
 app.command(name="retrieve", help="Retrieve a predictor.")(retrieve_predictor)
 app.command(name="archive", help="Archive a predictor.")(archive_predictor)

{fxn-0.0.9 → fxn-0.0.11}/fxn/cli/predict.py

@@ -4,8 +4,9 @@
 #
 
 from dataclasses import asdict
+from io import BytesIO
 from numpy import ndarray
-from pathlib import Path
+from pathlib import Path, PurePath
 from PIL import Image
 from rich import print_json
 from tempfile import mkstemp
@@ -16,7 +17,7 @@ from .auth import get_access_key
 
 def predict (
     tag: str = Argument(..., help="Predictor tag."),
-    raw_outputs: bool = Option(False, "--raw-outputs", help="Generate raw output features instead of parsing."),
+    raw_outputs: bool = Option(False, "--raw-outputs", help="Output raw features instead of parsing into Pythonic data."),
     context: Context = 0
 ):
     # Predict
@@ -25,6 +26,7 @@ def predict (
         tag=tag,
         **inputs,
         raw_outputs=raw_outputs,
+        return_binary_path=True,
         access_key=get_access_key()
     )
     # Parse results
@@ -34,7 +36,7 @@ def predict (
         results = [_serialize_feature(feature) for feature in prediction.results]
         object.__setattr__(prediction, "results", results)
     # Print
-    print_json(data=asdict(prediction))
+    print_json(data=asdict(prediction, dict_factory=_prediction_dict_factory))
     # Show images
     for image in images:
         image.show()
@@ -79,5 +81,20 @@ def _serialize_feature (feature):
         _, path = mkstemp(suffix=".png" if feature.mode == "RGBA" else ".jpg")
         feature.save(path)
         return path
+    # Serialize `BytesIO`
+    if isinstance(feature, BytesIO):
+        return str(feature)
+    # Serialize `Path`
+    if isinstance(feature, PurePath):
+        return str(feature)
     # Return    
-    return feature
+    return feature
+
+def _prediction_dict_factory (kv_pairs):
+    # Check if feature
+    FEATURE_KEYS = ["data", "type", "shape"]
+    keys = [k for k, _ in kv_pairs]
+    is_feature = all(k in keys for k in FEATURE_KEYS)
+    kv_pairs = [(k, v) for k, v in kv_pairs if v is not None] if is_feature else kv_pairs
+    # Construct
+    return dict(kv_pairs)

{fxn-0.0.9 → fxn-0.0.11}/fxn/cli/predictors.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typer import Argument, Option
 from typing import List
 
-from ..api import Acceleration, AccessMode, Predictor, PredictorType
+from ..api import Acceleration, AccessMode, Predictor, PredictorStatus, PredictorType
 from .auth import get_access_key
 
 def retrieve_predictor (
@@ -22,6 +22,22 @@ def retrieve_predictor (
     predictor = asdict(predictor) 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.")
+):
+    predictors = Predictor.list(
+        owner=owner,
+        status=status,
+        offset=offset,
+        count=count,
+        access_key=get_access_key()
+    )
+    predictors = [asdict(predictor) 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."),
@@ -44,11 +60,11 @@ def create_predictor (
     description: str=Option(None, help="Predictor description. This supports Markdown."),
     media: Path=Option(None, help="Predictor image path."),
     acceleration: Acceleration=Option(None, case_sensitive=False, help="Cloud predictor acceleration. This defaults to `CPU`."),
-    environment: List[str]=Option([], help="Predictor environment variables."),
     license: str=Option(None, help="Predictor license URL."),
+    env: List[str]=Option([], help="Specify a predictor environment variable."),
     overwrite: bool=Option(None, "--overwrite", help="Overwrite any existing predictor with the same tag.")
 ):
-    environment = { e.split("=")[0].strip(): e.split("=")[1].strip() for e in environment }
+    environment = { e.split("=")[0].strip(): e.split("=")[1].strip() for e in env }
     predictor = Predictor.create(
         tag=tag,
         notebook=notebook,

{fxn-0.0.9 → fxn-0.0.11}/fxn/version.py

@@ -3,4 +3,4 @@
 #   Copyright © 2023 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.9"
+__version__ = "0.0.11"

{fxn-0.0.9 → fxn-0.0.11}/fxn.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fxn
-Version: 0.0.9
+Version: 0.0.11
 Summary: Run on-device and cloud AI prediction functions in Python. Register at https://hub.fxn.ai.
 Home-page: https://fxn.ai
 Author: NatML Inc.

{fxn-0.0.9 → fxn-0.0.11}/fxn.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ fxn/api/api.py
 fxn/api/dtype.py
 fxn/api/environment.py
 fxn/api/feature.py
-fxn/api/featureinput.py
 fxn/api/prediction.py
 fxn/api/predictor.py
 fxn/api/profile.py

fxn-0.0.9/fxn/api/feature.py

@@ -1,23 +0,0 @@
-#
-#   Function
-#   Copyright © 2023 NatML Inc. All Rights Reserved.
-#
-
-from dataclasses import dataclass
-from typing import List, Optional
-
-from .dtype import Dtype
-
-@dataclass(frozen=True)
-class Feature:
-    """
-    Prediction feature.
-
-    Members:
-        data (str): Feature data URL.
-        type (Dtype): Feature data type.
-        shape (list): Feature shape. This is `None` if shape information is not available or applicable.
-    """
-    data: str
-    type: Dtype
-    shape: Optional[List[int]] = None

fxn-0.0.9/fxn/api/featureinput.py

@@ -1,117 +0,0 @@
-#
-#   Function
-#   Copyright © 2023 NatML Inc. All Rights Reserved.
-#
-
-from __future__ import annotations
-from base64 import b64encode
-from dataclasses import dataclass
-from filetype import guess_mime
-from io import BytesIO
-from numpy import ndarray
-from pathlib import Path
-from PIL import Image
-from typing import Any, Dict, List, Optional, Union
-
-from .dtype import Dtype
-
-@dataclass(frozen=True)
-class FeatureInput:
-    """
-    Prediction input feature.
-
-    Members:
-        name (str): Feature name. This MUST match the input parameter name defined by the predictor.
-        data (str): Feature data URL. This can be a web URL or a data URL.
-        type (Dtype): Feature data type.
-        shape (list): Feature shape. This MUST be provided for array features.
-    """
-    name: str
-    data: str = None
-    type: Dtype = None
-    shape: Optional[List[int]] = None
-    stringValue: str = None
-    floatValue: float = None
-    floatArray: List[float] = None
-    intValue: int = None
-    intArray: List[int] = None
-    boolValue: bool = None
-    listValue: list = None
-    dictValue: Dict[str, Any] = None
-
-    @classmethod
-    def from_value (
-        cls,
-        value: Union[ndarray, str, float, int, bool, List, Dict[str, any], Path, Image.Image],
-        name: str
-    ) -> FeatureInput:
-        """
-        Create a feature input from a given value.
-
-        Parameters:
-            value (any): Value.
-            name (str): Feature name.
-
-        Returns:
-            FeatureInput: Feature input.
-        """
-        # Array
-        if isinstance(value, ndarray):
-            encoded_data = b64encode(value).decode("ascii")
-            data = f"data:application/octet-stream;base64,{encoded_data}"
-            return FeatureInput(name, data, value.dtype.name, list(value.shape))
-        # String
-        if isinstance(value, str):
-            return FeatureInput(name, stringValue=value)
-        # Float
-        if isinstance(value, float):
-            return FeatureInput(name, floatValue=value)
-        # Boolean
-        if isinstance(value, bool):
-            return FeatureInput(name, boolValue=value)
-        # Integer
-        if isinstance(value, int):
-            return FeatureInput(name, intValue=value)
-        # List
-        if isinstance(value, list):
-            return FeatureInput(name, listValue=value)
-        # Dict
-        if isinstance(value, dict):
-            return FeatureInput(name, dictValue=value)
-        # Image
-        if isinstance(value, Image.Image):
-            image_buffer = BytesIO()
-            channels = { "L": 1, "RGB": 3, "RGBA": 4 }[value.mode]
-            format = "PNG" if value.mode == "RGBA" else "JPEG"
-            value.save(image_buffer, format=format)
-            encoded_data = b64encode(image_buffer.getvalue()).decode("ascii")
-            data = f"data:{value.get_format_mimetype()};base64,{encoded_data}"
-            shape = [1, value.height, value.width, channels]
-            return FeatureInput(name, data, Dtype.image, shape)
-        # Path
-        if isinstance(value, Path):
-            assert value.is_file(), "Input path must be a file, not a directory"
-            value = value.expanduser().resolve()
-            type = _file_to_dtype(value)
-            mime = guess_mime(str(value)) or "application/octet-stream"
-            with open(value, "rb") as f:
-                buffer = BytesIO(f.read())
-            encoded_data = b64encode(buffer.getvalue()).decode("ascii")
-            data = f"data:{mime};base64,{encoded_data}"
-            return FeatureInput(name, data, type)
-        # Unsupported
-        raise RuntimeError(f"Cannot create input feature for value {value} of type {type(value)}")
-    
-def _file_to_dtype (path: Path) -> str:
-    mime = guess_mime(str(path))
-    if not mime:
-        return Dtype.binary
-    if mime.startswith("image"):
-        return Dtype.image
-    if mime.startswith("video"):
-        return Dtype.video
-    if mime.startswith("audio"):
-        return Dtype.audio
-    if path.suffix in [".obj", ".gltf", ".glb", ".fbx", ".usd", ".usdz", ".blend"]:
-        return Dtype._3d
-    return Dtype.binary

fxn-0.0.9/fxn/api/prediction.py

@@ -1,186 +0,0 @@
-#
-#   Function
-#   Copyright © 2023 NatML Inc. All Rights Reserved.
-#
-
-from __future__ import annotations
-from dataclasses import asdict, dataclass
-from io import BytesIO
-from numpy import frombuffer
-from PIL import Image
-from platform import system
-from requests import get
-from typing import Any, Dict, List, Union
-from urllib.request import urlopen
-
-from .api import query
-from .dtype import Dtype
-from .feature import Feature
-from .featureinput import FeatureInput
-from .predictor import PredictorType
-
-@dataclass(frozen=True)
-class Prediction:
-    """
-    Prediction.
-
-    Members:
-        id (str): Prediction ID.
-        tag (str): Predictor tag.
-        type (PredictorType): Prediction type.
-        created (str): Date created.
-    """
-    id: str
-    tag: str
-    type: PredictorType
-    created: str
-    FIELDS = f"""
-    id
-    tag
-    type
-    created
-    ... on CloudPrediction {{
-        results {{
-            data
-            type
-            shape
-            stringValue
-            listValue
-            dictValue
-        }}
-        latency
-        error
-        logs
-    }}
-    """
-    RAW_FIELDS = f"""
-    id
-    tag
-    type
-    created
-    ... on CloudPrediction {{
-        results {{
-            data
-            type
-            shape
-        }}
-        latency
-        error
-        logs
-    }}
-    """
-
-    @classmethod
-    def create (
-        cls,
-        tag: str,
-        *features: List[FeatureInput],
-        data_url_limit: int=None,
-        raw_outputs: bool=False,
-        access_key: str=None,
-        **inputs: Dict[str, Any],
-    ) -> Union[CloudPrediction, EdgePrediction]:
-        """
-        Create a prediction.
-
-        Parameters:
-            tag (str): Predictor tag.
-            features (list): Input features. Only applies to `CLOUD` predictions.
-            data_url_limit (int): Return a data URL if a given output feature is smaller than this limit in bytes. Only applies to `CLOUD` predictions.
-            raw_outputs (bool): Skip parsing output features into Pythonic data types.
-            access_key (str): Function access key.
-            inputs (dict): Input features. Only applies to `CLOUD` predictions.
-
-        Returns:
-            CloudPrediction | EdgePrediction: Created prediction.
-        """
-        # Collect input features
-        input_features = list(features) + [FeatureInput.from_value(value, name) for name, value in inputs.items()]
-        input_features = [asdict(feature) for feature in input_features]
-        # Query
-        response = query(f"""
-            mutation ($input: CreatePredictionInput!) {{
-                createPrediction (input: $input) {{
-                    {cls.RAW_FIELDS if raw_outputs else cls.FIELDS}
-                }}
-            }}""",
-            { "input": { "tag": tag, "client": _get_client(), "inputs": input_features, "dataUrlLimit": data_url_limit } },
-            access_key=access_key
-        )
-        # Check
-        prediction = response["createPrediction"]
-        if not prediction:
-            return None
-        # Parse results
-        if "results" in prediction and not raw_outputs:
-            prediction["results"] = [_parse_output_feature(feature) for feature in prediction["results"]] if prediction["results"] is not None else None
-        # Create
-        prediction = CloudPrediction(**prediction) if prediction["type"] == PredictorType.Cloud else EdgePrediction(**prediction)
-        # Return
-        return prediction
-
-@dataclass(frozen=True)
-class CloudPrediction (Prediction):
-    """
-    Cloud prediction.
-
-    Members:
-        results (list): Prediction results.
-        latency (float): Prediction latency in milliseconds.
-        error (str): Prediction error. This is `null` if the prediction completed successfully.
-        logs (str): Prediction logs.
-    """
-    results: List[Feature] = None
-    latency: float = None
-    error: str = None
-    logs: str = None
-
-@dataclass(frozen=True)
-class EdgePrediction (Prediction):
-    """
-    Edge prediction
-    """
-
-def _parse_output_feature (feature: dict) -> Union[Feature, str, float, int, bool, Image.Image, list, dict]:
-    data, type, shape = feature["data"], feature["type"], feature["shape"]
-    # Handle image
-    if type == Dtype.image:
-        return Image.open(_download_feature_data(data))
-    # Handle non-numeric scalars
-    values = [feature.get(key, None) for key in ["stringValue", "listValue", "dictValue"]]
-    scalar = next((value for value in values if value is not None), None)
-    if scalar is not None:
-        return scalar
-    # Handle ndarray
-    ARRAY_TYPES = [
-        Dtype.int8, Dtype.int16, Dtype.int32, Dtype.int64,
-        Dtype.uint8, Dtype.uint16, Dtype.uint32, Dtype.uint64,
-        Dtype.float16, Dtype.float32, Dtype.float64, Dtype.bool
-    ]
-    if type in ARRAY_TYPES:
-        # Create array
-        array = frombuffer(_download_feature_data(data).getbuffer(), dtype=type).reshape(shape)
-        return array if len(shape) > 0 else array.item()
-    # Handle generic feature
-    feature = Feature(**feature)
-    return feature
-
-def _download_feature_data (url: str) -> BytesIO:
-    # Check if data URL
-    if url.startswith("data:"):
-        with urlopen(url) as response:
-            return BytesIO(response.read())
-    # Download
-    response = get(url)
-    result = BytesIO(response.content)
-    return result
-
-def _get_client () -> str:
-    id = system()
-    if id == "Darwin":
-        return "macos"
-    if id == "Linux":
-        return "linux"
-    if id == "Windows":
-        return "windows"
-    raise RuntimeError(f"Function cannot make predictions on the {id} platform")

fxn-0.0.9/fxn/api/storage.py

@@ -1,99 +0,0 @@
-# 
-#   Function
-#   Copyright © 2023 NatML Inc. All Rights Reserved.
-#
-
-from enum import Enum
-from io import BytesIO
-from mimetypes import guess_type
-from pathlib import Path
-from requests import put
-from rich.progress import open as open_progress
-from typing import Union
-
-from .api import query
-
-class UploadType (str, Enum):
-    """
-    Upload URL type.
-    """
-    Feature = "FEATURE"
-    Media = "MEDIA"
-    Notebook = "NOTEBOOK"
-
-class Storage:
-    """
-    Upload and download files.
-    """
-
-    @classmethod
-    def create_upload_url (
-        cls,
-        name: str,
-        type: UploadType,
-        key: str=None
-    ) -> str:
-        """
-        Create an upload URL.
-
-        Parameters:
-            name (str): File name.
-            type (UploadType): Upload type.
-            key (str): File key. This is useful for grouping related files.
-
-        Returns:
-            str: File upload URL.
-        """
-        # Query
-        response = query(f"""
-            mutation ($input: CreateUploadUrlInput!) {{
-                createUploadUrl (input: $input)
-            }}
-            """,
-            { "input": { "type": type, "name": name, "key": key } }
-        )
-        url = response["createUploadUrl"]
-        # Return
-        return url
-
-    @classmethod
-    def upload ( # INCOMPLETE # `bytes` and `BytesIO` support` # Data URL limit
-        cls,
-        file: Union[str, Path, BytesIO, bytes],
-        type: UploadType,
-        name: str=None,
-        key: str=None,
-        data_url_limit: int=0,
-        verbose: bool=False
-    ) -> str:
-        """
-        Upload a file and return the URL.
-
-        Parameters:
-            file (str | Path | BytesIO | bytes): File path.
-            type (UploadType): File type.
-            name (str): File name. This MUST be provided if `file` is not a file path.
-            key (str): File key. This is useful for grouping related files.
-            data_url_limit (int): Return a data URL if the output feature is smaller than this limit (in bytes).
-            check_extension (bool): Validate file extensions before uploading.
-            verbose (bool): Print a progress bar for the upload.
-
-        Returns:
-            str: Upload URL.
-        """
-        # Create path
-        file = Path(file) if isinstance(file, str) else file
-        # Check path
-        if not file.exists():
-            raise RuntimeError(f"Cannot upload {file.name} because the file does not exist")
-        # Check file
-        if not file.is_file():
-            raise RuntimeError(f"Cannot upload {file.name} becaause it does not point to a file")
-        # Get upload URL
-        name = name or file.name
-        mime = guess_type(file, strict=False)[0] or "application/octet-stream"
-        url = cls.create_upload_url(name, type, key=key)
-        with open_progress(file, "rb", description=name, disable=not verbose) as f:
-            put(url, data=f, headers={ "Content-Type": mime }).raise_for_status()
-        # Return
-        return url