ai-box-lib 0.1.0__tar.gz

ai_box_lib-0.1.0/LICENSE

@@ -0,0 +1,27 @@
+SOFTWARE LICENSE AGREEMENT
+
+This Software Library ("Library") is licensed, not sold, to you by Synadia ("Licensor"). By using, copying, or distributing this Library, you agree to the following terms:
+
+1. Authorized Use
+   - You may use this Library only if you have purchased a compatible device from Synadia.
+   - You may use the Library solely to develop software that runs on the purchased device.
+   - Any other use, including use on non-Synadia devices, is strictly prohibited.
+
+2. Restrictions
+   - You may not distribute, sublicense, or otherwise make the Library available to any third party except as part of software running exclusively on the purchased device.
+   - You may not use the Library for any commercial purpose other than developing software for the purchased device.
+   - Reverse engineering, modification, or derivative works are permitted only for the purpose of developing software for the purchased device.
+
+3. Ownership
+   - The Library remains the property of Synadia. No ownership rights are transferred.
+
+4. Termination
+   - This license is automatically terminated if you breach any of its terms. Upon termination, you must destroy all copies of the Library.
+
+5. Disclaimer
+   - The Library is provided "AS IS" without warranty of any kind. Synadia disclaims all warranties, express or implied, including but not limited to merchantability and fitness for a particular purpose.
+
+6. Limitation of Liability
+   - In no event shall Synadia be liable for any damages arising from the use or inability to use the Library.
+
+For questions or licensing inquiries, contact Synadia.

ai_box_lib-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: ai-box-lib
+Version: 0.1.0
+Summary: Python library for AWS Greengrass integration
+Author-email: Your Name <your.email@example.com>
+License: SOFTWARE LICENSE AGREEMENT
+        
+        This Software Library ("Library") is licensed, not sold, to you by Synadia ("Licensor"). By using, copying, or distributing this Library, you agree to the following terms:
+        
+        1. Authorized Use
+           - You may use this Library only if you have purchased a compatible device from Synadia.
+           - You may use the Library solely to develop software that runs on the purchased device.
+           - Any other use, including use on non-Synadia devices, is strictly prohibited.
+        
+        2. Restrictions
+           - You may not distribute, sublicense, or otherwise make the Library available to any third party except as part of software running exclusively on the purchased device.
+           - You may not use the Library for any commercial purpose other than developing software for the purchased device.
+           - Reverse engineering, modification, or derivative works are permitted only for the purpose of developing software for the purchased device.
+        
+        3. Ownership
+           - The Library remains the property of Synadia. No ownership rights are transferred.
+        
+        4. Termination
+           - This license is automatically terminated if you breach any of its terms. Upon termination, you must destroy all copies of the Library.
+        
+        5. Disclaimer
+           - The Library is provided "AS IS" without warranty of any kind. Synadia disclaims all warranties, express or implied, including but not limited to merchantability and fitness for a particular purpose.
+        
+        6. Limitation of Liability
+           - In no event shall Synadia be liable for any damages arising from the use or inability to use the Library.
+        
+        For questions or licensing inquiries, contact Synadia.
+        
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: greengrasssdk
+Requires-Dist: awsiotsdk
+Dynamic: license-file
+
+# AI Box Library
+
+
+## Development 
+
+Use the `./src/ai-box-lib` to write all the library code which can be used by users. 
+
+In order to test the library locally you can run the following commands: 
+1. 

ai_box_lib-0.1.0/README.md

@@ -0,0 +1,9 @@
+# AI Box Library
+
+
+## Development 
+
+Use the `./src/ai-box-lib` to write all the library code which can be used by users. 
+
+In order to test the library locally you can run the following commands: 
+1. 

ai_box_lib-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = [
+    "setuptools>=61.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai-box-lib"
+version = "0.1.0"
+description = "Python library for AWS Greengrass integration"
+authors = [
+    { name = "Your Name", email = "your.email@example.com" }
+]
+dependencies = [
+    "greengrasssdk", 
+    "awsiotsdk",
+]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.11"

ai_box_lib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai_box_lib-0.1.0/src/ai_box_lib/component_io.py

@@ -0,0 +1,306 @@
+"""
+Provides a client for inter-component communication within AWS Greengrass.
+
+This module defines the `ComponentIO` class, a generic client that simplifies
+publishing and subscribing to topics using the AWS IoT Greengrass Core IPC service.
+It is designed to be used by Greengrass components to communicate with each other.
+
+The client requires the `DEPLOYMENT_ID`, `COMPONENT_ID` and `COMPONENT_VERSION_ID` environment variables
+to be set, which are typically provided by the Greengrass environment.
+
+Example:
+    ```python
+
+    # Define the type of data you expect to send/receive
+    io = ComponentIO[dict]()
+    io.connect()
+
+    def on_message(message: dict):
+        print(f"Received message: {message}")
+
+    async def main():
+        # Subscribe to a topic
+        unsubscribe = io._subscribe("my/topic", on_message)
+
+        # Publish a message
+        await io._publish("my/topic", {"key": "value"})
+
+        # Wait for a bit to receive the message
+        await asyncio.sleep(2)
+
+        # Clean up the subscription
+        unsubscribe()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+    ```
+
+"""
+from dataclasses import dataclass
+from typing import Any, Generic, Mapping, TypeVar, Optional, Callable
+
+import os
+import sys
+import traceback
+import json
+import logging
+from enum import Enum
+from awsiot.greengrasscoreipc.clientv2 import GreengrassCoreIPCClientV2
+from awsiot.greengrasscoreipc.model import (
+    BinaryMessage,
+    PublishMessage,
+    JsonMessage,
+)
+
+logging.basicConfig(level=os.environ.get("LOG_LEVEL", "ERROR"))
+logger = logging.getLogger(__name__)
+
+
+class DataType(Enum):
+    """Enumeration of supported data types."""
+
+    FLOAT32 = "FLOAT32"
+    INT32 = "INT32"
+    STRING = "STRING"
+    BOOLEAN = "BOOLEAN"
+    BYTES = "BYTES"
+
+
+@dataclass
+class ContextDefinition:
+    """Represents a data context with a name and index."""
+
+    name: str
+    index: int
+
+
+@dataclass
+class ChannelDefinition:
+    """Represents a data channel with a name and index."""
+
+    name: str
+    index: int
+
+
+@dataclass
+class FeatureDefinition:
+    """Represents a feature with a name and index."""
+
+    name: str
+    index: int
+    # pylint: disable=invalid-name
+    dataType: DataType
+    shape: list[int]
+    description: Optional[str] = None
+
+S = TypeVar("S", bound=Mapping[str, str] | None)
+P = TypeVar("P", bound=Mapping[str, Any] | None)
+
+class ComponentIO(Generic[S, P]):  # pylint: disable=too-few-public-methods
+    """
+     A client for communication between Greengrass components via IPC.
+
+    This class wraps the AWS Greengrass Core IPC client to provide a simplified
+    interface for publishing and subscribing to topics. It automatically handles
+    message serialization (JSON) and deserialization.
+
+    The `DEPLOYMENT_ID`, `COMPONENT_ID` and `COMPONENT_VERSION_ID` environment variables must be set before
+    instantiating this class.
+
+    The `connect()` method must be called before any publish or subscribe
+    operations.
+
+    This is a generic class, and the type variable `T` represents the expected
+    type of the message payload.
+
+    This is a generic class with two type variables:
+    - S: Represents the expected type of incoming message payloads when subscribing to topics
+    - P: Represents the type of outgoing message payloads when publishing to topics
+
+    Attributes:
+        deployment_id (str): The ID of the deployment, read from the
+                           `DEPLOYMENT_ID` environment variable.
+        component_id (str): The ID of the component, read from the
+                            `COMPONENT_ID` environment variable.
+        component_version_id (str): The ID of the component, read from the
+                         `COMPONENT_VERSION_ID` environment variable.
+
+        Initializes the ComponentIO client.
+
+        Reads deployment and component version IDs from environment variables.
+
+        Raises:
+            ValueError: If `DEPLOYMENT_ID`, `COMPONENT_ID`, and `COMPONENT_VERSION_ID` environment
+                        variables are not set.
+    """
+
+    _ipc: Optional[GreengrassCoreIPCClientV2]
+    deployment_id: str
+    component_id: str
+    component_version_id: str
+
+    def __init__(self) -> None:
+        """Initializes the ComponentIO client."""
+        self.deployment_id = self._get_environment_variable("DEPLOYMENT_ID")
+        self.component_id = self._get_environment_variable("COMPONENT_ID")
+        self.component_version_id = self._get_environment_variable(
+            "COMPONENT_VERSION_ID"
+        )
+        self._ipc = None
+
+    def connect(self) -> None:
+        """Connects to the Greengrass Core IPC service.
+
+        This method initializes the connection to the underlying message broker.
+        It must be called before using `_publish` or `_subscribe`. If already
+        connected, this method does nothing.
+        """
+        if self._ipc is None:
+            self._ipc = GreengrassCoreIPCClientV2()
+
+    def _publish(self, topic: str, message: P) -> None:
+        """Publishes a message to a specified topic.
+
+        The message is serialized based on its type. If it's `bytes` or
+        `bytearray`, it's sent as a binary message. Otherwise, it's serialized
+        to JSON.
+
+            topic: The topic to publish the message to.
+            message: The message payload to publish.
+
+        Raises:
+            RuntimeError: If the client is not connected. `connect()` must be
+                          called first.
+        """
+        if self._ipc is None:
+            raise RuntimeError(
+                "Client is not connected. Call connect() before publishing."
+            )
+
+        if isinstance(message, (bytes, bytearray)):
+            pm = PublishMessage(
+                binary_message=BinaryMessage(message=bytes(message)))
+        else:
+            # Let IPC SDK do JSON serialization of Python primitive/dict/list
+            # Convert Mapping to Dict if needed
+            dict_message = dict(message) if message is not None else None
+            pm = PublishMessage(
+                json_message=JsonMessage(message=dict_message)
+            )  # type: ignore
+        self._ipc.publish_to_topic(topic=topic, publish_message=pm)
+
+    def _subscribe(
+        self, topic: str, handler: Callable[[S], None]
+    ) -> Callable[[], None]:
+        """Subscribes to a topic and registers a handler for incoming messages.
+
+        When a message is received on the topic, the `handler` function is
+        called with the message payload. The method automatically handles
+        deserialization. For binary messages, it attempts to decode them as
+        JSON first, falling back to raw bytes if decoding fails.
+
+            topic: The topic to subscribe to.
+            handler: A callback function that will be invoked with the
+                     message payload when a message is received.
+
+        Raises:
+            RuntimeError: If the client is not connected. `connect()` must be
+                          called first.
+
+        Returns:
+            A callable function that, when invoked, will close the subscription
+            and stop receiving messages.
+        """
+        if self._ipc is None:
+            raise RuntimeError(
+                "Client is not connected. Call connect() before subscribing."
+            )
+
+        def _on_event(event) -> None:
+            try:
+                if not event:
+                    return
+                if (
+                    getattr(event, "json_message", None)
+                    and event.json_message.message is not None
+                ):
+                    handler(event.json_message.message)
+                elif (
+                    getattr(event, "binary_message", None)
+                    and event.binary_message.message is not None
+                ):
+                    raw = event.binary_message.message
+                    # Attempt JSON decode; fallback to raw bytes
+                    try:
+                        handler(json.loads(raw.decode("utf-8")))
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        handler(raw)
+            except (TypeError, ValueError) as e:
+                print(
+                    f"Failed to process subscription event: {e}", file=sys.stderr)
+                traceback.print_exc()
+
+        def _on_error(error: Exception) -> bool:
+            print(f"Error in subscription stream: {error}", file=sys.stderr)
+            return False
+
+        def _on_closed() -> None:
+            print("Subscription stream closed")
+
+        op = self._ipc.subscribe_to_topic(
+            topic=topic,
+            on_stream_event=_on_event,
+            on_stream_error=_on_error,
+            on_stream_closed=_on_closed,
+        )
+
+        def unsubscribe() -> None:
+            op[1].close()
+
+        return unsubscribe
+
+    def _get_environment_variable_context_list(
+        self, var_name: str | None
+    ) -> list[ContextDefinition]:
+        value = self._get_environment_variable(var_name)
+
+        try:
+            return list(map(lambda c: ContextDefinition(**c), json.loads(value)))
+        except (json.JSONDecodeError, TypeError):
+            logger.error("Failed to parse: '%s'. Shutting down.", value)
+            sys.exit(3)
+
+    def _get_environment_variable_channel_list(
+        self, var_name: str | None
+    ) -> list[ChannelDefinition]:
+        value = self._get_environment_variable(var_name)
+
+        try:
+            return list(map(lambda c: ChannelDefinition(**c), json.loads(value)))
+        except (json.JSONDecodeError, TypeError):
+            logger.error("Failed to parse: '%s'. Shutting down.", value)
+            sys.exit(3)
+
+    def _get_environment_variable_feature_list(
+        self, var_name: str | None
+    ) -> list[FeatureDefinition]:
+        value = self._get_environment_variable(var_name)
+
+        try:
+            return list(map(lambda c: FeatureDefinition(**c), json.loads(value)))
+        except (json.JSONDecodeError, TypeError):
+            logger.error("Failed to parse: '%s'. Shutting down.", value)
+            sys.exit(3)
+
+    def _get_environment_variable(self, var_name: str | None) -> str:
+        if var_name is None:
+            logger.error(
+                "%s environment variable is not set. Shutting down.", var_name)
+            sys.exit(1)
+
+        value = os.getenv(var_name)
+        if value is None:
+            logger.error(
+                "%s environment variable is not set. Shutting down.", var_name)
+            sys.exit(3)
+        return value

ai_box_lib-0.1.0/src/ai_box_lib/context_engine_client.py

@@ -0,0 +1,72 @@
+"""
+This module provides a client for context engine to publish data to a specified topic.
+"""
+
+from typing import TypeVar
+import os
+import logging
+from .component_io import ContextDefinition, ComponentIO
+from .typing import ContextType
+
+T = TypeVar("T", bound=ContextType)
+
+logging.basicConfig(level=os.environ.get("LOG_LEVEL", "ERROR"))
+logger = logging.getLogger(__name__)
+
+
+class ContextEngineClient(ComponentIO[T, T]):
+    """Client for publishing data to a context engine service.
+
+    This component is designed to be part of a larger pipeline system. It
+    automatically constructs a unique NATS topic for publishing results based on the
+    pipeline and module IDs inherited from the `ComponentIO` base class.
+
+    This class is generic, allowing it to handle and publish any specified data type.
+
+    Args:
+        Generic (T): The type of data that the client will publish.
+
+    Attributes:
+        publish_topic (str): The NATS topic where data will be published, formatted as
+            'context-engine/result'.
+    """
+
+    context_definition: list[ContextDefinition]
+
+    def __init__(self) -> None:
+        """Initializes the ContextEngineClient and sets the publish topic."""
+        super().__init__()
+
+        self.publish_topic = "context-engine/result"
+        self._state: T | None = None
+        self.context_definition: list[ContextDefinition] = []
+
+    @property
+    def context(self) -> T | None:
+        """Read-only access to the latest received state."""
+        return self._state
+
+    def connect(self) -> None:
+        """Connects to the message broker and subscribes to the publish topic.""" 
+        super().connect()
+        self._subscribe(self.publish_topic, self._handle_incoming_message)
+
+    def publish_data(self, data: T) -> None:
+        """Asynchronously publishes data to the predefined topic.
+
+        This method is a convenience wrapper around the parent's `publish` method,
+        sending the data to the topic specified in `self.publish_topic`.
+
+        Args:
+            data (T): The data payload to publish. The type is generic and
+                should be compatible with the configured message broker's serializer.
+
+        Raises:
+            ValueError: If any keys in the data do not correspond to existing channels.
+        """
+        self._publish(self.publish_topic, data)
+
+    def _handle_incoming_message(self, message: T) -> None:
+        """Handle incoming messages from the context engine and update state."""
+        logger.info("Received message %s", message)
+        self._state = message

ai_box_lib-0.1.0/src/ai_box_lib/data_collector_client.py

@@ -0,0 +1,75 @@
+"""
+This module provides a client for data collectors to publish data to a specified topic.
+"""
+
+from typing import TypeVar
+import os
+import logging
+from .component_io import ChannelDefinition, ComponentIO
+from .typing import ChannelType
+
+
+logging.basicConfig(level=os.environ.get("LOG_LEVEL", "ERROR"))
+logger = logging.getLogger(__name__)
+
+P = TypeVar("P", bound=ChannelType)
+
+class DataCollectorClient(ComponentIO[None, P]):
+    """Client for publishing data to a data collector service.
+
+    This component is designed to be part of a larger pipeline system. It
+    automatically constructs a unique NATS topic for publishing results based on the
+    pipeline and module IDs inherited from the `ComponentIO` base class.
+
+    This class is generic, allowing it to handle and publish any specified data type.
+
+    Args:
+        Generic (P): The type of data that the client will publish.
+
+    Attributes:
+        publish_topic (str): The NATS topic where data will be published, formatted as
+            'data-collector/{component_id}/{component_version_id}/result'.
+    """
+
+    channels: list[ChannelDefinition]
+
+    def __init__(self) -> None:
+        """Initializes the DataCollectorClient and sets the publish topic.
+
+        Asynchronously publishes a data payload to the pre-configured topic.
+
+        Args:
+            data (T): The data to be published. The type is determined by the
+                generic type `T` provided during the class instantiation.
+        """
+        super().__init__()
+
+        self.channels = super()._get_environment_variable_channel_list("CHANNELS")
+
+        self.publish_topic = (
+            f"data-collector/{self.component_id}/{self.component_version_id}/result"
+        )
+        self.subscribe_context_engine_topic = (
+            "context-engine/result"
+        )
+
+    def publish_data(self, data: P) -> None:
+        """Asynchronously publishes data to the predefined topic.
+
+        This method is a convenience wrapper around the parent's `publish` method,
+        sending the data to the topic specified in `self.publish_topic`.
+
+        Args:
+            data (T): The data payload to publish. The type is generic and
+                should be compatible with the configured message broker's serializer.
+
+        Raises:
+            ValueError: If any keys in the data do not correspond to existing channels.
+        """
+        keys = list(data.keys())
+        channel_names = [channel.name for channel in self.channels]
+        missing_keys = set(channel_names) - set(keys)
+        if missing_keys:
+            logger.error("Missing channels for keys: %s", missing_keys)
+            raise ValueError(f"Missing channels for keys: {missing_keys}")
+        self._publish(self.publish_topic, data)

ai_box_lib-0.1.0/src/ai_box_lib/pre_processor_client.py

@@ -0,0 +1,136 @@
+"""Defines the client for a pre-processor component in a data processing pipeline.
+
+This module contains the `PreProcessorClient` class, which handles the communication
+(publishing and subscribing) for a pre-processing stage. It is designed to
+receive data from a data collector and publish the processed results for
+subsequent components in the pipeline.
+"""
+
+import logging
+import os
+from typing import Any, TypeVar, Callable
+from .component_io import ComponentIO
+from .typing import ChannelType, FeatureType
+
+logging.basicConfig(level=os.environ.get("LOG_LEVEL", "ERROR"))
+logger = logging.getLogger(__name__)
+
+
+S = TypeVar("S", bound=ChannelType)
+P = TypeVar("P", bound=FeatureType)
+
+
+class PreProcessorClient(ComponentIO[S, P]):
+    """A client for a pre-processing component in a data pipeline.
+
+    This class facilitates communication for a pre-processor. It subscribes to data
+    from a 'data-collector' component and publishes the processed results. The specific
+    data type it handles is defined by the generic type `T`.
+
+    It inherits from `ComponentIO` to leverage common pipeline communication logic.
+
+    Attributes:
+        publish_topic (str): The NATS topic for publishing processed data.
+        subscribe_topic (str): The NATS topic for subscribing to raw data.
+    """
+
+    def __init__(self) -> None:
+        """Initializes the PreProcessorClient instance.
+
+        Sets up the NATS topics for publishing and subscribing based on the
+        pipeline and module IDs inherited from the `ComponentIO` base class.
+        """
+        super().__init__()
+
+        self.channels = super()._get_environment_variable_channel_list("CHANNELS")
+        self.features = super()._get_environment_variable_feature_list("FEATURES")
+        self.pipeline_id = super()._get_environment_variable("PIPELINE_ID")
+        self.data_collector_component_id = super()._get_environment_variable(
+            "DATA_COLLECTOR_COMPONENT_ID"
+        )
+        self.data_collector_component_version_id = super()._get_environment_variable(
+            "DATA_COLLECTOR_COMPONENT_VERSION_ID"
+        )
+
+        self.publish_topic = (
+            f"pre-processor/{self.pipeline_id}/{self.component_id}/{self.component_version_id}/result"
+        )
+        self.subscribe_topic = (
+            f"data-collector/{self.data_collector_component_id}/{self.data_collector_component_version_id}/result"
+        )
+
+    def publish_data(self, data: P) -> None:
+        """Asynchronously publishes processed data.
+        Args:
+            data (P): The processed data to be published to the pre-processor's
+                     result topic.
+        """
+        keys = list(data.keys())
+        feature_names = [feature.name for feature in self.features]
+        missing_keys = set(feature_names) - set(keys)
+        if missing_keys:
+            logger.error("Missing features for keys: %s", missing_keys)
+            raise ValueError(f"Missing features for keys: {missing_keys}")
+
+        for feature in self.features:
+            shape = self._shape_from_object(data[feature.name])
+            if list(shape) != feature.shape:
+                logger.error(
+                    "Feature '%s' has incorrect shape. Expected %s, got %s",
+                    feature.name,
+                    feature.shape,
+                    list(shape),
+                )
+                error_message = (
+                    f"Feature '{feature.name}' has incorrect shape. "
+                    f"Expected {feature.shape}, got {list(shape)}"
+                )
+                raise ValueError(error_message)
+            self._validate_list_type(data[feature.name], (float, int))
+        self._publish(self.publish_topic, data)
+
+    def subscribe(self, handler: Callable[[S], None]) -> Callable[[], None]:
+        """Subscribes to raw data from a data collector.
+
+        Sets up a subscription to the corresponding data collector's result topic.
+        When a message is received, the provided handler is called with the data.
+
+        Args:
+            handler (Callable[[S], None]): A callback function to be invoked
+                with the received data.
+
+        Returns:
+            Callable[[], None]: A function that can be called to unsubscribe
+                from the topic.
+        """
+        return self._subscribe(self.subscribe_topic, handler)
+
+
+    def _shape_from_object(self, obj: list) -> tuple:
+
+        shape = []
+        def _shape_from_object_r(element: list, axis: int):
+            try:
+                for i, e in enumerate(element):
+                    _shape_from_object_r(e, axis+1)
+                    while len(shape) <= axis:
+                        shape.append(0)
+                    l = i + 1
+                    s = shape[axis]
+                    if l > s:
+                        shape[axis] = l
+            except TypeError:
+                pass
+
+        _shape_from_object_r( obj, 0)
+        return tuple(shape)
+
+    def _validate_list_type(self, obj: Any, expected_type: tuple[type, ...]) -> None:
+        if not isinstance(obj, list):
+            raise TypeError(f"Expected list, got {type(obj)}")
+        for item in obj:
+            if isinstance(item, list):
+                self._validate_list_type(item, expected_type)
+            else:
+                if not isinstance(item, expected_type):
+                    raise TypeError(f"Expected list of {expected_type}, got {type(item)}")

ai_box_lib-0.1.0/src/ai_box_lib/typing.py

@@ -0,0 +1,6 @@
+"""Typing definitions for context, channels and features."""
+from typing import Any, Mapping, TypeAlias
+
+ContextType: TypeAlias = Mapping[str, Any]
+ChannelType: TypeAlias = Mapping[str, Any]
+FeatureType: TypeAlias = Mapping[str, Any]

ai_box_lib-0.1.0/src/ai_box_lib.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: ai-box-lib
+Version: 0.1.0
+Summary: Python library for AWS Greengrass integration
+Author-email: Your Name <your.email@example.com>
+License: SOFTWARE LICENSE AGREEMENT
+        
+        This Software Library ("Library") is licensed, not sold, to you by Synadia ("Licensor"). By using, copying, or distributing this Library, you agree to the following terms:
+        
+        1. Authorized Use
+           - You may use this Library only if you have purchased a compatible device from Synadia.
+           - You may use the Library solely to develop software that runs on the purchased device.
+           - Any other use, including use on non-Synadia devices, is strictly prohibited.
+        
+        2. Restrictions
+           - You may not distribute, sublicense, or otherwise make the Library available to any third party except as part of software running exclusively on the purchased device.
+           - You may not use the Library for any commercial purpose other than developing software for the purchased device.
+           - Reverse engineering, modification, or derivative works are permitted only for the purpose of developing software for the purchased device.
+        
+        3. Ownership
+           - The Library remains the property of Synadia. No ownership rights are transferred.
+        
+        4. Termination
+           - This license is automatically terminated if you breach any of its terms. Upon termination, you must destroy all copies of the Library.
+        
+        5. Disclaimer
+           - The Library is provided "AS IS" without warranty of any kind. Synadia disclaims all warranties, express or implied, including but not limited to merchantability and fitness for a particular purpose.
+        
+        6. Limitation of Liability
+           - In no event shall Synadia be liable for any damages arising from the use or inability to use the Library.
+        
+        For questions or licensing inquiries, contact Synadia.
+        
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: greengrasssdk
+Requires-Dist: awsiotsdk
+Dynamic: license-file
+
+# AI Box Library
+
+
+## Development 
+
+Use the `./src/ai-box-lib` to write all the library code which can be used by users. 
+
+In order to test the library locally you can run the following commands: 
+1. 

ai_box_lib-0.1.0/src/ai_box_lib.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/ai_box_lib/__init__.py
+src/ai_box_lib/component_io.py
+src/ai_box_lib/context_engine_client.py
+src/ai_box_lib/data_collector_client.py
+src/ai_box_lib/pre_processor_client.py
+src/ai_box_lib/typing.py
+src/ai_box_lib.egg-info/PKG-INFO
+src/ai_box_lib.egg-info/SOURCES.txt
+src/ai_box_lib.egg-info/dependency_links.txt
+src/ai_box_lib.egg-info/requires.txt
+src/ai_box_lib.egg-info/top_level.txt

ai_box_lib-0.1.0/src/ai_box_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ai_box_lib-0.1.0/src/ai_box_lib.egg-info/requires.txt

@@ -0,0 +1,2 @@
+greengrasssdk
+awsiotsdk

ai_box_lib-0.1.0/src/ai_box_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+ai_box_lib