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

fxn/compile/sandbox.py

@@ -0,0 +1,177 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from __future__ import annotations
+from hashlib import sha256
+from pathlib import Path
+from pydantic import BaseModel
+from requests import put
+from typing import Literal
+
+from ..function import Function
+
+class WorkdirCommand (BaseModel):
+    kind: Literal["workdir"] = "workdir"
+    path: str
+
+class EnvCommand (BaseModel):
+    kind: Literal["env"] = "env"
+    env: dict[str, str]
+
+class UploadFileCommand (BaseModel):
+    kind: Literal["upload_file"] = "upload_file"
+    from_path: str
+    to_path: str
+    manifest: dict[str, str] | None = None
+
+class UploadDirectoryCommand (BaseModel):
+    kind: Literal["upload_dir"] = "upload_dir"
+    from_path: str
+    to_path: str
+    manifest: dict[str, str] | None = None
+
+class PipInstallCommand (BaseModel):
+    kind: Literal["pip_install"] = "pip_install"
+    packages: list[str]
+
+class AptInstallCommand (BaseModel):
+    kind: Literal["apt_install"] = "apt_install"
+    packages: list[str]
+
+class EntrypointCommand (BaseModel):
+    kind: Literal["entrypoint"] = "entrypoint"
+    path: str
+
+Command = (
+    WorkdirCommand          |
+    EnvCommand              |
+    UploadFileCommand       |
+    UploadDirectoryCommand  |
+    PipInstallCommand       |
+    AptInstallCommand       |
+    EntrypointCommand
+)
+
+class Sandbox (BaseModel):
+    """
+    Sandbox which defines a containerized environment for compiling your Python function.
+    """
+    commands: list[Command] = []
+
+    def workdir (self, path: str | Path) -> Sandbox:
+        """
+        Change the current working directory for subsequent commands.
+
+        Parameters:
+            path (str | Path): Path to change to.
+        """
+        command = WorkdirCommand(path=str(path))
+        self.commands.append(command)
+        return self
+
+    def env (self, **env: str) -> Sandbox:
+        """
+        Set environment variables in the sandbox.
+        """
+        command = EnvCommand(env=env)
+        self.commands.append(command)
+        return self
+
+    def upload_file (
+        self,
+        from_path: str | Path,
+        to_path: str | Path = "./"
+    ) -> Sandbox:
+        """
+        Upload a file to the sandbox.
+
+        Parameters:
+            from_path (str | Path): File path on the local file system.
+            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
+
+    def upload_directory (
+        self,
+        from_path: str | Path,
+        to_path: str | Path = "."
+    ) -> Sandbox:
+        """
+        Upload a directory to the sandbox.
+
+        Parameters:
+            from_path (str | Path): Directory path on the local file system.
+            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
+
+    def pip_install (self, *packages: str) -> Sandbox:
+        """
+        Install Python packages in the sandbox.
+
+        Parameters:
+            packages (list): Packages to install.
+        """
+        command = PipInstallCommand(packages=packages)
+        self.commands.append(command)
+        return self
+
+    def apt_install (self, *packages: str) -> Sandbox:
+        """
+        Install Debian packages in the sandbox.
+
+        Parameters:
+            packages (list): Packages to install.
+        """
+        command = AptInstallCommand(packages=packages)
+        self.commands.append(command)
+        return self
+    
+    def populate (self, fxn: Function=None) -> Sandbox:
+        """
+        Populate all metadata.
+        """
+        fxn = fxn if fxn is not None else Function()
+        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):
+                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 }
+        return self
+
+    def __upload_file (self, path: Path, fxn: Function) -> str:
+        assert path.is_file(), "Cannot upload file at path {path} because it is not a file"
+        hash = self.__compute_hash(path)
+        try:
+            fxn.client.request(method="HEAD", path=f"/resources/{hash}")
+        except:
+            resource = fxn.client.request(
+                method="POST",
+                path="/resources",
+                body={ "name": hash },
+                response_type=_Resource
+            )
+            with path.open("rb") as f:
+                put(resource.url, data=f).raise_for_status()
+        return hash
+    
+    def __compute_hash (self, path: Path) -> str:
+        hash = sha256()
+        with path.open("rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hash.update(chunk)
+        return hash.hexdigest()
+    
+class _Resource (BaseModel):
+    url: str

fxn/compile/signature.py

@@ -0,0 +1,183 @@
+# 
+#   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

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/services/__init__.py

@@ -1,6 +1,6 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from .user import UserService

fxn/services/prediction.py

@@ -1,6 +1,6 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from dataclasses import asdict, is_dataclass
@@ -16,8 +16,8 @@ from tempfile import gettempdir
 from typing import Any, AsyncIterator
 from urllib.parse import urlparse
 
-from ..client import FunctionClient
 from ..c import Configuration, Predictor, Prediction as CPrediction, Value as CValue, ValueFlags, ValueMap
+from ..client import FunctionClient
 from ..types import Acceleration, Prediction, PredictionResource
 
 Value = ndarray | str | float | int | bool | list[Any] | dict[str, Any] | Image.Image | BytesIO | memoryview
@@ -134,9 +134,10 @@ class PredictionService:
                 "tag": tag,
                 "clientId": client_id,
                 "configurationId": configuration_id,
-            }
+            },
+            response_type=Prediction
         )
-        return Prediction(**prediction)
+        return prediction
 
     def __get_predictor (
         self,

fxn/services/predictor.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from ..client import FunctionClient, FunctionAPIError
@@ -22,8 +22,11 @@ class PredictorService:
             Predictor: Predictor.
         """
         try:
-            predictor = self.client.request(method="GET", path=f"/predictors/{tag}")
-            return Predictor(**predictor)
+            return self.client.request(
+                method="GET",
+                path=f"/predictors/{tag}",
+                response_type=Predictor
+            )
         except FunctionAPIError as error:
             if error.status_code == 404:
                 return None

fxn/services/user.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from ..client import FunctionClient, FunctionAPIError
@@ -19,8 +19,11 @@ class UserService:
             User: User.
         """
         try:
-            user = self.client.request(method="GET", path="/users")
-            return User(**user)
+            return self.client.request(
+                method="GET",
+                path="/users",
+                response_type=User
+            )
         except FunctionAPIError as error:
             if error.status_code == 401:
                 return None

fxn/types/__init__.py

@@ -1,9 +1,9 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from .dtype import Dtype
-from .prediction import Prediction, PredictionResource
-from .predictor import Acceleration, AccessMode, EnumerationMember, Parameter, Predictor, PredictorStatus, Signature
+from .prediction import Acceleration, Prediction, PredictionResource
+from .predictor import AccessMode, EnumerationMember, Parameter, Predictor, PredictorStatus, Signature
 from .user import User

fxn/types/dtype.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from enum import Enum

fxn/types/prediction.py

@@ -1,8 +1,9 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
+from enum import IntFlag
 from pydantic import BaseModel, Field
 from typing import Any
 
@@ -42,4 +43,13 @@ class Prediction (BaseModel):
     latency: float | None = Field(default=None, description="Prediction latency in milliseconds.")
     error: str | None = Field(default=None, description="Prediction error. This is `None` if the prediction completed successfully.")
     logs: str | None = Field(default=None, description="Prediction logs.")
-    created: str = Field(description="Date created.")
+    created: str = Field(description="Date created.")
+
+class Acceleration (IntFlag):
+    """
+    Predictor acceleration.
+    """
+    Auto    = 0,
+    CPU     = 1 << 0,
+    GPU     = 1 << 1,
+    NPU     = 1 << 2

fxn/types/predictor.py

@@ -1,24 +1,15 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from enum import Enum, IntFlag
+from enum import Enum
 from pydantic import AliasChoices, BaseModel, ConfigDict, Field
 from typing import Any
 
 from .dtype import Dtype
 from .user import User
 
-class Acceleration (IntFlag):
-    """
-    Predictor acceleration.
-    """
-    Auto    = 0,
-    CPU     = 1 << 0,
-    GPU     = 1 << 1,
-    NPU     = 1 << 2
-
 class AccessMode (str, Enum):
     """
     Predictor access mode.
@@ -57,7 +48,6 @@ class Parameter (BaseModel):
         optional (bool): Whether the parameter is optional.
         range (tuple): Parameter value range for numeric parameters.
         enumeration (list): Parameter value choices for enumeration parameters.
-        default_value (str | float | int | bool | ndarray | list | dict | PIL.Image | BytesIO): Parameter default value.
         value_schema (dict): Parameter JSON schema. This is only populated for `list` and `dict` parameters.
     """
     name: str = Field(description="Parameter name.")
@@ -66,7 +56,6 @@ class Parameter (BaseModel):
     optional: bool | None = Field(default=None, description="Whether the parameter is optional.")
     range: tuple[float, float] | None = Field(default=None, description="Parameter value range for numeric parameters.")
     enumeration: list[EnumerationMember] | None = Field(default=None, description="Parameter value choices for enumeration parameters.")
-    default_value: str | float | int | bool | list[Any] | dict[str, Any] | None = Field(default=None, description="Parameter default value.", serialization_alias="defaultValue", validation_alias=AliasChoices("default_value", "defaultValue"))
     value_schema: dict[str, Any] | None = Field(default=None, description="Parameter JSON schema. This is only populated for `list` and `dict` parameters.", serialization_alias="schema", validation_alias=AliasChoices("schema", "value_schema"))
     model_config = ConfigDict(arbitrary_types_allowed=True)
 

fxn/types/user.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from pydantic import BaseModel, Field

fxn/version.py

@@ -1,6 +1,6 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.41"
+__version__ = "0.0.42"

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

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fxn
-Version: 0.0.41
+Version: 0.0.42
 Summary: Run prediction functions locally in Python. Register at https://fxn.ai.
 Author-email: "NatML Inc." <hi@fxn.ai>
-License: Apache License
+License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
         

fxn-0.0.42.dist-info/RECORD

@@ -0,0 +1,47 @@
+fxn/__init__.py,sha256=co_h8b85Oz3gyrT8T30RbwFQZ8Zf0i57ynGC2H44VZs,207
+fxn/client.py,sha256=i56oIr4f4ODjKhnD2EugBWQULVubIIFHqqBsoix23xw,1666
+fxn/function.py,sha256=JBZnGaLedgoY-wV5Tg-Rxwpd3tK_ADkD0Qve45NBaA0,1342
+fxn/version.py,sha256=-M_EgT0O4ScSm10y5QibgzW8y3KbHfvkosDKMCfirOQ,95
+fxn/beta/__init__.py,sha256=gKoDhuXtXCjdhUYUqmF0gDPMhJfg3UwFgbvMtRB5ipo,111
+fxn/beta/client.py,sha256=x1AVAz0PlX0Wnemi7KXk5XfC8R6HC7vOQaGUviPJLN8,363
+fxn/beta/prediction.py,sha256=9DTBahNF6m0TicLab2o9e8IKpiSV6K7cUSTYaFju0ZU,356
+fxn/beta/remote.py,sha256=MMFM6QYyxNkpf2czql_JZz9dVbuWHIzhC4mq7pcyPdo,7778
+fxn/c/__init__.py,sha256=NMIduqO_MYtI9jVCu6ZxvbBtYQXoQyNEWblNy3m2UPY,313
+fxn/c/configuration.py,sha256=Jq4kWLu3xb1MWjkfNA4xPr_TykABppbHctUEOHBFdRM,4887
+fxn/c/fxnc.py,sha256=YrvwOlzPmTlSDuz2zmKZfws2WK5BY4YZ62edoplcMJU,1381
+fxn/c/map.py,sha256=47fBJ0Q6uB_xeW3sn9aCLYJ539edg8ff9DU-EIfWRGA,2352
+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/auth.py,sha256=6iGbNbjxfCr8OZT3_neLThXdWeKRBZATwru8vU0XmRw,1688
+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/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
+fxn/lib/macos/arm64/Function.dylib,sha256=ODM3zDbI4Tomx7_QSvnqOE42OBYYblntkSq6gftBP4c,263664
+fxn/lib/macos/x86_64/Function.dylib,sha256=qIu4dhx0Xk5dQHgTnZTcm2IpoMYJwRPmKRi9J-UnkAY,263680
+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/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/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,,