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

fxn/__init__.py

@@ -1,8 +1,10 @@
 # 
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
+from .client import FunctionAPIError
+from .compile import *
 from .function import Function
 from .types import *
 from .version import *

fxn/beta/__init__.py

@@ -0,0 +1,6 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from .remote import RemoteAcceleration

fxn/beta/client.py

@@ -0,0 +1,16 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from ..client import FunctionClient
+from .prediction import PredictionService
+
+class BetaClient:
+    """
+    Client for incubating features.
+    """
+    predictions: PredictionService
+    
+    def __init__ (self, client: FunctionClient):
+        self.predictions = PredictionService(client)

fxn/beta/prediction.py

@@ -0,0 +1,16 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from ..client import FunctionClient
+from .remote import RemotePredictionService
+
+class PredictionService:
+    """
+    Make predictions.
+    """
+    remote: RemotePredictionService
+
+    def __init__ (self, client: FunctionClient):
+        self.remote = RemotePredictionService(client)

fxn/beta/remote.py

@@ -0,0 +1,207 @@
+# 
+#   Function
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
+#
+
+from __future__ import annotations
+from base64 import b64encode
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+from io import BytesIO
+from json import dumps, loads
+from numpy import array, frombuffer, ndarray
+from PIL import Image
+from pydantic import BaseModel, Field
+from requests import get, put
+from typing import Any
+from urllib.request import urlopen
+
+from ..c import Configuration
+from ..client import FunctionClient
+from ..services import Value
+from ..types import Dtype, Prediction
+
+class RemoteAcceleration (str, Enum):
+    """
+    Remote acceleration.
+    """
+    Auto = "auto"
+    CPU = "cpu"
+    A40 = "a40"
+    A100 = "a100"
+
+class RemotePredictionService:
+    """
+    Make remote predictions.
+    """
+
+    def __init__ (self, client: FunctionClient):
+        self.client = client
+
+    def create (
+        self,
+        tag: str,
+        *,
+        inputs: dict[str, Value],
+        acceleration: RemoteAcceleration=RemoteAcceleration.Auto
+    ) -> Prediction:
+        """
+        Create a remote prediction.
+
+        Parameters:
+            tag (str): Predictor tag.
+            inputs (dict): Input values.
+            acceleration (RemoteAcceleration): Prediction acceleration.
+
+        Returns:
+            Prediction: Created prediction.
+        """
+        input_map = { name: self.__to_value(value, name=name).model_dump(mode="json") for name, value in inputs.items() }
+        prediction = self.client.request(
+            method="POST",
+            path="/predictions/remote",
+            body={
+                "tag": tag,
+                "inputs": input_map,
+                "acceleration": acceleration,
+                "clientId": Configuration.get_client_id()
+            },
+            response_type=RemotePrediction
+        )
+        results = list(map(self.__to_object, prediction.results)) if prediction.results is not None else None
+        prediction = Prediction(**{ **prediction.model_dump(), "results": results })
+        return prediction
+
+    def __to_value (
+        self,
+        object: Value,
+        *,
+        name: str,
+        max_data_url_size: int=4 * 1024 * 1024
+    ) -> RemoteValue:
+        object = self.__try_ensure_serializable(object)
+        if object is None:
+            return RemoteValue(data=None, type=Dtype.null)
+        elif isinstance(object, float):
+            object = array(object, dtype=Dtype.float32)
+            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(object, bool):
+            object = array(object, dtype=Dtype.bool)
+            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(object, int):
+            object = array(object, dtype=Dtype.int32)
+            return self.__to_value(object, name=name, max_data_url_size=max_data_url_size)
+        elif isinstance(object, ndarray):
+            buffer = BytesIO(object.tobytes())
+            data = self.__upload(buffer, name=name, max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=object.dtype.name, shape=list(object.shape))
+        elif isinstance(object, str):
+            buffer = BytesIO(object.encode())
+            data = self.__upload(buffer, name=name, mime="text/plain", max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=Dtype.string)
+        elif isinstance(object, list):
+            buffer = BytesIO(dumps(object).encode())
+            data = self.__upload(buffer, name=name, mime="application/json", max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=Dtype.list)
+        elif isinstance(object, dict):
+            buffer = BytesIO(dumps(object).encode())
+            data = self.__upload(buffer, name=name, mime="application/json", max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=Dtype.dict)
+        elif isinstance(object, Image.Image):
+            buffer = BytesIO()
+            format = "PNG" if object.mode == "RGBA" else "JPEG"
+            mime = f"image/{format.lower()}"
+            object.save(buffer, format=format)
+            data = self.__upload(buffer, name=name, mime=mime, max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=Dtype.image)
+        elif isinstance(object, BytesIO):
+            data = self.__upload(object, name=name, max_data_url_size=max_data_url_size)
+            return RemoteValue(data=data, type=Dtype.binary)
+        else:
+            raise ValueError(f"Failed to serialize value '{object}' of type `{type(object)}` because it is not supported")
+
+    def __to_object (self, value: RemoteValue) -> Value:
+        if value.type == Dtype.null:
+            return None
+        buffer = self.__download(value.data)
+        if value.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 value.shape is not None, "Array value must have a shape specified"
+            array = frombuffer(buffer.getbuffer(), dtype=value.type).reshape(value.shape)
+            return array if len(value.shape) > 0 else array.item()
+        elif value.type == Dtype.string:
+            return buffer.getvalue().decode("utf-8")
+        elif value.type in [Dtype.list, Dtype.dict]:
+            return loads(buffer.getvalue().decode("utf-8"))
+        elif value.type == Dtype.image:
+            return Image.open(buffer)
+        elif value.type == Dtype.binary:
+            return buffer
+        else:
+            raise ValueError(f"Failed to deserialize value with type `{value.type}` because it is not supported")
+
+    def __upload (
+        self,
+        data: BytesIO,
+        *,
+        name: str,
+        mime: str="application/octet-stream",
+        max_data_url_size: int=4 * 1024 * 1024
+    ) -> str:
+        if data.getbuffer().nbytes <= max_data_url_size:
+            encoded_data = b64encode(data.getvalue()).decode("ascii")
+            return f"data:{mime};base64,{encoded_data}"
+        value = self.client.request(
+            method="POST",
+            path="/values",
+            body={ "name": name },
+            response_type=CreateValueResponse
+        )
+        put(
+            value.upload_url,
+            data=data,
+            headers={ "Content-Type": mime }
+        ).raise_for_status()
+        return value.download_url
+
+    def __download (self, url: str) -> BytesIO:
+        if url.startswith("data:"):
+            with urlopen(url) as response:
+                return BytesIO(response.read())
+        response = get(url)
+        response.raise_for_status()
+        result = BytesIO(response.content)
+        return result
+
+    @classmethod
+    def __try_ensure_serializable (cls, object: Any) -> Any:
+        if object is None:
+            return object
+        if isinstance(object, list):
+            return [cls.__try_ensure_serializable(x) for x in object]
+        if is_dataclass(object) and not isinstance(object, type):
+            return asdict(object)
+        if isinstance(object, BaseModel):
+            return object.model_dump(mode="json", by_alias=True)
+        return object
+
+class RemoteValue (BaseModel):
+    data: str | None
+    type: Dtype
+    shape: list[int] | None = None
+
+class RemotePrediction (BaseModel):
+    id: str
+    tag: str
+    created: str
+    results: list[RemoteValue] | None
+    latency: float | None
+    error: str | None
+    logs: str | None
+
+class CreateValueResponse (BaseModel):
+    upload_url: str = Field(validation_alias="uploadUrl")
+    download_url: str = Field(validation_alias="downloadUrl")

fxn/c/__init__.py

@@ -1,16 +1,13 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 # https://github.com/fxnai/fxnc
 
-from .status import FXNStatus
-from .value import FXNDtype, FXNValueRef, FXNValueFlags
-from .map import FXNValueMapRef
-from .configuration import FXNConfigurationRef, FXNAcceleration
-from .prediction import FXNPredictionRef
-from .stream import FXNPredictionStreamRef
-from .predictor import FXNPredictorRef
-
-from .fxnc import load_fxnc
+from .configuration import Configuration
+from .map import ValueMap
+from .prediction import Prediction
+from .predictor import Predictor
+from .stream import PredictionStream
+from .value import Value, ValueFlags

fxn/c/configuration.py

@@ -1,60 +1,118 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import c_char_p, c_int, c_int32, c_void_p, CDLL, POINTER, Structure
-from .status import FXNStatus
-
-class FXNAcceleration(c_int):
-    FXN_ACCELERATION_DEFAULT = 0
-    FXN_ACCELERATION_CPU = 1 << 0
-    FXN_ACCELERATION_GPU = 1 << 1
-    FXN_ACCELERATION_NPU = 1 << 2
-
-class FXNConfiguration(Structure): pass
-
-FXNConfigurationRef = POINTER(FXNConfiguration)
-
-def _register_fxn_configuration (fxnc: CDLL) -> CDLL:
-    # FXNConfigurationGetUniqueID
-    fxnc.FXNConfigurationGetUniqueID.argtypes = [c_char_p, c_int32]
-    fxnc.FXNConfigurationGetUniqueID.restype = FXNStatus
-    # FXNConfigurationGetClientID
-    fxnc.FXNConfigurationGetClientID.argtypes = [c_char_p, c_int32]
-    fxnc.FXNConfigurationGetClientID.restype = FXNStatus
-    # FXNConfigurationCreate
-    fxnc.FXNConfigurationCreate.argtypes = [POINTER(FXNConfigurationRef)]
-    fxnc.FXNConfigurationCreate.restype = FXNStatus
-    # FXNConfigurationRelease
-    fxnc.FXNConfigurationRelease.argtypes = [FXNConfigurationRef]
-    fxnc.FXNConfigurationRelease.restype = FXNStatus
-    # FXNConfigurationGetTag
-    fxnc.FXNConfigurationGetTag.argtypes = [FXNConfigurationRef, c_char_p, c_int32]
-    fxnc.FXNConfigurationRelease.restype = FXNStatus
-    # FXNConfigurationSetTag
-    fxnc.FXNConfigurationSetTag.argtypes = [FXNConfigurationRef, c_char_p]
-    fxnc.FXNConfigurationSetTag.restype = FXNStatus
-    # FXNConfigurationGetToken
-    fxnc.FXNConfigurationGetToken.argtypes = [FXNConfigurationRef, c_char_p, c_int32]
-    fxnc.FXNConfigurationGetToken.restype = FXNStatus
-    # FXNConfigurationSetToken
-    fxnc.FXNConfigurationSetToken.argtypes = [FXNConfigurationRef, c_char_p]
-    fxnc.FXNConfigurationSetToken.restype = FXNStatus
-    # FXNConfigurationGetAcceleration
-    fxnc.FXNConfigurationGetAcceleration.argtypes = [FXNConfigurationRef, POINTER(FXNAcceleration)]
-    fxnc.FXNConfigurationGetAcceleration.restype = FXNStatus
-    # FXNConfigurationSetAcceleration
-    fxnc.FXNConfigurationSetAcceleration.argtypes = [FXNConfigurationRef, FXNAcceleration]
-    fxnc.FXNConfigurationSetAcceleration.restype = FXNStatus
-    # FXNConfigurationGetDevice
-    fxnc.FXNConfigurationGetDevice.argtypes = [FXNConfigurationRef, POINTER(c_void_p)]
-    fxnc.FXNConfigurationGetDevice.restype = FXNStatus
-    # FXNConfigurationSetDevice
-    fxnc.FXNConfigurationSetDevice.argtypes = [FXNConfigurationRef, c_void_p]
-    fxnc.FXNConfigurationSetDevice.restype = FXNStatus
-    # FXNConfigurationAddResource
-    fxnc.FXNConfigurationAddResource.argtypes = [FXNConfigurationRef, c_char_p, c_char_p]
-    fxnc.FXNConfigurationAddResource.restype = FXNStatus
-    # Return
-    return fxnc
+from ctypes import byref, c_int, c_void_p, create_string_buffer
+from pathlib import Path
+from typing import final
+
+from ..types import Acceleration
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+
+@final
+class Configuration:
+
+    def __init__ (self):
+        configuration = c_void_p()
+        status = get_fxnc().FXNConfigurationCreate(byref(configuration))
+        if status == FXNStatus.OK:
+            self.__configuration = configuration
+        else:
+            raise RuntimeError(f"Failed to create configuration with error: {status_to_error(status)}")
+
+    @property
+    def tag (self) -> str:
+        buffer = create_string_buffer(2048)
+        status = get_fxnc().FXNConfigurationGetTag(self.__configuration, buffer, len(buffer))
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to get configuration tag with error: {status_to_error(status)}")
+        tag = buffer.value.decode("utf-8")
+        return tag if tag else None
+
+    @tag.setter
+    def tag (self, tag: str):
+        tag = tag.encode() if tag is not None else None
+        status = get_fxnc().FXNConfigurationSetTag(self.__configuration, tag)
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to set configuration tag with error: {status_to_error(status)}")
+
+    @property
+    def token (self) -> str:
+        buffer = create_string_buffer(2048)
+        status = get_fxnc().FXNConfigurationGetToken(self.__configuration, buffer, len(buffer))
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to get configuration token with error: {status_to_error(status)}")
+        token = buffer.value.decode("utf-8")
+        return token if token else None
+
+    @token.setter
+    def token (self, token: str):
+        token = token.encode() if token is not None else None
+        status = get_fxnc().FXNConfigurationSetToken(self.__configuration, token)
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to set configuration token with error: {status_to_error(status)}")            
+
+    @property
+    def acceleration (self) -> Acceleration:
+        acceleration = c_int()
+        status = get_fxnc().FXNConfigurationGetAcceleration(self.__configuration, byref(acceleration))
+        if status == FXNStatus.OK:
+            return Acceleration(acceleration.value)
+        else:
+            raise RuntimeError(f"Failed to get configuration acceleration with error: {status_to_error(status)}")
+
+    @acceleration.setter
+    def acceleration (self, acceleration: Acceleration):
+        status = get_fxnc().FXNConfigurationSetAcceleration(self.__configuration, acceleration.value)
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to set configuration acceleration with error: {status_to_error(status)}")
+
+    @property
+    def device (self):
+        device = c_void_p()
+        status = get_fxnc().FXNConfigurationGetDevice(self.__configuration, byref(device))
+        if status == FXNStatus.OK:
+            return device if device.value else None
+        else:
+            raise RuntimeError(f"Failed to get configuration device with error: {status_to_error(status)}")
+
+    @device.setter
+    def device (self, device):
+        status = get_fxnc().FXNConfigurationSetDevice(self.__configuration, device)
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to set configuration device with error: {status_to_error(status)}")
+
+    def add_resource (self, type: str, path: Path):
+        status = get_fxnc().FXNConfigurationAddResource(self.__configuration, type.encode(), str(path).encode())
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to add configuration resource with error: {status_to_error(status)}")
+
+    def __enter__ (self):
+        return self
+    
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__configuration:
+            get_fxnc().FXNConfigurationRelease(self.__configuration)
+        self.__configuration = None
+
+    @classmethod
+    def get_unique_id (cls) -> str:
+        buffer = create_string_buffer(2048)
+        status = get_fxnc().FXNConfigurationGetUniqueID(buffer, len(buffer))
+        if status == FXNStatus.OK:
+            return buffer.value.decode("utf-8")
+        else:
+            raise RuntimeError(f"Failed to retrieve configuration identifier with error: {status_to_error(status)}")
+
+    @classmethod
+    def get_client_id (cls) -> str:
+        buffer = create_string_buffer(64)
+        status = get_fxnc().FXNConfigurationGetClientID(buffer, len(buffer))
+        if status == FXNStatus.OK:
+            return buffer.value.decode("utf-8")
+        else:
+            raise RuntimeError(f"Failed to retrieve client identifier with error: {status_to_error(status)}")

fxn/c/fxnc.py

@@ -1,28 +1,48 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
 from ctypes import CDLL
-from pathlib import Path
-from .configuration import _register_fxn_configuration
-from .prediction import _register_fxn_prediction
-from .stream import _register_fxn_prediction_stream
-from .predictor import _register_fxn_predictor
-from .value import _register_fxn_value
-from .map import _register_fxn_value_map
-from .version import _register_fxn_version
+from enum import IntEnum
+from importlib import resources
+from platform import machine, system
 
-def load_fxnc (path: Path) -> CDLL:
-    # Open
-    fxnc = CDLL(str(path))
-    # Register
-    fxnc = _register_fxn_value(fxnc)
-    fxnc = _register_fxn_value_map(fxnc)
-    fxnc = _register_fxn_configuration(fxnc)
-    fxnc = _register_fxn_prediction(fxnc)
-    fxnc = _register_fxn_prediction_stream(fxnc)
-    fxnc = _register_fxn_predictor(fxnc)
-    fxnc = _register_fxn_version(fxnc)
-    # Return
-    return fxnc
+_fxnc: CDLL = None
+
+class FXNStatus(IntEnum):
+    OK = 0
+    ERROR_INVALID_ARGUMENT = 1
+    ERROR_INVALID_OPERATION = 2
+    ERROR_NOT_IMPLEMENTED = 3
+
+def get_fxnc () -> CDLL:
+    global _fxnc
+    _fxnc = _fxnc if _fxnc is not None else _load_fxnc()
+    return _fxnc
+
+def set_fxnc (fxnc: CDLL):
+    global _fxnc
+    _fxnc = fxnc
+
+def _load_fxnc () -> CDLL:
+    os = system().lower()
+    os = "macos" if os == "darwin" else os
+    arch = machine().lower()
+    arch = "arm64" if arch == "aarch64" else arch
+    arch = "x86_64" if arch in ["x64", "amd64"] else arch
+    package = f"fxn.lib.{os}.{arch}"
+    resource = "libFunction.so"
+    resource = "Function.dylib" if os == "macos" else resource
+    resource = "Function.dll" if os == "windows" else resource
+    with resources.path(package, resource) as path:
+        return CDLL(str(path))
+    
+def status_to_error (status: int) -> str:
+    if status == FXNStatus.ERROR_INVALID_ARGUMENT:
+        return "FXN_ERROR_INVALID_ARGUMENT"
+    elif status == FXNStatus.ERROR_INVALID_OPERATION:
+        return "FXN_ERROR_INVALID_OPERATION"
+    elif status == FXNStatus.ERROR_NOT_IMPLEMENTED:
+        return "FXN_ERROR_NOT_IMPLEMENTED"
+    return ""

fxn/c/map.py

@@ -1,34 +1,64 @@
 #
 #   Function
-#   Copyright © 2024 NatML Inc. All Rights Reserved.
+#   Copyright © 2025 NatML Inc. All Rights Reserved.
 #
 
-from ctypes import c_char_p, c_int32, CDLL, POINTER, Structure
-from .status import FXNStatus
-from .value import FXNValueRef
-
-class FXNValueMap(Structure): pass
-
-FXNValueMapRef = POINTER(FXNValueMap)
-
-def _register_fxn_value_map (fxnc: CDLL) -> CDLL:
-    # FXNValueMapCreate
-    fxnc.FXNValueMapCreate.argtypes = [POINTER(FXNValueMapRef)]
-    fxnc.FXNValueMapCreate.restype = FXNStatus
-    # FXNValueMapRelease
-    fxnc.FXNValueMapRelease.argtypes = [FXNValueMapRef]
-    fxnc.FXNValueMapRelease.restype = FXNStatus
-    # FXNValueMapGetSize
-    fxnc.FXNValueMapGetSize.argtypes = [FXNValueMapRef, POINTER(c_int32)]
-    fxnc.FXNValueMapGetSize.restype = FXNStatus
-    # FXNValueMapGetKey
-    fxnc.FXNValueMapGetKey.argtypes = [FXNValueMapRef, c_int32, c_char_p, c_int32]
-    fxnc.FXNValueMapGetKey.restype = FXNStatus
-    # FXNValueMapGetValue
-    fxnc.FXNValueMapGetValue.argtypes = [FXNValueMapRef, c_char_p, POINTER(FXNValueRef)]
-    fxnc.FXNValueMapGetValue.restype = FXNStatus
-    # FXNValueMapSetValue
-    fxnc.FXNValueMapSetValue.argtypes = [FXNValueMapRef, c_char_p, FXNValueRef]
-    fxnc.FXNValueMapSetValue.restype = FXNStatus
-    # Return
-    return fxnc
+from ctypes import byref, c_int, c_int32, c_void_p, create_string_buffer
+from pathlib import Path
+from typing import final
+
+from .fxnc import get_fxnc, status_to_error, FXNStatus
+from .value import Value
+
+@final
+class ValueMap:
+
+    def __init__ (self, map=None, *, owner: bool=True):
+        if map is None:
+            map = c_void_p()
+            owner = True
+            status = get_fxnc().FXNValueMapCreate(byref(map))
+            if status != FXNStatus.OK:
+                raise RuntimeError(f"Failed to create value map with error: {status_to_error(status)}")
+        self.__map = map
+        self.__owner = owner
+
+    def key (self, index: int) -> str:
+        buffer = create_string_buffer(256)
+        status = get_fxnc().FXNValueMapGetKey(self.__map, index, buffer, len(buffer))
+        if status == FXNStatus.OK:
+            return buffer.value.decode("utf-8")
+        else:
+            raise RuntimeError(f"Failed to get value map key at index {index} with error: {status_to_error(status)}")
+
+    def __getitem__ (self, key: str) -> Value | None:
+        value = c_void_p()
+        status = get_fxnc().FXNValueMapGetValue(self.__map, key.encode(), byref(value))
+        if status == FXNStatus.OK:
+            return Value(value, owner=False)
+        else:
+            raise RuntimeError(f"Failed to get value map value for key '{key}' with error: {status_to_error(status)}")
+
+    def __setitem__ (self, key: str, value: Value):
+        status = get_fxnc().FXNValueMapSetValue(self.__map, key.encode(), value._Value__value)
+        if status != FXNStatus.OK:
+            raise RuntimeError(f"Failed to set value map value for key '{key}' with error: {status_to_error(status)}")
+
+    def __len__ (self) -> int:
+        count = c_int32()
+        status = get_fxnc().FXNValueMapGetSize(self.__map, byref(count))
+        if status == FXNStatus.OK:
+            return count.value
+        else:
+            raise RuntimeError(f"Failed to get value map size with error: {status_to_error(status)}")
+
+    def __enter__ (self):
+        return self
+
+    def __exit__ (self, exc_type, exc_value, traceback):
+        self.__release()
+
+    def __release (self):
+        if self.__map and self.__owner:
+            get_fxnc().FXNValueMapRelease(self.__map)
+        self.__map = None