PyAres 0.3.2__tar.gz → 0.4.0__tar.gz

{pyares-0.3.2 → pyares-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.3.2
+Version: 0.4.0
 Summary: The official Python library for ARES.
 Project-URL: Homepage, https://github.com/AFRL-ARES/PyAres
 Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
@@ -9,9 +9,7 @@ License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: ares-datamodel>=0.16.0
-Requires-Dist: grpcio-tools>=1.75.1
-Requires-Dist: grpcio<2.0.0,>=1.71.0
+Requires-Dist: ares-datamodel>=0.20.1
 Description-Content-Type: text/markdown
 
 # PyAres

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Analyzing/analysis_service.py

@@ -36,8 +36,8 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
         self._info = info
         self._timeout = timeout
         self._custom_analysis_logic = custom_analysis_logic
-        self._settings: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
-        self._analysis_parameters: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
+        self._settings: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+        self._analysis_parameters: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
 
     def GetInfo(self, request, context) -> connection_info_pb2.InfoResponse:
         print("Info Requested!")
@@ -138,7 +138,7 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
 
     def ValidateInputs(self, request: analyzer_service.ParameterValidationRequest, context): 
         response = analyzer_service.ParameterValidationResult(success=True)
-        provided_params: Mapping[str, ares_data_schema_pb2.SchemaEntry] = request.input_schema.fields
+        provided_params: Mapping[str, ares_data_schema_pb2.AresValueSchema] = request.input_schema.fields
 
         for stored_key, stored_schema in self._analysis_parameters.items():
             if stored_key in provided_params:

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Demo/device_test.py

@@ -1,5 +1,6 @@
-from PyAres import AresDeviceService, DeviceCommandDescriptor, DeviceSchemaEntry, AresDataType
+from PyAres import *
 from typing import Dict
+import pint
 import time
 
 class DemoDevice:
@@ -25,20 +26,21 @@ class DemoDevice:
 device = DemoDevice()
 
 if __name__ == "__main__":
-  # Basic information about my device
+  ureg = pint.UnitRegistry()  # 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")
+  quantity_schema = QuantitySchema(ureg.degree_Celsius, 40.0, 125.0)
+  parameter_schema = DeviceSchemaEntry(AresDataType.QUANTITY, "A numeric temperature value", quantity_schema=quantity_schema)
   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")}
+  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.QUANTITY, "The current temperature of the device", quantity_schema=quantity_schema)}
   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)
 

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Demo/rotary_mixer.py

@@ -1,14 +1,26 @@
 from PyAres import AresDeviceService, AresDataType, DeviceSchemaEntry, DeviceCommandDescriptor
 
+class RotaryMixer:
+    def __init__(self, speed):
+        self.speed = speed
+
+
+mixer = RotaryMixer(1200)
+
 # 1. Define your hardware logic
 def set_speed(rpm: float):
     print(f"Setting motor speed to {rpm}")
+    mixer.speed = rpm
     # Hardware communication goes here...
     return {} # Return empty dict if no data needs to be sent back
 
+def get_speed():
+    print("Hey I got speed")
+    return { "rpm": mixer.speed }
+
 def get_status():
     # Return a dictionary matching your state schema
-    return { "rpm": 1200 } 
+    return { "rpm": mixer.speed } 
 
 def safe_mode():
     print("Stopping motor immediately!")
@@ -30,8 +42,14 @@ input_schema = {
 }
 cmd_descriptor = DeviceCommandDescriptor("Set Speed", "Sets mixer speed", input_schema, {})
 
+output_schema = {
+    "rpm": DeviceSchemaEntry(AresDataType.NUMBER, "Speed in RPM", "RPM")
+}
+get_speed_descriptor = DeviceCommandDescriptor("Get Speed", "Gets mixer speed", {}, output_schema)
+
 # 4. Register the command
 service.add_new_command(cmd_descriptor, set_speed)
+service.add_new_command(get_speed_descriptor, get_speed)
 
 # 5. Start
 service.start()

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Device/device_models.py

@@ -1,10 +1,16 @@
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 from ..Models import ares_data_models
 
 class DeviceSchemaEntry:
   """ A class that describes an input or output parameter for a device command """
 
-  def __init__(self, type: ares_data_models.AresDataType, description: str = "", unit: str = "", optional: bool = False, constraints: Union[list[int], list[float], list[str]] = []):
+  def __init__(self, type: ares_data_models.AresDataType, description: str = "", unit: str = "", optional: bool = False, 
+               constraints: Union[list[int], list[float], list[str]] = [],
+               quantity_schema: Optional[ares_data_models.QuantitySchema] = None,
+               struct_schema: Optional[Dict[str, 'DeviceSchemaEntry']] = None,
+               list_element_schema: Optional['DeviceSchemaEntry'] = None,
+               min_number_value: Optional[float] = None,
+               max_number_value: Optional[float] = None):
     """
     Initializes a new DeviceSchemaEntry
 
@@ -13,14 +19,24 @@ class DeviceSchemaEntry:
       description (str): A description of the given schema entry
       unit (str): The unit associated with this schema entry
       optional (bool): A boolean value that determines whether or not this schema entry's inclusion is optional
-      contraints (Union[list[int], list[float], list[str]]): An optional list of contraints to limit the number of choices available for this schema entry
+      constraints (Union[list[int], list[float], list[str]]): An optional list of constraints to limit the number of choices available for this schema entry
+      quantity_schema (ares_data_models.QuantitySchema): Optional metadata for quantity types
+      struct_schema (Dict[str, DeviceSchemaEntry]): Optional schema for struct types
+      list_element_schema (DeviceSchemaEntry): Optional schema for list elements
+      min_number_value (float): Optional minimum value for numeric types
+      max_number_value (float): Optional maximum value for numeric types
     """
 
     self.type = type
     self.optional = optional
     self.description = description
     self.unit = unit
-    self.contraints = constraints
+    self.constraints = constraints
+    self.quantity_schema = quantity_schema
+    self.struct_schema = struct_schema
+    self.list_element_schema = list_element_schema
+    self.min_number_value = min_number_value
+    self.max_number_value = max_number_value
 
 class DeviceCommandDescriptor:
   """ A class that contains all the necessary information to describe a device command """

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Device/device_service.py

@@ -37,9 +37,9 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
     self.version = version
     self._enter_safe_mode = enter_safe_mode
     self._update_device_state = update_device_state
-    self._setting_schema: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
-    self._current_settings: Dict[str, ares_struct_pb2.AresValue] = {}
-    self._state_schema: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
+    self._setting_schema: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+    self._current_settings: Dict[str, ares_struct_pb2.AresStruct] = {}
+    self._state_schema: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
     self._commands: list[DeviceCommandDescriptor] = []
     self._command_methods: Dict[str, Callable] = {}
 
@@ -85,8 +85,11 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
       provided_param_dict = ares_struct_utils.ares_struct_to_dict(request.arguments)
       result : Dict[str, Any] = method(**provided_param_dict)
       
-      for key, value in result.items():
-        ares_struct_utils.add_value_to_struct(response.result, key, ares_value_utils.create_ares_value(value))
+      if isinstance(result, dict):
+        for key, value in result.items():
+            ares_struct_utils.add_value_to_struct(response.result.struct_value, key, ares_value_utils.create_ares_value(value))
+      else:
+        response.result.CopyFrom(ares_value_utils.create_ares_value(result))
         
       response.success = True
       return response

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Models/__init__.py

@@ -1,8 +1,10 @@
-from .ares_data_models import AresDataType, Outcome, RequestMetadata, AresSchemaEntry
+from .ares_data_models import AresDataType, Outcome, RequestMetadata, AresSchemaEntry, Quantity, QuantitySchema
 
 __all__ = [
     "AresDataType",
     "Outcome",
     "RequestMetadata",
-    "AresSchemaEntry"
+    "AresSchemaEntry",
+    "Quantity",
+    "QuantitySchema"
 ]

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Models/ares_data_models.py

@@ -2,6 +2,7 @@ from ares_datamodel import request_metadata_pb2
 from enum import Enum
 from dataclasses import dataclass, field
 from typing import Union, List, Optional, Dict
+import pint
 
 class AresDataType(Enum):
     UNKNOWN = 0
@@ -14,6 +15,10 @@ class AresDataType(Enum):
     LIST = 7
     STRUCT = 8
     BYTE_ARRAY = 9
+    ANY = 10
+    UNIT = 11
+    FUNCTION = 12
+    QUANTITY = 13
 
 class Outcome(Enum):
     UNSPECIFIED_OUTCOME = 0
@@ -27,7 +32,9 @@ class 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  
+        self.experiment_id = proto_metadata.experiment_id
+        dt = proto_metadata.experiment_start_time.ToDatetime()
+        self.experiment_start_time = dt.strftime("%Y-%m-%d %H:%M:%S")
 
     @classmethod
     def from_default_values(cls):
@@ -35,6 +42,18 @@ class RequestMetadata():
         default = request_metadata_pb2.RequestMetadata(system_name="TEST SYSTEM", campaign_name="TEST CAMPAIGN", campaign_id="TEST ID", experiment_id="TEST EXPERIMENT ID")
         return cls(default)
 
+@dataclass
+class Quantity:
+    scalar: float
+    type: int # QuantityType enum value
+    unit: str
+
+@dataclass
+class QuantitySchema:
+    bounds_unit: pint.Unit = None
+    min_scalar_value: Optional[float] = None
+    max_scalar_value: Optional[float] = None
+
 @dataclass
 class AresSchemaEntry:
     type: AresDataType
@@ -42,4 +61,8 @@ class AresSchemaEntry:
     description: str = ""
     unit: str = ""
     choices: Union[List[str], List[int], List[float]] = field(default_factory=list)
-    struct_schema: Optional[Dict[str, 'AresSchemaEntry']] = None
+    quantity_schema: Optional[QuantitySchema] = None
+    struct_schema: Optional[Dict[str, 'AresSchemaEntry']] = None
+    list_element_schema: Optional['AresSchemaEntry'] = None
+    min_number_value: Optional[float] = None
+    max_number_value: Optional[float] = None

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Planning/planning_service.py

@@ -37,7 +37,7 @@ class AresPlannerServiceWrapper(planner_service_grpc.AresRemotePlannerServiceSer
         self._service_name: str = service_name
         self._description: str = description
         self._version: str = version
-        self._settings: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
+        self._settings: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
         self._planner_options: list[planner_pb2.Planner] = []
         self._supported_types: list[ares_data_type_pb2.AresDataType] = []
         self._timeout: int = timeout
@@ -54,15 +54,7 @@ class AresPlannerServiceWrapper(planner_service_grpc.AresRemotePlannerServiceSer
         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)
+            capabilities.settings_schema.fields[key].CopyFrom(value)
 
         print("Capabilites Sent!")
         return capabilities

pyares-0.4.0/PyAres/Utils/ares_data_schema_utils.py

@@ -0,0 +1,59 @@
+from typing import Union, Dict, Optional, List
+from ares_datamodel import ares_data_schema_pb2
+from ..Models import ares_data_models
+from ..Models.ares_data_models import AresSchemaEntry
+
+def convert_ares_schema_entry_to_proto(entry: AresSchemaEntry) -> ares_data_schema_pb2.AresValueSchema:
+    proto_entry = create_settings_schema_entry(entry.type, entry.optional, entry.choices, entry.struct_schema)
+    proto_entry.description = entry.description
+    
+    if entry.quantity_schema:
+        proto_entry.quantity_schema.quantity_type = entry.quantity_schema.quantity_type
+        proto_entry.quantity_schema.bounds_unit = entry.quantity_schema.bounds_unit
+        if entry.quantity_schema.min_scalar_value is not None:
+            proto_entry.quantity_schema.min_scalar_value = entry.quantity_schema.min_scalar_value
+        if entry.quantity_schema.max_scalar_value is not None:
+            proto_entry.quantity_schema.max_scalar_value = entry.quantity_schema.max_scalar_value
+
+    if entry.list_element_schema:
+        proto_entry.list_element_schema.CopyFrom(convert_ares_schema_entry_to_proto(entry.list_element_schema))
+
+    if entry.min_number_value is not None:
+        proto_entry.min_number_value = entry.min_number_value
+    if entry.max_number_value is not None:
+        proto_entry.max_number_value = entry.max_number_value
+
+    return proto_entry
+
+def create_settings_schema_entry(
+    setting_type: ares_data_models.AresDataType, 
+    optional: bool, 
+    choices: Union[list[str], list[int], list[float]],
+    struct_schema: Optional[Dict[str, AresSchemaEntry]] = None) -> ares_data_schema_pb2.AresValueSchema:
+    """
+    Creates a protobuf AresValueSchema message from the provided setting details.
+
+    Args:
+        setting_type (AresDataType): The data type of the setting.
+        optional (bool): Whether the setting is optional.
+        choices (Union[list[str], list[int], list[float]]): A list of valid choices for the setting.
+        struct_schema (Optional[Dict[str, AresSchemaEntry]]): Nested schema definition for STRUCT types.
+
+    Returns:
+        (AresValueSchema): A new AresValueSchema message.
+    """
+    schema_entry = ares_data_schema_pb2.AresValueSchema()
+    schema_entry.type = setting_type.value
+    schema_entry.optional = optional
+
+    if isinstance(choices, list) and len(choices) > 0:
+        if all(isinstance(item, str) for item in choices):
+            schema_entry.string_choices.strings.extend(choices)
+        elif all(isinstance(item, (int, float)) for item in choices):
+            schema_entry.number_choices.numbers.extend(choices)
+            
+    if struct_schema is not None:
+        for key, value in struct_schema.items():
+            schema_entry.struct_schema.fields[key].CopyFrom(convert_ares_schema_entry_to_proto(value))
+
+    return schema_entry

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Utils/ares_data_type_utils.py

@@ -11,7 +11,7 @@ def proto_ares_type_to_python_ares_type(proto_value: ares_data_type_pb2.AresData
   """ 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]):
+def determine_python_ares_data_type(value: Union[int, float, str, bool, list, dict, bytes]):
   """ A method that takes in a value and returns the corresponding `PyAres.Models.AresDataType`"""
   match value:
     case str():
@@ -22,6 +22,10 @@ def determine_python_ares_data_type(value: Union[int, float, str, bool, list]):
       return AresDataType.NUMBER
     case float():
       return AresDataType.NUMBER
+    case bytes():
+      return AresDataType.BYTE_ARRAY
+    case dict():
+      return AresDataType.STRUCT
     case list():
       if(all(isinstance(x, bool) for x in value)):
         return AresDataType.LIST
@@ -31,5 +35,9 @@ def determine_python_ares_data_type(value: Union[int, float, str, bool, list]):
         return AresDataType.NUMBER_ARRAY
       else:
         return AresDataType.LIST
+    case None:
+      return AresDataType.NULL
     case _:
+      # If it has specific attributes, it might be a Quantity or other complex type
+      # This part might need more refinement as we define how Quantity looks in Python
       return AresDataType.UNKNOWN

pyares-0.4.0/PyAres/Utils/ares_device_command_utils.py

@@ -0,0 +1,65 @@
+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, ares_data_type_pb2
+from ares_datamodel import to_quantity_schema
+
+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()
+  
+  # Update input_schema (AresStructSchema)
+  for key, value in python_description.input_schema.items():
+    proto_description.input_schema.fields[key].CopyFrom(python_device_schema_entry_to_proto(value))
+
+  # Update output_schema (AresValueSchema)
+  # If there is only one output and the key is empty or "output", we can use it directly.
+  # Otherwise, if there are multiple outputs, we should probably wrap them in a struct.
+  # However, the proto says output_schema is a single AresValueSchema.
+  # For now, let's assume we use the first one if there's only one, or wrap in a struct if there are multiple.
+  if len(python_description.output_schema) == 1:
+    first_val = list(python_description.output_schema.values())[0]
+    proto_description.output_schema.CopyFrom(python_device_schema_entry_to_proto(first_val))
+  elif len(python_description.output_schema) > 1:
+    proto_description.output_schema.type = ares_data_type_pb2.AresDataType.STRUCT
+    for key, value in python_description.output_schema.items():
+      proto_description.output_schema.struct_schema.fields[key].CopyFrom(python_device_schema_entry_to_proto(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.AresValueSchema:
+  proto_schema = ares_data_schema_pb2.AresValueSchema()
+  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
+  
+  if entry.constraints:
+    if all(isinstance(x, (int, float)) for x in entry.constraints):
+      proto_schema.number_choices.numbers.extend(entry.constraints)
+    elif all(isinstance(x, str) for x in entry.constraints):
+      proto_schema.string_choices.strings.extend(entry.constraints)
+
+  # If a quantity schema is provided, utilize it. Use datamodel helpers to create the protobuf representation
+  if entry.quantity_schema:
+    proto_schema.quantity_schema.CopyFrom(to_quantity_schema(entry.quantity_schema.bounds_unit, entry.quantity_schema.min_scalar_value, entry.quantity_schema.max_scalar_value))
+
+  if entry.struct_schema:
+    for key, sub_entry in entry.struct_schema.items():
+      proto_schema.struct_schema.fields[key].CopyFrom(python_device_schema_entry_to_proto(sub_entry))
+
+  if entry.list_element_schema:
+    proto_schema.list_element_schema.CopyFrom(python_device_schema_entry_to_proto(entry.list_element_schema))
+
+  if entry.min_number_value is not None:
+    proto_schema.min_number_value = entry.min_number_value
+  if entry.max_number_value is not None:
+    proto_schema.max_number_value = entry.max_number_value
+
+  return proto_schema

{pyares-0.3.2 → pyares-0.4.0}/PyAres/Utils/ares_value_utils.py

@@ -3,23 +3,33 @@ from ares_datamodel import ares_data_type_pb2
 from typing import Union, Any, Dict
 
 from . import ares_data_type_utils
-from ..Models import AresDataType 
+from ..Models import AresDataType, Quantity
 
 def ares_value_to_py(ares_value: ares_struct_pb2.AresValue):
     """Converts an AresValue protobuf message to a Python native type."""
-    type_map = {
-        "null_value": None,
-        "number_value": ares_value.number_value,
-        "string_value": ares_value.string_value,
-        "bool_value": ares_value.bool_value,
-        "string_array_value": ares_value.string_array_value.strings,
-        "number_array_value": ares_value.number_array_value.numbers,
-        "bytes_value": ares_value.bytes_value
-    }
-    
     field = ares_value.WhichOneof("kind")
-    if field in type_map:
-        return type_map[field]
+    if field == "null_value":
+        return None
+    elif field == "number_value":
+        return ares_value.number_value
+    elif field == "string_value":
+        return ares_value.string_value
+    elif field == "bool_value":
+        return ares_value.bool_value
+    elif field == "string_array_value":
+        return list(ares_value.string_array_value.strings)
+    elif field == "number_array_value":
+        return list(ares_value.number_array_value.numbers)
+    elif field == "bytes_value":
+        return ares_value.bytes_value
+    elif field == "list_value":
+        return [ares_value_to_py(v) for v in ares_value.list_value.values]
+    elif field == "struct_value":
+        return {k: ares_value_to_py(v) for k, v in ares_value.struct_value.fields.items()}
+    elif field == "quantity_value":
+        return Quantity(scalar=ares_value.quantity_value.scalar, 
+                        type=ares_value.quantity_value.type, 
+                        unit=ares_value.quantity_value.unit)
     return None
 
 def py_to_ares_value(py_value, ares_value: ares_struct_pb2.AresValue):
@@ -32,6 +42,13 @@ def py_to_ares_value(py_value, ares_value: ares_struct_pb2.AresValue):
         ares_value.number_value = py_value
     elif isinstance(py_value, bytes):
         ares_value.bytes_value = py_value
+    elif isinstance(py_value, Quantity):
+        ares_value.quantity_value.scalar = py_value.scalar
+        ares_value.quantity_value.type = py_value.type
+        ares_value.quantity_value.unit = py_value.unit
+    elif isinstance(py_value, dict):
+        for k, v in py_value.items():
+            py_to_ares_value(v, ares_value.struct_value.fields[k])
     elif isinstance(py_value, list):
         if(all(isinstance(x, str) for x in py_value)):
             ares_value.string_array_value.strings.extend(py_value)
@@ -47,6 +64,14 @@ def py_to_ares_value(py_value, ares_value: ares_struct_pb2.AresValue):
     else:
         raise TypeError(f"Unsupported type for AresValue: {type(py_value)}")
 
+def create_quantity(value: Quantity) -> ares_struct_pb2.AresValue:
+    """ Creates a new AresValue, initialized to the provided Quantity. """
+    ares_val = ares_struct_pb2.AresValue()
+    ares_val.quantity_value.scalar = value.scalar
+    ares_val.quantity_value.type = value.type
+    ares_val.quantity_value.unit = value.unit
+    return ares_val
+
 def create_number(value: Union[int, float]) -> ares_struct_pb2.AresValue:
     """
     Creates a new AresValue, initialized to the provided number value.
@@ -203,6 +228,8 @@ def create_default(python_datatype: AresDataType) -> ares_struct_pb2.AresValue:
     
     elif(dataType == ares_data_type_pb2.AresDataType.STRUCT):
         return create_struct({})
+    elif(dataType == ares_data_type_pb2.AresDataType.QUANTITY):
+        return create_quantity(Quantity(0, 0, ""))
     else:
         return create_null()
     
@@ -229,6 +256,9 @@ def create_ares_value(value: Any) -> ares_struct_pb2.AresValue:
     elif(isinstance(value, bytes)):
         return create_bytes(value)
     
+    elif(isinstance(value, Quantity)):
+        return create_quantity(value)
+    
     elif(isinstance(value, list)):
         if all(isinstance(x, bool) for x in value):
             return create_array(value)

{pyares-0.3.2 → pyares-0.4.0}/PyAres/__init__.py

@@ -11,4 +11,7 @@ from .Device import AresDeviceService
 from .Device import DeviceCommandDescriptor
 from .Device import DeviceSchemaEntry
 from .Models import AresDataType
-from .Models import Outcome
+from .Models import Outcome
+from .Models import AresSchemaEntry
+from .Models import Quantity
+from .Models import QuantitySchema

{pyares-0.3.2 → pyares-0.4.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "googleapis-common-protos>=1.70.0"]
+requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [project]
@@ -16,9 +16,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "grpcio-tools >= 1.75.1",
-    "grpcio >= 1.71.0, < 2.0.0",
-    "ares-datamodel >= 0.16.0",
+    "ares-datamodel >= 0.20.1",
 ]
 
 [project.urls]

{pyares-0.3.2 → pyares-0.4.0}/tests/test_analyzer.py

@@ -107,7 +107,7 @@ class TestAresAnalyzerService(unittest.TestCase):
         # Case A: Success (Matches Schema)
         req = analyzer_service.ParameterValidationRequest()
         entry = req.input_schema.fields["Voltage"]
-        new_schema_entry = ares_data_schema_pb2.SchemaEntry(type=ares_data_type_pb2.AresDataType.NUMBER, optional=False, description="Voltage value", unit="Volts")
+        new_schema_entry = ares_data_schema_pb2.AresValueSchema(type=ares_data_type_pb2.AresDataType.NUMBER, optional=False, description="Voltage value")
         entry.CopyFrom(new_schema_entry)
         resp = self.service._service_wrapper.ValidateInputs(req, None)
         self.assertTrue(resp.success, "Validation should pass for correct schema")
@@ -115,7 +115,7 @@ class TestAresAnalyzerService(unittest.TestCase):
         # Case B: Failure (Wrong Type)
         req_bad_type = analyzer_service.ParameterValidationRequest()
         bad_entry = req_bad_type.input_schema.fields["Voltage"]
-        bad_schema_entry = ares_data_schema_pb2.SchemaEntry(type=ares_data_type_pb2.AresDataType.STRING, optional=False, description="Voltage value", unit="Volts")
+        bad_schema_entry = ares_data_schema_pb2.AresValueSchema(type=ares_data_type_pb2.AresDataType.STRING, optional=False, description="Voltage value")
         bad_entry.CopyFrom(bad_schema_entry)
         resp_bad = self.service._service_wrapper.ValidateInputs(req_bad_type, None)
         self.assertFalse(resp_bad.success, "Validation should fail for type mismatch")

{pyares-0.3.2 → pyares-0.4.0}/tests/test_ares_data_schema_utils.py

@@ -48,15 +48,13 @@ class TestAresDataSchemaUtils(unittest.TestCase):
             type=AresDataType.NUMBER,
             optional=True,
             description="Test Desc",
-            unit="m/s",
             choices=[1.0, 2.0]
         )
         proto = ares_data_schema_utils.convert_ares_schema_entry_to_proto(py_entry)
         self.assertEqual(proto.type, ares_data_type_pb2.AresDataType.NUMBER)
         self.assertTrue(proto.optional)
         self.assertEqual(proto.description, "Test Desc")
-        self.assertEqual(proto.unit, "m/s")
-        self.assertEqual(proto.number_choices.numbers, [1.0, 2.0])
+        self.assertEqual(list(proto.number_choices.numbers), [1.0, 2.0])
 
     def test_nested_struct_schema(self):
         nested_field = AresSchemaEntry(type=AresDataType.STRING, description="Inner")

{pyares-0.3.2 → pyares-0.4.0}/tests/test_ares_device.py

@@ -111,7 +111,7 @@ class TestAresDeviceService(unittest.TestCase):
         response = self.service._service_wrapper.ExecuteCommand(req, None)
         
         self.assertTrue(response.success, response.error)
-        result_dict = ares_struct_utils.ares_struct_to_dict(response.result)
+        result_dict = ares_struct_utils.ares_struct_to_dict(response.result.struct_value)
         self.assertEqual(result_dict["axis"], "X")
         self.assertEqual(result_dict["final_speed"], 50.0)
 

pyares-0.3.2/PyAres/Utils/ares_data_schema_utils.py

@@ -1,49 +0,0 @@
-from typing import Union, Dict, Optional, List
-from ares_datamodel import ares_data_schema_pb2
-from ..Models import ares_data_models
-from ..Models.ares_data_models import AresSchemaEntry
-
-def convert_ares_schema_entry_to_proto(entry: AresSchemaEntry) -> ares_data_schema_pb2.SchemaEntry:
-    proto_entry = create_settings_schema_entry(entry.type, entry.optional, entry.choices, entry.struct_schema)
-    proto_entry.description = entry.description
-    proto_entry.unit = entry.unit
-    return proto_entry
-
-def create_settings_schema_entry(
-    setting_type: ares_data_models.AresDataType, 
-    optional: bool, 
-    choices: Union[list[str], list[int], list[float]],
-    struct_schema: Optional[Dict[str, AresSchemaEntry]] = None) -> ares_data_schema_pb2.SchemaEntry:
-    """
-    Creates a protobuf SchemaEntry message from the provided setting details.
-
-    Args:
-        setting_type (AresDataType): The data type of the setting.
-        optional (bool): Whether the setting is optional.
-        choices (Union[list[str], list[int], list[float]]): A list of valid choices for the setting.
-        struct_schema (Optional[Dict[str, AresSchemaEntry]]): Nested schema definition for STRUCT types.
-
-    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)
-
-        else:
-            schema_entry = ares_data_schema_pb2.SchemaEntry(type=setting_type.value, optional=optional)
-            
-    if struct_schema is not None:
-        for key, value in struct_schema.items():
-            schema_entry.struct_schema.fields[key].CopyFrom(convert_ares_schema_entry_to_proto(value))
-
-    return schema_entry

pyares-0.3.2/PyAres/Utils/ares_device_command_utils.py

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