fxn 0.0.28__py3-none-any.whl → 0.0.30__py3-none-any.whl

fxn/cli/predict.py

@@ -22,18 +22,20 @@ def predict (
     raw_outputs: bool = Option(False, "--raw-outputs", help="Output raw Function values instead of converting into plain Python values."),
     context: Context = 0
 ):
-    inputs = { context.args[i].replace("-", ""): _parse_value(context.args[i+1]) for i in range(0, len(context.args), 2) }
-    run_async(_predict_async(tag, inputs, raw_outputs=raw_outputs))
+    run_async(_predict_async(tag, context=context, raw_outputs=raw_outputs))
 
-async def _predict_async (tag: str, inputs: Dict[str, Any], raw_outputs: bool):
+async def _predict_async (tag: str, context: Context, raw_outputs: bool):
     with Progress(
         SpinnerColumn(spinner_name="dots"),
         TextColumn("[progress.description]{task.description}"),
         transient=True
     ) as progress:
         progress.add_task(description="Running Function...", total=None)
+        # Parse inputs
+        inputs = { context.args[i].replace("-", ""): _parse_value(context.args[i+1]) for i in range(0, len(context.args), 2) }
+        # Stream
         fxn = Function(get_access_key())
-        async for prediction in fxn.predictions.stream(tag, inputs=inputs, raw_outputs=raw_outputs, return_binary_path=True):
+        async for prediction in fxn.predictions.stream(tag, inputs=inputs, raw_outputs=raw_outputs, return_binary_path=True, verbose=True):
             # Parse results
             images = [value for value in prediction.results or [] if isinstance(value, Image.Image)]
             prediction.results = [_serialize_value(value) for value in prediction.results] if prediction.results is not None else None

fxn/services/prediction/fxnc.py

@@ -129,12 +129,9 @@ def load_fxnc (path: Path) -> CDLL:
     # FXNConfigurationSetToken
     fxnc.FXNConfigurationSetToken.argtypes = [FXNConfigurationRef, c_char_p]
     fxnc.FXNConfigurationSetToken.restype = FXNStatus
-    # FXNConfigurationGetResource
-    fxnc.FXNConfigurationGetResource.argtypes = [FXNConfigurationRef, c_char_p, c_char_p, c_int32]
-    fxnc.FXNConfigurationGetResource.restype = FXNStatus
-    # FXNConfigurationSetResource
-    fxnc.FXNConfigurationSetResource.argtypes = [FXNConfigurationRef, c_char_p, c_char_p, c_char_p]
-    fxnc.FXNConfigurationSetResource.restype = FXNStatus
+    # FXNConfigurationAddResource
+    fxnc.FXNConfigurationAddResource.argtypes = [FXNConfigurationRef, c_char_p, c_char_p]
+    fxnc.FXNConfigurationAddResource.restype = FXNStatus
     # FXNConfigurationGetAcceleration
     fxnc.FXNConfigurationGetAcceleration.argtypes = [FXNConfigurationRef, POINTER(FXNAcceleration)]
     fxnc.FXNConfigurationGetAcceleration.restype = FXNStatus
@@ -186,11 +183,15 @@ def to_fxn_value ( # DEPLOY
     *,
     copy: bool=False
 ) -> type[FXNValueRef]:
-    result = FXNValue()
+    result = FXNValueRef()
     if result is None:
         fxnc.FXNValueCreateNull(byref(result))
-    elif isinstance(input, (int, float)):
-        return to_fxn_value(fxnc, array(value))
+    elif isinstance(value, bool):
+        return to_fxn_value(fxnc, array(value, dtype="bool"))
+    elif isinstance(value, int):
+        return to_fxn_value(fxnc, array(value, dtype="int32"))
+    elif isinstance(value, float):
+        return to_fxn_value(fxnc, array(value, dtype="float32"))
     elif isinstance(value, ndarray):
         dtype = _NP_TO_FXN_DTYPE.get(value.dtype)
         assert dtype is not None, f"Failed to convert numpy array to Function value because array data type is not supported: {value.dtype}"

fxn/services/prediction/service.py

@@ -7,25 +7,26 @@ from aiohttp import ClientSession
 from ctypes import byref, c_double, c_int32, create_string_buffer
 from dataclasses import asdict, is_dataclass
 from datetime import datetime, timezone
-from filetype import guess_mime
 from io import BytesIO
 from json import dumps, loads
+from magika import Magika
 from numpy import array, float32, frombuffer, int32, ndarray
 from numpy.typing import NDArray
 from pathlib import Path
 from PIL import Image
-from platform import system
+from platform import machine, system
 from pydantic import BaseModel
 from requests import get, post
 from tempfile import NamedTemporaryFile
 from typing import Any, AsyncIterator, Dict, List, Union
 from uuid import uuid4
+from urllib.parse import urlparse
 from urllib.request import urlopen
 
 from ...graph import GraphClient
-from ...types import Dtype, PredictorType, Prediction, Value, UploadType
+from ...types import Dtype, PredictorType, Prediction, PredictionResource, Value, UploadType
 from ..storage import StorageService
-from .fxnc import to_fxn_value, to_py_value, FXNPredictorRef, FXNProfileRef, FXNStatus, FXNValueRef, FXNValueMapRef
+from .fxnc import load_fxnc, to_fxn_value, to_py_value, FXNConfigurationRef, FXNPredictorRef, FXNProfileRef, FXNStatus, FXNValueRef, FXNValueMapRef
 
 class PredictionService:
 
@@ -39,10 +40,11 @@ class PredictionService:
         self,
         tag: str,
         *,
-        inputs: Dict[str, Union[ndarray, str, float, int, bool, List, Dict[str, Any], Path, Image.Image, Value]] = {},
+        inputs: Dict[str, Union[ndarray, str, float, int, bool, List, Dict[str, Any], Path, Image.Image, Value]] = None,
         raw_outputs: bool=False,
         return_binary_path: bool=True,
         data_url_limit: int=None,
+        verbose: bool=False
     ) -> Prediction:
         """
         Create a prediction.
@@ -53,41 +55,45 @@ class PredictionService:
             raw_outputs (bool): Skip converting output values into Pythonic types. This only applies to `CLOUD` predictions.
             return_binary_path (bool): Write binary values to file and return a `Path` instead of returning `BytesIO` instance.
             data_url_limit (int): Return a data URL if a given output value is smaller than this size in bytes. This only applies to `CLOUD` predictions.
+            verbose (bool): Use verbose logging.
 
         Returns:
             Prediction: Created prediction.
         """
         # Check if cached
         if tag in self.__cache:
-            return self.__predict(tag, inputs)
+            return self.__predict(tag=tag, predictor=self.__cache[tag], inputs=inputs)
         # Serialize inputs
         key = uuid4().hex
-        inputs = { name: self.to_value(value, name, key=key).model_dump(mode="json") for name, value in inputs.items() }
+        values = { name: self.to_value(value, name, key=key).model_dump(mode="json") for name, value in inputs.items() } if inputs is not None else { }
         # Query
-        response = post(
+        response = post( # INCOMPLETE # Configuration token
             f"{self.client.api_url}/predict/{tag}?rawOutputs=true&dataUrlLimit={data_url_limit}",
-            json=inputs,
+            json=values,
             headers={
                 "Authorization": f"Bearer {self.client.access_key}",
-                "fxn-client": self.__get_client_id()
+                "fxn-client": self.__get_client_id(),
+                "fxn-configuration-token": ""
             }
         )
         # Check
         prediction = response.json()
         try:
             response.raise_for_status()
-        except:
-            raise RuntimeError(prediction.get("error"))
+        except Exception as ex:
+            error = prediction["errors"][0]["message"] if "errors" in prediction else str(ex)
+            raise RuntimeError(error)
         # Parse prediction
-        prediction = Prediction(**prediction)
-        prediction.results = [Value(**value) for value in prediction.results] if prediction.results is not None else None
-        prediction.results = [self.to_object(value, return_binary_path=return_binary_path) for value in prediction.results] if prediction.results is not None and not raw_outputs else prediction.results
-        # Create edge outputs
-
+        prediction = self.__parse_prediction(prediction, raw_outputs=raw_outputs, return_binary_path=return_binary_path)
+        # Create edge prediction
+        if prediction.type == PredictorType.Edge:
+            predictor = self.__load(prediction, verbose=verbose)
+            self.__cache[tag] = predictor
+            prediction = self.__predict(tag=tag, predictor=predictor, inputs=inputs) if inputs is not None else prediction
         # Return
         return prediction
     
-    async def stream (
+    async def stream ( # INCOMPLETE # Add edge prediction support
         self,
         tag: str,
         *,
@@ -95,6 +101,7 @@ class PredictionService:
         raw_outputs: bool=False,
         return_binary_path: bool=True,
         data_url_limit: int=None,
+        verbose: bool=False
     ) -> AsyncIterator[Prediction]:
         """
         Create a streaming prediction.
@@ -107,6 +114,7 @@ class PredictionService:
             raw_outputs (bool): Skip converting output values into Pythonic types. This only applies to `CLOUD` predictions.
             return_binary_path (bool): Write binary values to file and return a `Path` instead of returning `BytesIO` instance.
             data_url_limit (int): Return a data URL if a given output value is smaller than this size in bytes. This only applies to `CLOUD` predictions.
+            verbose (bool): Use verbose logging.
 
         Returns:
             Prediction: Created prediction.
@@ -119,19 +127,26 @@ class PredictionService:
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self.client.access_key}",
-            "fxn-client": self.__get_client_id()
+            "fxn-client": self.__get_client_id(),
+            "fxn-configuration-token": ""
         }
         async with ClientSession(headers=headers) as session:
             async with session.post(url, data=dumps(inputs)) as response:
                 async for chunk in response.content.iter_any():
                     prediction = loads(chunk)
                     # Check status
-                    if response.status >= 400:
-                        raise RuntimeError(prediction.get("error"))
+                    try:
+                        response.raise_for_status()
+                    except Exception as ex:
+                        error = prediction["errors"][0]["message"] if "errors" in prediction else str(ex)
+                        raise RuntimeError(error)
                     # Parse prediction
-                    prediction = Prediction(**prediction)
-                    prediction.results = [Value(**value) for value in prediction.results] if prediction.results is not None else None
-                    prediction.results = [self.to_object(value, return_binary_path=return_binary_path) for value in prediction.results] if prediction.results is not None and not raw_outputs else prediction.results
+                    prediction = self.__parse_prediction(prediction, raw_outputs=raw_outputs, return_binary_path=return_binary_path)
+                    # Create edge prediction
+                    if prediction.type == PredictorType.Edge:
+                        predictor = self.__load(prediction, verbose=verbose)
+                        self.__cache[tag] = predictor
+                        prediction = self.__predict(tag=tag, predictor=predictor, inputs=inputs) if inputs is not None else prediction
                     # Yield
                     yield prediction
 
@@ -263,7 +278,39 @@ class PredictionService:
         # Unsupported
         raise RuntimeError(f"Cannot create Function value '{name}' for object {object} of type {type(object)}")
 
-    def __predict (self, tag: str, inputs: Dict[str, Any]) -> Prediction: # DEPLOY
+    def __load (self, prediction: Prediction, *, verbose: bool=False):
+        # Load fxnc
+        if self.__fxnc is None:
+            fxnc_resource = next(x for x in prediction.resources if x.type == "fxn")
+            fxnc_path = self.__get_resource_path(fxnc_resource)
+            self.__fxnc = load_fxnc(fxnc_path)
+        # Load predictor
+        fxnc = self.__fxnc
+        configuration = FXNConfigurationRef()
+        try:
+            # Create configuration
+            status = fxnc.FXNConfigurationCreate(byref(configuration))
+            assert status.value == FXNStatus.OK, f"Failed to create prediction configuration for tag {prediction.tag} with status: {status.value}"
+            # Populate
+            status = fxnc.FXNConfigurationSetToken(configuration, prediction.configuration.encode())
+            assert status.value == FXNStatus.OK, f"Failed to set prediction configuration token for tag {prediction.tag} with status: {status.value}"
+            # Add resources
+            for resource in prediction.resources:
+                if resource.type == "fxn":
+                    continue
+                path = self.__get_resource_path(resource, verbose=verbose)
+                status = fxnc.FXNConfigurationAddResource(configuration, resource.type.encode(), str(path).encode())
+                assert status.value == FXNStatus.OK, f"Failed to set prediction configuration resource with type {resource.type} for tag {prediction.tag} with status: {status.value}"
+            # Create predictor
+            predictor = FXNPredictorRef()
+            status = fxnc.FXNPredictorCreate(prediction.tag.encode(), configuration, byref(predictor))
+            assert status.value == FXNStatus.OK, f"Failed to create prediction for tag {prediction.tag} with status: {status.value}"
+            # Return
+            return predictor
+        finally:
+            fxnc.FXNConfigurationRelease(configuration)
+
+    def __predict (self, *, tag: str, predictor, inputs: Dict[str, Any]) -> Prediction: # DEPLOY
         fxnc = self.__fxnc
         predictor = self.__cache[tag]
         profile = FXNProfileRef()
@@ -288,14 +335,15 @@ class PredictionService:
             fxnc.FXNProfileGetLatency(profile, byref(latency))
             fxnc.FXNProfileGetError(profile, error, len(error))
             fxnc.FXNProfileGetLogLength(profile, byref(log_length))
-            id = id.decode("utf-8")
+            id = id.value.decode("utf-8")
             latency = latency.value
-            error = error.decode("utf-8")
+            error = error.value.decode("utf-8")
             # Marshal logs
             logs = create_string_buffer(log_length.value + 1)
             fxnc.FXNProfileGetLogs(profile, logs, len(logs))
+            logs = logs.value.decode("utf-8")
             # Marshal outputs
-            results = { }
+            results = []
             output_count = c_int32()
             fxnc.FXNValueMapGetSize(output_map, byref(output_count))
             for idx in range(output_count.value):
@@ -303,38 +351,51 @@ class PredictionService:
                 value = FXNValueRef()
                 fxnc.FXNValueMapGetKey(output_map, idx, name, len(name))
                 fxnc.FXNValueMapGetValue(output_map, name, byref(value))
-                name = name.decode("utf-8")
+                name = name.value.decode("utf-8")
                 value = to_py_value(fxnc, value)
-                results[name] = value
+                results.append(value)
             # Return
             return Prediction(
                 id=id,
                 tag=tag,
                 type=PredictorType.Edge,
-                results=results,
+                results=results if not error else None,
                 latency=latency,
                 error=error,
                 logs=logs,
                 created=datetime.now(timezone.utc).isoformat()
             )
         finally:
-            fxnc.FXNReleaseProfile(profile)
-            fxnc.FXNReleaseValueMap(input_map)
-            fxnc.FXNReleaseValueMap(output_map)
+            fxnc.FXNProfileRelease(profile)
+            fxnc.FXNValueMapRelease(input_map)
+            fxnc.FXNValueMapRelease(output_map)
+
+    def __parse_prediction (
+            self,
+            data: Dict[str, Any],
+            *,
+            raw_outputs: bool,
+            return_binary_path: bool
+        ) -> Prediction:
+        prediction = Prediction(**data)
+        prediction.results = [Value(**value) for value in prediction.results] if prediction.results is not None else None
+        prediction.results = [self.to_object(value, return_binary_path=return_binary_path) for value in prediction.results] if prediction.results is not None and not raw_outputs else prediction.results
+        return prediction
 
     def __get_data_dtype (self, data: Union[Path, BytesIO]) -> Dtype:
-        mime = guess_mime(str(data) if isinstance(data, Path) else data)
-        if not mime:
-            return Dtype.binary
-        if mime.startswith("image"):
+        magika = Magika()
+        result = magika.identify_bytes(data.getvalue()) if isinstance(data, BytesIO) else magika.identify_path(data)
+        group = result.output.group
+        if group == "image":
             return Dtype.image
-        if mime.startswith("video"):
-            return Dtype.video
-        if mime.startswith("audio"):
+        elif group == "audio":
             return Dtype.audio
-        if isinstance(data, Path) and data.suffix in [".obj", ".gltf", ".glb", ".fbx", ".usd", ".usdz", ".blend"]:
+        elif group == "video":
+            return Dtype.video
+        elif isinstance(data, Path) and data.suffix in [".obj", ".gltf", ".glb", ".fbx", ".usd", ".usdz", ".blend"]:
             return Dtype._3d
-        return Dtype.binary
+        else:
+            return Dtype.binary
 
     def __download_value_data (self, url: str) -> BytesIO:
         if url.startswith("data:"):
@@ -344,6 +405,19 @@ class PredictionService:
         result = BytesIO(response.content)
         return result
     
+    def __get_resource_path (self, resource: PredictionResource, *, verbose: bool=False) -> Path: # INCOMPLETE # Verbose
+        cache_dir = Path.home() / ".fxn" / "cache"
+        cache_dir.mkdir(exist_ok=True)
+        res_name = Path(urlparse(resource.url).path).name
+        res_path = cache_dir / res_name
+        if res_path.exists():
+            return res_path
+        req = get(resource.url)
+        req.raise_for_status()
+        with open(res_path, "wb") as f:
+            f.write(req.content)
+        return res_path
+    
     @classmethod
     def __try_ensure_serializable (cls, object: Any) -> Any:
         if object is None:
@@ -362,11 +436,11 @@ class PredictionService:
     def __get_client_id (self) -> str:
         id = system()
         if id == "Darwin":
-            return "macos"
+            return f"macos:{machine()}"
         if id == "Linux":
-            return "linux"
+            return f"linux:{machine()}"
         if id == "Windows":
-            return "windows"
+            return f"windows:{machine()}"
         raise RuntimeError(f"Function cannot make predictions on the {id} platform")
     
 

fxn/services/storage.py

@@ -4,8 +4,8 @@
 #
 
 from base64 import b64encode
-from filetype import guess_mime
 from io import BytesIO
+from magika import Magika
 from pathlib import Path
 from requests import put
 from rich.progress import open as open_progress, wrap_file
@@ -87,7 +87,7 @@ class StorageService:
         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"
+        mime = self.__infer_mime(file)
         if file.stat().st_size < (data_url_limit or 0):
             with open(file, mode="rb") as f:
                 buffer = BytesIO(f.read())
@@ -114,7 +114,7 @@ class StorageService:
         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"
+        mime = self.__infer_mime(file)
         size = file.getbuffer().nbytes
         if size < (data_url_limit or 0):
             return self.__create_data_url(file, mime=mime)
@@ -136,4 +136,25 @@ class StorageService:
         parsed_url = urlparse(url)
         parsed_url = parsed_url._replace(netloc="cdn.fxn.ai", query="")
         url = urlunparse(parsed_url)
-        return url
+        return url
+    
+    def __infer_mime (self, file: Union[str, Path, BytesIO]) -> str:
+        MAGIC_TO_MIME = {
+            b"\x00\x61\x73\x6d": "application/wasm"
+        }
+        # Read magic
+        file = Path(file) if isinstance(file, str) else file
+        if isinstance(file, Path):
+            with open(file, "rb") as f:
+                magic = f.read(4)
+        elif isinstance(file, BytesIO):
+            magic = file.getvalue()[:4]
+        # Check known mime
+        mime = MAGIC_TO_MIME.get(magic)
+        # Infer
+        if mime is None:
+            magika = Magika()
+            result = magika.identify_bytes(file.getvalue()) if isinstance(file, BytesIO) else magika.identify_path(file)
+            mime = result.output.mime_type
+        # Return
+        return mime

fxn/version.py

@@ -3,4 +3,4 @@
 #   Copyright © 2024 NatML Inc. All Rights Reserved.
 #
 
-__version__ = "0.0.28"
+__version__ = "0.0.30"

{fxn-0.0.28.dist-info → fxn-0.0.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fxn
-Version: 0.0.28
+Version: 0.0.30
 Summary: Run on-device and cloud AI prediction functions in Python. Register at https://fxn.ai.
 Home-page: https://fxn.ai
 Author: NatML Inc.
@@ -14,11 +14,11 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
-Requires-Dist: filetype
+Requires-Dist: magika
 Requires-Dist: numpy
 Requires-Dist: pillow
 Requires-Dist: pydantic >=2.0
@@ -40,7 +40,8 @@ Function is distributed on PyPi. This distribution contains both the Python clie
 pip install --upgrade fxn
 ```
 
-> Note that Function requires Python 3.9+
+> [!NOTE]
+> Function requires Python 3.9+
 
 ## Making a Prediction
 Let's run the [`@samplefxn/stable-diffusion`](https://fxn.ai/@samplefxn/stable-diffusion) predictor which accepts a text `prompt` and generates a corresponding image.
@@ -89,3 +90,4 @@ ___
 
 Function is a product of [NatML Inc](https://github.com/natmlx).
 
+

{fxn-0.0.28.dist-info → fxn-0.0.30.dist-info}/RECORD

@@ -1,23 +1,23 @@
 fxn/__init__.py,sha256=tWk0-aCNHX_yCS-Dg90pYnniNka9MWFoNMk6xY7u4nI,157
 fxn/function.py,sha256=H2oviHGWfal2O7d386R8BZDMUZYdfOuMB7OijiPKo54,1632
 fxn/magic.py,sha256=PQmXhO9EvJ5EZylioV-6gsCvqhVRYscKBSOBoN4VhTk,1041
-fxn/version.py,sha256=TZq06bXr0nOqLaHEQ1Zk4Wvz9PT6UQyaeN3bcjsMG4s,95
+fxn/version.py,sha256=A2_mJosEtqos00n0S2q_ctD70NhvQ0jouy6KHj5ttxI,95
 fxn/cli/__init__.py,sha256=gwMG0euV0qCe_vSvJLqBd6VWoQ99T-y4xQXeA4m4Wf0,1492
 fxn/cli/auth.py,sha256=MpHxhqPjGY92TmaTh3o58i868Cv-6Xgf13Si1NFluMg,1677
 fxn/cli/env.py,sha256=shqoP4tUiXdOoil73oiUYpqGeVcR119HPYFKgnoF894,1553
 fxn/cli/misc.py,sha256=J3WgNjrxRzm-_iKC3Cp0o4VHeBYBQ1ta_t2-ozD9roo,662
-fxn/cli/predict.py,sha256=borclznKdvOTYnszHM9lt3HdbNbMJg4C_ltZ0xTyoCA,3241
+fxn/cli/predict.py,sha256=-2PP11XSa8BRVt_ONoRsLXQI1nIX9luPmWeDCadrWOU,3302
 fxn/cli/predictors.py,sha256=Fg1yFvPgVnLORnQ3K_EWnGYw_lpkjTOA2l4W2wbXr08,4310
 fxn/graph/__init__.py,sha256=rJIDBhYg5jcrWO4hT4-CpwPq6dSgmLTEHCfUYTLpVaI,103
 fxn/graph/client.py,sha256=TRTgPatHq0nn-IkarBF93jEJ9-xltq-V9JJFIfHvqY4,1215
 fxn/services/__init__.py,sha256=OTBRL_wH94hc_scZgRd42VrJQfldNLjv4APN4YaWBAw,366
 fxn/services/environment.py,sha256=-K84dJhlQ_R13CPCqBMngdxSPP2jsgtNc_wBYx6dxjU,3716
 fxn/services/predictor.py,sha256=KtzckP0xsy6uoGATww4AbBQbEC9s2W6MDNrJFJx7rA8,7880
-fxn/services/storage.py,sha256=1aGxDLikA09d4TwrJFX2ezOOiy_SQcU0x1DiosB1dz4,4797
+fxn/services/storage.py,sha256=MY4in8XXVHDIpp8f928PFdujwegESb6m1zzop6d-z58,5517
 fxn/services/user.py,sha256=z7mencF-muknruaUuoleu6JoL-QsPJcrJ6ONT_6U7fk,1219
 fxn/services/prediction/__init__.py,sha256=TPox_z58SRjIvziCt1UnLNN1O23n_iF6HcmI0p9hwpQ,129
-fxn/services/prediction/fxnc.py,sha256=pirm4bGTDLdO8cpCp-vgx2CYl4Plq545K72-doj-0R4,11668
-fxn/services/prediction/service.py,sha256=NT7U3gFuzefKZuAZOH-4n_Y5f2J4DzpbVZen9go6XB0,16243
+fxn/services/prediction/fxnc.py,sha256=UsU95dWaRoyxMEEKYjh5b4Sa0bspUn7tXdwNu9ug6fc,11673
+fxn/services/prediction/service.py,sha256=-p-J5LOX18EQcAO316C0DGZw6YS9Kvjc5Y7VomqaNKs,20333
 fxn/types/__init__.py,sha256=jHLpQnvUKGQujVPK3li1rIkANBBvw6l_EznzIsfoD88,438
 fxn/types/dtype.py,sha256=YpTnIG-yzrQwda27GzfGZcel-zF3gOMMoHhcWD915BY,617
 fxn/types/environment.py,sha256=FbmfGjSb5yYMT9IyDj8zNUpsoP3RbzqM6tK8gn2TfDs,394
@@ -28,9 +28,9 @@ fxn/types/storage.py,sha256=AtVKR3CtHzvSWLiJS_bbUyIA2Of_IKZVeL5_1PqqrQ0,228
 fxn/types/tag.py,sha256=hWzSDCo8VjRHjS5ZLuFi3xVo8cuCNaNeULQ2mHEuwzM,707
 fxn/types/user.py,sha256=_hc1YQh0WydniAurywA70EDs4VCY5rnGRYSiRc97Ab0,150
 fxn/types/value.py,sha256=_Euyb3ffydKV1Q68Mf2G9mz7gKD5NzFap-aX1NEuNuY,767
-fxn-0.0.28.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fxn-0.0.28.dist-info/METADATA,sha256=kqNpoIz4ST1-bqKighHnCBWdN0tKrui9fU0z19F7tk8,3341
-fxn-0.0.28.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fxn-0.0.28.dist-info/entry_points.txt,sha256=QBwKIRed76CRY98VYQYrQDVEBZtJugxJJmBpilxuios,46
-fxn-0.0.28.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
-fxn-0.0.28.dist-info/RECORD,,
+fxn-0.0.30.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fxn-0.0.30.dist-info/METADATA,sha256=0gDRWpFCUFnqGqMVveI9E7pf5YQEZYO54gG1vBKdDmc,3340
+fxn-0.0.30.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fxn-0.0.30.dist-info/entry_points.txt,sha256=QBwKIRed76CRY98VYQYrQDVEBZtJugxJJmBpilxuios,46
+fxn-0.0.30.dist-info/top_level.txt,sha256=1ULIEGrnMlhId8nYAkjmRn9g3KEFuHKboq193SEKQkA,4
+fxn-0.0.30.dist-info/RECORD,,