PyAres 0.1.4__py3-none-any.whl

PyAres/Models/ares_data_models.py

@@ -0,0 +1,27 @@
+from ares_datamodel import request_metadata_pb2
+from enum import Enum
+
+class AresDataType(Enum):
+    UNKNOWN = 0
+    NULL = 1
+    BOOLEAN = 2
+    STRING = 3
+    NUMBER = 4
+    STRING_ARRAY = 5
+    NUMBER_ARRAY = 6
+    BYTE_ARRAY = 7
+    BOOL_ARRAY = 8
+
+class Outcome(Enum):
+    UNSPECIFIED_OUTCOME = 0
+    SUCCESS = 1
+    FAILURE = 2
+    WARNING = 3
+    CANCELED = 4
+
+class RequestMetadata():
+    def __init__(self, proto_metadata: request_metadata_pb2.RequestMetadata):
+        self.system_name = proto_metadata.system_name
+        self.campaign_name = proto_metadata.campaign_name
+        self.campaign_id = proto_metadata.campaign_id
+        self.experiment_id = proto_metadata.experiment_id  

PyAres/Planning/__init__.py

@@ -0,0 +1,9 @@
+from .planner_models import PlanningParameter, PlanRequest, PlanResponse, ParameterHistoryItem
+from .planning_service import AresPlannerService
+
+__all__ = [
+    "PlanningParameter",
+    "PlanRequest",
+    "PlanResponse",
+    "AresPlannerService"
+]

PyAres/Planning/planner_models.py

@@ -0,0 +1,83 @@
+from typing import Dict, Any, List
+from ..Models import Outcome, AresDataType, RequestMetadata
+
+class ParameterHistoryItem:
+    """ Represents a single historical parameter item """
+    def __init__(self, planned_value: Any, achieved_value: Any):
+        """
+        Initializes a ParameterHistoryItem
+
+        Args:
+          planned_value: A value that was planned
+          achieved_value: Optionally a value that was actually achieved for what was planned
+        """
+        self.planned_value = planned_value
+        self.achieved_value = achieved_value
+
+class PlanningParameter:
+    """
+    Represents a single parameter within a planning request.
+
+    Designed to provide a more user-friendly abstraction for the user to interact
+    with planning parameters through.
+    """
+    def __init__(self, name: str, minimum_value: float, 
+                 maximum_value: float, param_history: list[ParameterHistoryItem], data_type: AresDataType, 
+                 is_planned: bool, is_result: bool, planner_name: str, initial_value = None):
+        """
+        Initializes a PlanningParameter.
+
+        Args:
+            name: The name or key associated with the parameter.
+            minimum_value: The minimum value the parameter is capable of being assigned.
+            maximum_value: The maximum value the parameter is capable of being assigned.
+            param_history: A list of historical planned and achieved values associated with the parameter.
+            data_type: The data type associated with the parameter.
+            is_planned: A bool representing whether this parameter is designed to be planned for.
+            is_result: A bool representing whether this parameter is the intended result of the experiment.
+            planner_name: The name of the planner ARES requested be used to plan for this parameter.
+            initial_value: An optional initial value for the given parameter
+        """
+        self.name : str = name
+        self.minimum_value : float = minimum_value
+        self.maximum_value : float= maximum_value
+        self.param_history : List = param_history
+        self.data_type : AresDataType = data_type
+        self.is_planned : bool = is_planned
+        self.is_result : bool = is_result
+        self.planner_name : str = planner_name
+        self.initial_value = initial_value
+
+class PlanRequest:
+    """
+    Represents a PlanRequest message received from ARES.
+    
+    Designed to provide a more user-friendly abstraction for interacting with a plan request message.
+    """
+    def __init__(self, parameters: list[PlanningParameter], settings: Dict[str, Any], analysis_results: list[float], metadata: RequestMetadata):
+        """
+        Initializes a PlanRequest.
+
+        Args:
+            parameters: A list of PlanningParameter objects.
+        """
+        self.parameters = parameters
+        self.settings = settings
+        self.analysis_results = analysis_results
+        self.request_metadata = metadata
+
+
+class PlanResponse:
+    """ Represents a PlanResponse message to be send to ARES. """
+    def __init__(self, parameter_names: list[str], parameter_values: list, planning_outcome: Outcome = Outcome.SUCCESS, error_string: str = ""):
+        """
+        Initializes a PlanResponse.
+
+        Args:
+            parameter_names: A list of names associated with planned parameters.
+            parameter_values: A list of values associated with planned parameters. 
+        """
+        self.parameter_names = parameter_names
+        self.parameter_values = parameter_values
+        self.outcome = planning_outcome
+        self.error_string = error_string

PyAres/Planning/planning_service.py

@@ -0,0 +1,252 @@
+import grpc
+from concurrent import futures
+from typing import Callable, Awaitable, Union, Dict
+
+from ares_datamodel.planning.remote import ares_remote_planner_service_pb2 as planner_service
+from ares_datamodel.planning.remote import ares_remote_planner_service_pb2_grpc as planner_service_grpc
+from ares_datamodel.planning import planner_pb2
+from ares_datamodel.planning import planner_settings_pb2
+from ares_datamodel.planning import planner_service_capabilities_pb2
+from ares_datamodel.planning import plan_pb2
+from ares_datamodel import ares_data_schema_pb2
+from ares_datamodel import ares_data_type_pb2
+from ares_datamodel import ares_outcome_enum_pb2
+from ares_datamodel.connection import connection_state_pb2
+from ares_datamodel.connection import connection_info_pb2
+
+# Import Utilities
+from ..Utils import ares_value_utils
+from ..Utils import ares_data_schema_utils
+from ..Utils import ares_data_type_utils
+from ..Utils import ares_struct_utils
+from ..Utils import ares_outcome_utils
+
+# Import python models
+from ..Models import ares_data_models
+from .planner_models import *
+
+# Type hint for the user's custom planning logic
+PlanLogicFunction = Callable[[PlanRequest], Union[PlanResponse, Awaitable[PlanResponse]]]
+
+class AresPlannerServiceWrapper(planner_service_grpc.AresRemotePlannerServiceServicer):
+    """
+    A wrapper around the gRPC service to expose native Python objects for planning
+    """
+    def __init__(self, service_name: str, description: str, version: str, timeout: int, custom_plan_logic: PlanLogicFunction):
+        self._custom_plan_logic: PlanLogicFunction = custom_plan_logic
+        self._service_name: str = service_name
+        self._description: str = description
+        self._version: str = version
+        self._settings: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
+        self._planner_options: list[planner_pb2.Planner] = []
+        self._supported_types: list[ares_data_type_pb2.AresDataType] = []
+        self._timeout: int = timeout
+
+    def GetPlannerServiceCapabilities(self, request, context) -> planner_service_capabilities_pb2.PlannerServiceCapabilities:
+        print("Capabilities Requested!")
+        """
+        Implements the gRPC Capabilities request method. Responsible for telling ARES what this planner
+        service is capable of.
+        """
+        capabilities = planner_service_capabilities_pb2.PlannerServiceCapabilities(timeout_seconds=self._timeout)
+        capabilities.service_name = self._service_name
+        capabilities.accepted_types.extend(self._supported_types)
+        capabilities.available_planners.extend(self._planner_options)
+
+        for(key, value) in self._settings.items():
+            settings_entry: ares_data_schema_pb2.SchemaEntry = capabilities.settings_schema.fields[key]
+            settings_entry.type = value.type
+            settings_entry.optional - value.optional
+
+            if len(value.string_choices.strings) != 0:
+                settings_entry.string_choices.strings.extend(value.string_choices.strings)
+
+            elif len(value.number_choices.numbers) != 0:
+                settings_entry.number_choices.numbers.extend(value.number_choices.numbers)
+
+        print("Capabilites Sent!")
+        return capabilities
+    
+    def GetInfo(self, request, context) -> connection_info_pb2.InfoResponse:
+        try:
+            response = connection_info_pb2.InfoResponse(
+                name=self._service_name,
+                version=self._version,
+                description=self._description
+            )
+
+            return response
+        
+        except Exception as e:
+            response = connection_info_pb2.InfoResponse(
+                name="ERROR",
+                version="ERROR",
+                description="Error fetching information"
+            )
+            print(f"Exception while trying to respond to ARES with information! {e}")
+            return response
+
+    def GetState(self, request, context) -> connection_state_pb2.StateResponse:
+        try:
+            return connection_state_pb2.StateResponse(state=connection_state_pb2.State.ACTIVE, state_message=f"{self._service_name} is active!")
+        
+        except Exception as e:
+            print(f"{e}")
+            return connection_state_pb2.StateResponse(state=connection_state_pb2.State.ERROR, state_message=f"Exception while trying to respond to ARES with state! {e}")
+ 
+
+    
+    def GetConnectionStatus(self, request, context):
+        try:
+            return connection_state_pb2.StateResponse(state=connection_state_pb2.State.ACTIVE, state_message=f"{self._service_name} is active!")
+
+        except Exception as e:
+            print(f"Exception while trying to respond to ARES with connection status! {e}")
+
+    
+    def Plan(self, request: plan_pb2.PlanningRequest, context) -> plan_pb2.PlanningResponse:
+        """
+        Implements the gRPC Plan method. This method converts protobuf requests to native Python objects
+        before executing the users custom planning logic and converting their response back to protobuf.
+        """
+        parameters = []
+        for proto_param in request.planning_parameters:
+            parameters.append(
+                PlanningParameter
+                (
+                    name=proto_param.parameter_name,
+                    maximum_value=proto_param.maximum_value,
+                    minimum_value=proto_param.minimum_value,
+                    param_history=[ParameterHistoryItem(ares_value_utils.ares_value_to_py(val.planned_value), ares_value_utils.ares_value_to_py(val.achieved_value)) for val in proto_param.parameter_history],
+                    data_type=ares_data_type_utils.proto_ares_type_to_python_ares_type(proto_param.data_type),
+                    is_planned=proto_param.is_planned,
+                    is_result=proto_param.is_result,
+                    planner_name=proto_param.planner_name,
+                    initial_value=ares_value_utils.ares_value_to_py(proto_param.initial_value)
+                ))
+        
+        python_request = PlanRequest(parameters=parameters, 
+                                     settings=ares_struct_utils.ares_struct_to_dict(request.adapter_settings), 
+                                     analysis_results=list(request.analysis_results),
+                                     metadata=RequestMetadata(request.metadata))
+        
+        #Handle call using the user's custom planning logic 
+        response_proto = plan_pb2.PlanningResponse()
+        try:
+            python_response = self._custom_plan_logic(python_request)
+            if isinstance(python_response, Awaitable):
+                python_response = python_response.__await__()
+
+        except Exception as e:
+            #Handle errors from user's logic
+            context.set_code(grpc.StatusCode.INTERNAL)
+            context.set_details(f"Error in custom planning logic: {e}")
+            response_proto.error_string = f"{e}"
+            response_proto.planning_outcome = ares_outcome_enum_pb2.FAILURE
+            return response_proto
+        
+        if not isinstance(python_response, PlanResponse):
+            response_proto.error_string = "The returned response from the user planning method was not a plan response, and thus was invalid."
+            response_proto.planning_outcome = ares_outcome_enum_pb2.FAILURE
+            return response_proto
+        
+        response_proto.planning_outcome = ares_outcome_utils.python_ares_outcome_to_proto_ares_outcome(python_response.outcome)
+        response_proto.error_string = python_response.error_string
+
+        for i in range(len(python_response.parameter_names)):
+            planned_parameter = plan_pb2.PlannedParameter(parameter_value=ares_value_utils.create_ares_value(python_response.parameter_values[i]))
+            planned_parameter.parameter_name = python_response.parameter_names[i]
+            new_planned_parameter = response_proto.planned_parameters.add()
+            new_planned_parameter.CopyFrom(planned_parameter)
+
+        print("Sending Plan Response.....")
+        return response_proto
+    
+class AresPlannerService:
+    """
+    Manages the gRPC server for the AresPlannerService
+    """
+    def __init__(self, custom_plan_logic: PlanLogicFunction, service_name: str, service_description: str, service_version: str, timeout: int = 30, use_localhost: bool = True, port: int = 7082):
+        """
+        Initializes the AresPlannerService
+
+        Args:
+            custom_plan_logic: A callable function that will be executed when a PlanRequest is received.
+                This function should accept a 'PyARES.AresPlanning.PlanRequest' object and return a
+                'PyARES.AresPlanning.PlanResponse' object (or an awaitable that resolves to one).
+            service_name: The name descriptor that is associated with your planner service.
+            service_description: A brief description describing your implementation of the planner service.
+            service_version: The version of your planner service.
+            use_localhost: An optional value that allows the user to specify whether to host the service on the local network. Defaults to True.
+            port: The port that your planner service will serve on. Defaults to port 7082.
+        """
+        #Public Values, designed to be accessible to the user
+        self.service_name = service_name
+        self.service_description = service_description
+        self.service_version = service_version
+
+        #Private values, mostly related to the service
+        self._port = port
+        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+        self._service_wrapper = AresPlannerServiceWrapper(service_name, service_description, service_version, timeout, custom_plan_logic)
+        planner_service_grpc.add_AresRemotePlannerServiceServicer_to_server(self._service_wrapper, self._server)
+        if(use_localhost):
+            self._server.add_insecure_port(f'localhost:{self._port}')
+        else:
+            self._server.add_insecure_port(f'[::]:{self._port}')
+
+    def add_planner_option(self, planner_name: str, planner_description: str, planner_version: str):
+        """
+        Adds a planner option that is reported to ARES when your services capabilities are requested.
+
+        Args:
+            planner_name (str): The dedicated name of your planner.
+            planner_description (str): A brief description of your planner that is displayed in ARES.
+            planner_version (str): The version of your planner. 
+        """
+        self._service_wrapper._planner_options.append(planner_pb2.Planner(planner_name=planner_name, description=planner_description, version=planner_version))
+
+    def add_setting(self, setting_name: str, setting_type: ares_data_models.AresDataType, optional: bool = True, constraints: Union[list[int], list[str], list[float]] = []):
+        """
+        Adds a planner setting to be reported to ARES when your services capabilities are requested.
+
+        Args:
+            setting_name (str): The name of the setting.
+            setting_type (AresDataType): The type of this settings value.
+            optional (bool): Whether the setting is optional.
+            constraints: An optional list of values to constrain the available setting choices. Can be integers, strings, or floats.
+        """
+        self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(setting_type, optional, constraints)
+
+    def add_supported_type(self, type: ares_data_models.AresDataType):
+        """
+        Adds the specified type to the list of value types your planenr service accepts.
+
+        Args:
+            type (AresDataType): The type being added to the list of allowed types.
+        """
+        self._service_wrapper._supported_types.append(ares_data_type_utils.python_ares_type_to_proto_ares_type(type))
+
+    def set_timeout(self, new_timeout: int):
+        """
+        Sets the time, in seconds, that ARES will wait to receive a response from this service.
+
+        Args:
+            new_timeout: The time to be assigned as the new timeout value
+        """
+        self._service_wrapper._timeout = new_timeout
+
+    def start(self):
+        """
+        Starts the service on the specified port, and waits for termination.
+        """
+        print(f"Starting Ares Planner Service on port {self._port}...")
+        self._server.start()
+        self._server.wait_for_termination()
+
+    def stop(self):
+        """
+        Stops the service, terminating the connection.
+        """
+        print("Stopping Ares Planning Service...")
+        self._server.stop(0).wait()       

PyAres/Test/analyzer_test.py

@@ -0,0 +1,27 @@
+from PyAres import AresAnalyzerService, AnalysisRequest, Analysis, AresDataType, Outcome
+
+def analyze(request: AnalysisRequest) -> Analysis:
+    #Custom Analysis Logic
+    temperature = request.inputs.get("Temperature")
+
+    if not isinstance(temperature, float):
+        print("Temperature was not a float")
+        temperature = 0.0
+
+    print(f"Temperature: {temperature}")
+
+    analysis = Analysis(result=temperature)
+    return analysis
+
+
+if __name__ == "__main__":
+    #Basic details about your analyzer
+    name = "Python Test Analyzer"
+    version = "0.0.1"
+    description = "This is a test analyzer to demonstrate working with PyAres to create analyzers!"
+    pythonDemoAnalyzer = AresAnalyzerService(analyze, name, version, description)
+
+    #Add Analysis Parameters
+    pythonDemoAnalyzer.add_analysis_parameter("Temperature", AresDataType.NUMBER)
+
+    pythonDemoAnalyzer.start()

PyAres/Test/device_test.py

@@ -0,0 +1,48 @@
+from PyAres import AresDeviceService, DeviceCommandDescriptor, DeviceSchemaEntry, AresDataType
+from typing import Dict
+import time
+
+class DemoDevice:
+  # A simulated device. In reality, these communications would be happening with external hardware over serial, usb, etc.
+  def __init__(self):
+    self.temperature = 0.0
+
+  def set_temperature(self, temperature: float):
+    self.temperature = temperature
+    time.sleep(5)
+    return {}
+
+  def get_temperature(self):
+    return { "temperature": self.temperature }
+  
+  def get_device_state(self) -> Dict:
+    state_dict = { "temperature": self.temperature }
+    return state_dict
+  
+  def enter_safe_mode(self):
+    self.temperature = 0
+
+device = DemoDevice()
+
+if __name__ == "__main__":
+  # Basic information about my device
+  device_name = "Demo Device"
+  description = "A device to demonstrate the PyAres device capabilities"
+  version = "1.0.0"
+  device_service = AresDeviceService(device.enter_safe_mode, device.get_device_state, device_name, description, version)
+
+  # Create the "Set Temperature" Command
+  parameter_schema = DeviceSchemaEntry(AresDataType.NUMBER, "A numeric temperature value", "Degree's Celsius")
+  input_schema = { "temperature": parameter_schema }
+  set_temp_descriptor = DeviceCommandDescriptor("Set Temperature", "Set's the temperature of the demo device to the provided value.", input_schema, {})
+  device_service.add_new_command(set_temp_descriptor, device.set_temperature)
+
+  # Create the "Get Temperature" Command
+  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.NUMBER, "The current temperature of the device", "Degree's Celsius")}
+  get_temp_desc = DeviceCommandDescriptor("Get Temperature", "Get's the current temperature of the demo device.", {}, output_schema)
+  device_service.add_new_command(get_temp_desc, device.get_temperature)
+
+  #Add Settings
+  device_service.add_setting("Allow Negative Values", True)
+
+  device_service.start()

PyAres/Test/planner_test.py

@@ -0,0 +1,85 @@
+from PyAres import *
+
+import random
+
+def plan(request: PlanRequest) -> PlanResponse:
+  print("Planning Requested!")
+  new_values = []
+  gpdoods = []
+  names = []
+
+  for param in request.parameters:
+    if param.planner_name == "GPRDood":
+      gpdoods.append(param)
+
+    if param.planner_name == "Random Planner":
+      new_value = random_planner(param)
+      new_values.append(new_value)
+      names.append(param.name)
+
+    elif param.planner_name == "Gradual Planner":
+      new_value = gradual_planner(param)
+      new_values.append(new_value)
+      names.append(param.name)
+
+    else:
+      print("Invalid planner name detected... defaulting to random")
+      new_value = random_planner(param)
+      new_values.append(new_value)
+      names.append(param.name)
+
+  return PlanResponse(parameter_names=names, parameter_values=new_values)
+
+def random_planner(param: PlanningParameter) -> float:
+  if param.data_type == AresDataType.NUMBER:
+    return random.uniform(param.minimum_value, param.maximum_value)
+ 
+  else:
+    print("Found a non-number....")
+    return 0
+  
+def gradual_planner(param: PlanningParameter) -> float:
+  if(param.data_type == AresDataType.NUMBER):
+    if len(param.param_history) == 0:
+      return param.minimum_value
+    
+    previous_value = param.param_history[-1].planned_value
+    previous_value += 5
+
+    if previous_value > param.maximum_value:
+      return param.minimum_value
+    
+    else:
+      return previous_value
+    
+  else:
+    return 0
+    
+if __name__ == "__main__":
+  #Basic details about your planner
+  name = "Python Test Planner"
+  version = "1.0.0"
+  description = "This is a test planner to demonstrate working with PyAres to create planners!"
+  pythonDemoPlanner = AresPlannerService(plan, name, description, version)
+
+  #Add Supported Types
+  pythonDemoPlanner.add_supported_type(AresDataType.NUMBER)
+
+  #Add Planner Options
+  pythonDemoPlanner.add_planner_option("Random Planner", "A planner that returns random values", "1.0.0")
+  pythonDemoPlanner.add_planner_option("Gradual Planner", "A planner that gradually increases a value based on the values history", "1.0.0")
+
+  #Add Planner Settings
+  pythonDemoPlanner.add_setting("String Setting", AresDataType.STRING)
+  pythonDemoPlanner.add_setting("Number Setting", AresDataType.NUMBER)
+  pythonDemoPlanner.add_setting("Boolean Setting", AresDataType.BOOLEAN)
+  pythonDemoPlanner.add_setting("String Array Setting", AresDataType.STRING_ARRAY)
+  pythonDemoPlanner.add_setting("Constrained Strings", AresDataType.STRING_ARRAY, True, ["One", "Two", "Three"])
+  pythonDemoPlanner.add_setting("Number Array Setting", AresDataType.NUMBER_ARRAY)
+  pythonDemoPlanner.add_setting("Constrained Numbers", AresDataType.NUMBER_ARRAY, True, [1, 2, 3])
+
+  #Set Planner Timeout
+  pythonDemoPlanner.set_timeout(60)
+
+  #Start Your Planner Service
+  pythonDemoPlanner.start()

PyAres/Utils/ares_data_schema_utils.py

@@ -0,0 +1,44 @@
+from typing import Union, Dict
+
+#Datamodel Imports
+from ares_datamodel import ares_data_schema_pb2
+
+from ..Models import ares_data_models
+# def ares_schema_to_dict(schema: ares_data_schema_pb2.AresDataSchema) -> dict:
+#     """Converts an AresDataSchemaSimplified to a dictionary for user logic."""
+#     result = {}
+#     for key, entry in schema.fields.items():
+#         result[key] = {
+#             "type": ares_data_schema_pb2.AresDataType.Name(entry.type),
+#             "is_array": entry.is_array
+#         }
+#     return result
+
+def create_settings_schema_entry(
+    setting_type: ares_data_models.AresDataType, 
+    optional: bool, 
+    choices: Union[list[str], list[int], list[float]]) -> ares_data_schema_pb2.SchemaEntry:
+    """
+    Takes in an AresSetting object and converts it into the protobuf SchemaEntry message.
+
+    Args:
+        new_setting: The AresSetting object that provides all the details around the setting implementation.
+
+    Returns:
+        (SchemaEntry): A new SchemaEntry message.
+    """
+
+    if(isinstance(choices, list)):
+        if(len(choices) == 0):
+            schema_entry = ares_data_schema_pb2.SchemaEntry(type=setting_type.value, optional=optional)
+
+        elif(all(isinstance(item, str) for item in choices)):
+            schema_entry = ares_data_schema_pb2.SchemaEntry(type=setting_type.value, optional=optional)
+            schema_entry.string_choices.strings.extend(choices)
+    
+        elif(all(isinstance(item, (int, float)) for item in choices)):
+            schema_entry = ares_data_schema_pb2.SchemaEntry(type=setting_type.value, optional=optional)
+            schema_entry.number_choices.numbers.extend(choices)
+
+    return schema_entry
+

PyAres/Utils/ares_data_type_utils.py

@@ -0,0 +1,36 @@
+from typing import Union
+from ares_datamodel import ares_data_type_pb2
+from ..Models import AresDataType
+
+def python_ares_type_to_proto_ares_type(py_value: AresDataType) -> ares_data_type_pb2.AresDataType:
+  """ A method to convert from the python AresDataType class to the protobuf version """
+  return py_value.value
+
+def proto_ares_type_to_python_ares_type(proto_value: ares_data_type_pb2.AresDataType) -> AresDataType:
+  """ A method to convert from the protobuf AresDataType class to the python version """
+  return AresDataType(proto_value)
+
+def determine_python_ares_data_type(value: Union[int, float, str, bool, list]):
+  """ A method that takes in a value and returns the corresponding `PyAres.Models.AresDataType`"""
+  match value:
+    case str():
+      return AresDataType.STRING
+    case bool():
+      # Boolean is a subtype of int, meaning we have to check if it's a bool
+      # before we check if it's an int, otherwise every bool would return an int instead.
+      return AresDataType.BOOLEAN
+    case int():
+      return AresDataType.NUMBER
+    case float():
+      return AresDataType.NUMBER
+    case list():
+      if(all(isinstance(x, str) for x in value)):
+        return AresDataType.STRING_ARRAY
+      elif(all(isinstance(x, (int, float)) for x in value)):
+        return AresDataType.NUMBER_ARRAY
+      elif(all(isinstance(x, bool)) for x in value):
+        return AresDataType.BOOL_ARRAY
+      else:
+        return AresDataType.UNKNOWN
+    case _:
+      return AresDataType.UNKNOWN

PyAres/Utils/ares_device_command_utils.py

@@ -0,0 +1,43 @@
+from typing import Union
+
+from ..Device import DeviceCommandDescriptor
+from ..Device import DeviceSchemaEntry
+from ares_datamodel.device import device_command_descriptor_pb2
+from ares_datamodel import ares_data_schema_pb2
+
+from . import ares_data_type_utils
+
+def python_command_description_to_proto(python_description: DeviceCommandDescriptor) -> device_command_descriptor_pb2.DeviceCommandDescriptor:
+  proto_description = device_command_descriptor_pb2.DeviceCommandDescriptor()
+  
+  #First, we need to transform our Python DeviceSchemaEntry classes into the protobuf equivalent. Then add them to our new proto message
+  transformed_input_schema = {key: python_device_schema_entry_to_proto(value) for key, value in python_description.input_schema.items()}
+  for key, value in transformed_input_schema.items():
+    new_entry: ares_data_schema_pb2.SchemaEntry = proto_description.input_schema.fields[key]
+    new_entry.CopyFrom(value)
+
+  transformed_output_schema = {key: python_device_schema_entry_to_proto(value) for key, value in python_description.output_schema.items()}
+  for key, value in transformed_output_schema.items():
+    new_entry: ares_data_schema_pb2.SchemaEntry = proto_description.output_schema.fields[key]
+    new_entry.CopyFrom(value)
+
+  proto_description.name = python_description.name
+  proto_description.description = python_description.description
+
+  return proto_description
+
+
+def python_device_schema_entry_to_proto(entry: DeviceSchemaEntry) -> ares_data_schema_pb2.SchemaEntry:
+  proto_schema = ares_data_schema_pb2.SchemaEntry()
+  proto_schema.type = ares_data_type_utils.python_ares_type_to_proto_ares_type(entry.type)
+  proto_schema.optional = entry.optional
+  proto_schema.description = entry.description
+  proto_schema.unit = entry.unit
+  
+  if all(isinstance(x, (int, float)) for x in entry.contraints):
+    proto_schema.number_choices.numbers.extend(entry.contraints)
+
+  elif all(isinstance(x, str) for x in entry.contraints):
+    proto_schema.string_choices.strings.extend(entry.contraints)
+
+  return proto_schema

PyAres/Utils/ares_outcome_utils.py

@@ -0,0 +1,10 @@
+from ..Models import Outcome
+from ares_datamodel import ares_outcome_enum_pb2
+
+def python_ares_outcome_to_proto_ares_outcome(py_value: Outcome) -> ares_outcome_enum_pb2.Outcome:
+  """ A method to convert from the python AresDataType class to the protobuf version """
+  return py_value.value
+
+def proto_ares_outcome_to_python_ares_outcome(proto_value: ares_outcome_enum_pb2.Outcome) -> Outcome:
+  """ A method to convert from the protobuf AresDataType class to the python version """
+  return Outcome(proto_value)