PyAres 0.1.4__tar.gz → 0.2.0__tar.gz

{pyares-0.1.4 → pyares-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.1.4
+Version: 0.2.0
 Summary: The official Python library for ARES.
 Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
 License-Expression: MIT
@@ -9,5 +9,5 @@ Requires-Python: >=3.10
 License-File: LICENSE
 Requires-Dist: grpcio-tools>=1.75.1
 Requires-Dist: grpcio<2.0.0,>=1.71.0
-Requires-Dist: ares-datamodel>=0.13.2b1
+Requires-Dist: ares-datamodel>=0.15.1b1
 Dynamic: license-file

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Analyzing/analysis_service.py

@@ -177,7 +177,8 @@ class AresAnalyzerService:
                  description: str = "",
                  timeout: int = 30,
                  use_localhost: bool = True,
-                 port: int = 7083):
+                 port: int = 7083,
+                 max_message_size: int = -1):
         """
         Initializes the AresAnalyzerService.
 
@@ -190,11 +191,17 @@ class AresAnalyzerService:
             description (str): A brief description of your analyzer.
             use_localhost (bool): If true, binds to localhost. Otherwise, binds to [::].
             port (int): The port that your analyzer service will serve on. Defaults to port 7083.
+            max_message_size (int): The max size, in megabytes, of the messages your Analysis service is capable of sending. Increasing this can help transfer data like images, but may result in some loss in performance
         """
+
         self.info = InfoResponse(name=name, version=version, description=description)
         self._capabilities = analyzer_capabilities_pb2.AnalyzerCapabilities(settings_schema={})
         self._port = port
-        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+        server_options = []
+        if max_message_size != -1:
+            print("Setting Custom Max Message Size")
+            server_options.append(('grpc.max_receive_message_length', max_message_size * 1024 * 1024))
+        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=server_options)
         self._service_wrapper = AresAnalyzerServiceWrapper(info=self.info, timeout=timeout, custom_analysis_logic=custom_analysis_logic)
         analyzer_service_grpc.add_AresRemoteAnalyzerServiceServicer_to_server(self._service_wrapper, self._server)
 
@@ -238,13 +245,21 @@ class AresAnalyzerService:
         """
         self._capabilities.timeout_seconds = new_timeout
 
-    def start(self):
-        """
-        Starts the service on the specified port, and waits for termination.
+    def start(self, wait_for_termination: bool = True):
+        """ 
+        Starts the service on the specified port, and waits for termination. 
+        
+        Args:
+            wait_for_termination (bool): A boolean value that determines whether the start method will use the "wait_for_termination" blocking call. 
+            If true, the gRPC service will keep the main thread alive but at the cost of blocking any continued execution of your python logic.
+            Setting this value to false will allow you to continue execution after starting your service, however this should ONLY be done if you have
+            another mechanism for keeping your process alive (such as a GUI, or a loop). Defaults to true.
         """
-        print(f"Starting Ares Analyzer Service on port {self._port}...")
+        print(f"Starting Ares Device Service on port {self._port}...")
         self._server.start()
-        self._server.wait_for_termination()
+
+        if wait_for_termination:
+            self._server.wait_for_termination()
 
     def stop(self):
         """

{pyares-0.1.4/PyAres/Test → pyares-0.2.0/PyAres/Demo}/analyzer_test.py

@@ -23,5 +23,7 @@ if __name__ == "__main__":
 
     #Add Analysis Parameters
     pythonDemoAnalyzer.add_analysis_parameter("Temperature", AresDataType.NUMBER)
+    pythonDemoAnalyzer.add_setting(setting_name="", setting_type=AresDataType.NULL, optional=True, constraints=[])
+    pythonDemoAnalyzer.start(wait_for_termination=True)
 
     pythonDemoAnalyzer.start()

pyares-0.2.0/PyAres/Demo/analyzer_test_tools_demo.py

@@ -0,0 +1,19 @@
+from PyAres.test_tools import AnalyzerTestClient
+
+
+if __name__ == "__main__":
+  client = AnalyzerTestClient()
+  
+  # 1. Health Checks
+  client.check_status()
+  client.get_info()
+
+  # 2. Run a Mock Analysis
+  # Replace these keys with actual data your analyzer expects
+  sample_inputs = {
+      "Temperature": 130.5
+  }
+
+  client.run_analysis(inputs=sample_inputs)
+
+    

pyares-0.2.0/PyAres/Demo/analyzer_wiki.py

@@ -0,0 +1,31 @@
+from PyAres import AresAnalyzerService, AnalysisRequest, Analysis, AresDataType, Outcome
+
+def analyze_sample(request: AnalysisRequest) -> Analysis:
+    # 1. Extract inputs
+    # 'Growth_Metric' would come from a sensor or previous step
+    raw_value = request.inputs.get("Growth_Metric")
+
+    if raw_value is None:
+        return Analysis(result=0.0, outcome=Outcome.FAILURE)
+    
+    # 2. Perform Logic
+    print(f"Analyzing sample with value: {raw_value}")
+    
+    calculated_score = raw_value * 1.5 # Placeholder logic
+    is_success = calculated_score > 10.0 # Define success criteria
+    
+    # 3. Return Result
+    return Analysis(result=calculated_score, outcome=Outcome.SUCCESS)
+
+if __name__ == "__main__":
+    service = AresAnalyzerService(
+        analyze_sample, 
+        "Growth Analyzer", 
+        "0.1.0", 
+        "Calculates growth viability"
+    )
+
+    # Define what data we need from ARES
+    service.add_analysis_parameter("Growth_Metric", AresDataType.NUMBER)
+
+    service.start()

pyares-0.2.0/PyAres/Demo/hotplate.py

@@ -0,0 +1,72 @@
+from PyAres import AresDeviceService, AresDataType, DeviceSchemaEntry, DeviceCommandDescriptor
+
+# --- PART 1: The Simulated Hardware ---
+class VirtualHotplate:
+    def __init__(self):
+        self.target_temp = 25.0 # Start at room temp
+    
+    def set_temperature(self, temp: float):
+        """Simulates setting the heater."""
+        print(f"[Hardware] Heating to {temp}°C...")
+        self.target_temp = temp
+        return {} # Return empty dict if no data needs to be sent back
+
+    def get_temperature(self):
+        """Simulates reading the sensor."""
+        # In a real device, you'd read a serial port here.
+        print("[Hardware] Retrieving the current temperature...")
+        return { "current_temp": self.target_temp }
+
+    def get_state(self):
+        """Required: Tells ARES the current status for logging."""
+        return { "current_temp": self.target_temp }
+
+    def safe_mode(self):
+        """Required: A safety fallback (e.g., turn off heat)."""
+        print("[Hardware] SAFE MODE TRIGGERED: Heater off.")
+        self.target_temp = 0.0
+
+# --- PART 2: The Ares Service Wrapper ---
+if __name__ == "__main__":
+    # 1. Initialize the hardware
+    my_hotplate = VirtualHotplate()
+
+    # 2. Define the Service Info
+    service = AresDeviceService(
+        my_hotplate.safe_mode,
+        my_hotplate.get_state,
+        "My Virtual Hotplate",    # Device Name
+        "A simulated lab hotplate", # Description
+        "1.0.0"                   # Version
+    )
+
+    # 3. Define Command: Set Temperature
+    # This schema tells ARES to draw a Number Input box in the UI
+    input_schema = { 
+        "temp": DeviceSchemaEntry(AresDataType.NUMBER, "Target Temperature", "Celsius") 
+    }
+    set_cmd = DeviceCommandDescriptor(
+        "Set Temp", 
+        "Sets the hotplate target temperature", 
+        input_schema, 
+        {} # No output expected
+    )
+    service.add_new_command(set_cmd, my_hotplate.set_temperature)
+
+    # 4. Define Command: Get Temperature
+    # This schema tells ARES to expect a number back
+    output_schema = {
+        "current_temp": DeviceSchemaEntry(AresDataType.NUMBER, "Current Temperature", "Celsius")
+    }
+    get_cmd = DeviceCommandDescriptor(
+        "Get Temp", 
+        "Reads the current temperature", 
+        {}, # No input needed
+        output_schema
+    )
+    service.add_new_command(get_cmd, my_hotplate.get_temperature)
+
+    # 5. Start the Service
+    # This will block and listen for ARES connections
+    print("Virtual Hotplate Service Running...")
+    service.start()

pyares-0.2.0/PyAres/Demo/planner_test_tools_demo.py

@@ -0,0 +1,21 @@
+from PyAres import PlanRequest, PlanningParameter, AresDataType, ParameterHistoryItem
+from PyAres.test_tools import PlannerTestClient
+
+if __name__ == "__main__":
+  client = PlannerTestClient()
+
+  # 1. Health Checks
+  client.check_status()
+  client.get_info()
+
+  # 2. Mock Data
+  planning_parameters = []
+  planning_parameters.append(PlanningParameter("Param One", 0, 100, [ParameterHistoryItem(123, 128)], AresDataType.NUMBER, False, False, "Random Planner"))
+  planning_parameters.append(PlanningParameter("Param Two", 0, 500, [ParameterHistoryItem(132, 122)], AresDataType.NUMBER, False, False, "Random Planner"))
+  planning_parameters.append(PlanningParameter("Param Three", 0, 500, [ParameterHistoryItem(141, 121)], AresDataType.NUMBER, False, False, "Random Planner"))
+  setting_dict = {"Random Setting" : 4000}
+  analysis_results = [10, 20, 30]
+
+  # 3. Create and Send the Request
+  request = PlanRequest(planning_parameters, setting_dict, analysis_results)
+  response = client.run_planning(request)

pyares-0.2.0/PyAres/Demo/planner_wiki.py

@@ -0,0 +1,29 @@
+from PyAres import AresPlannerService, PlanRequest, PlanResponse, AresDataType
+import random
+
+def generate_plan(request: PlanRequest) -> PlanResponse:
+    planned_values = []
+    names = []
+
+    # Iterate through every parameter configured in the ARES Experiment
+    for param in request.parameters:
+        # Simple Logic: Pick a random value within the allowed range
+        val = random.uniform(param.minimum_value, param.maximum_value)
+        
+        names.append(param.name)
+        planned_values.append(val)
+
+    return PlanResponse(parameter_names=names, parameter_values=planned_values)
+
+if __name__ == "__main__":
+    service = AresPlannerService(
+        generate_plan, 
+        "Random Search Planner", 
+        "This planner picks random values within bounds.", 
+        "1.0.0"
+    )
+
+    # Tell ARES we can plan for Numeric values
+    service.add_supported_type(AresDataType.NUMBER)
+
+    service.start()

pyares-0.2.0/PyAres/Demo/rotary_mixer.py

@@ -0,0 +1,37 @@
+from PyAres import AresDeviceService, AresDataType, DeviceSchemaEntry, DeviceCommandDescriptor
+
+# 1. Define your hardware logic
+def set_speed(rpm: float):
+    print(f"Setting motor speed to {rpm}")
+    # Hardware communication goes here...
+    return {} # Return empty dict if no data needs to be sent back
+
+def get_status():
+    # Return a dictionary matching your state schema
+    return { "rpm": 1200 } 
+
+def safe_mode():
+    print("Stopping motor immediately!")
+
+# 2. Initialize Service
+service = AresDeviceService(
+    safe_mode, 
+    get_status, 
+    "Rotary Mixer", 
+    "High-speed mixer control", 
+    "1.0.0",
+    port=7101
+)
+
+# 3. Define the 'Set Speed' Command
+# Input: One number (Speed)
+input_schema = { 
+    "rpm": DeviceSchemaEntry(AresDataType.NUMBER, "Speed in RPM", "RPM") 
+}
+cmd_descriptor = DeviceCommandDescriptor("Set Speed", "Sets mixer speed", input_schema, {})
+
+# 4. Register the command
+service.add_new_command(cmd_descriptor, set_speed)
+
+# 5. Start
+service.start()

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Device/device_service.py

@@ -23,8 +23,8 @@ from ..Utils import ares_data_type_utils
 
 # Type hint for the user's custom methods
 EnterSafeModeMethod = Callable[[], None]
-DeviceCommandMethod = Callable[..., Dict[str, any]]
-DeviceStateMethod = Callable[[], Dict[str, any]]
+DeviceCommandMethod = Callable[..., Dict[str, Any]]
+DeviceStateMethod = Callable[[], Dict[str, Any]]
 
 class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServicer):
   """
@@ -211,7 +211,14 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
 
 class AresDeviceService:
   """ Manages the gRPC service for the AresDeviceSerivce """
-  def __init__(self, enter_safe_mode_logic: EnterSafeModeMethod, get_device_state_logic: DeviceStateMethod, device_name: str, description: str, version: str, use_localhost: bool = True, port: int = 7100):
+  def __init__(self, 
+               enter_safe_mode_logic: EnterSafeModeMethod, 
+               get_device_state_logic: DeviceStateMethod, 
+               device_name: str,
+               description: str, 
+               version: str, 
+               use_localhost: bool = True, 
+               port: int = 7100):
     """
     Initializes the AresDeviceService
     
@@ -273,11 +280,21 @@ class AresDeviceService:
     new_ares_value = ares_value_utils.create_ares_value(setting_value)
     self._service_wrapper._current_settings[setting_name] = new_ares_value
 
-  def start(self):
-    """ Starts the service on the specified port, and waits for termination. """
+  def start(self, wait_for_termination: bool = True):
+    """ 
+    Starts the service on the specified port, and waits for termination. 
+    
+    Args:
+      wait_for_termination (bool): A boolean value that determines whether the start method will use the "wait_for_termination" blocking call. 
+      If true, the gRPC service will keep the main thread alive but at the cost of blocking any continued execution of your python logic.
+      Setting this value to false will allow you to continue execution after starting your service, however this should ONLY be done if you have
+      another mechanism for keeping your process alive (such as a GUI, or a loop). Defaults to true.
+    """
     print(f"Starting Ares Device Service on port {self._port}...")
     self._server.start()
-    self._server.wait_for_termination()
+
+    if wait_for_termination:
+      self._server.wait_for_termination()
 
   def stop(self):
     """ Stops the service, terminating the connection. """

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Models/ares_data_models.py

@@ -24,4 +24,10 @@ 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  
+
+    @classmethod
+    def from_default_values(cls):
+        """ Alternative constructor for creating fake metadata """
+        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)

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Planning/planner_models.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Sequence
 from ..Models import Outcome, AresDataType, RequestMetadata
 
 class ParameterHistoryItem:
@@ -38,23 +38,41 @@ class PlanningParameter:
             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.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 ParamHistoryInfo:
+    """
+    Represents the history of a given parameter.
+
+    Designed to provide a more user-friendly abstraction for interacting with a param history object.
+    """
+    def __init__(self, planned_value: Any, achieved_value: Any):
+        """
+        Initializes a ParamHistoryInfo.
+
+        Args:
+            planned_value (Any): The value given directly from the planner.
+            achieved_value (Any): An optional value that represents the real world achieved value, which may differ from the planners target value.
+        """
+        self.planned_value = planned_value
+        self.achieved_value = achieved_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):
+    def __init__(self, parameters: list[PlanningParameter], settings: Dict[str, Any], analysis_results: Sequence[float], metadata: RequestMetadata = RequestMetadata.from_default_values()):
         """
         Initializes a PlanRequest.
 

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Planning/planning_service.py

@@ -166,19 +166,27 @@ 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):
+    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,
+                 max_message_size: int = -1):
         """
         Initializes the AresPlannerService
 
         Args:
-            custom_plan_logic: A callable function that will be executed when a PlanRequest is received.
+            custom_plan_logic (PlanLogicFunction): 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.
+            service_name (str): The name descriptor that is associated with your planner service.
+            service_description (str): A brief description describing your implementation of the planner service.
+            service_version (str): The version of your planner service.
+            use_localhost (bool): An optional value that allows the user to specify whether to host the service on the local network. Defaults to True.
+            port (int): The port that your planner service will serve on. Defaults to port 7082.
+            max_message_size (int): The max size, in megabytes, of the messages your Planning service is capable of sending. Increasing this can help transfer heavy data like images, but may result in some loss in performance
         """
         #Public Values, designed to be accessible to the user
         self.service_name = service_name
@@ -187,7 +195,11 @@ class AresPlannerService:
 
         #Private values, mostly related to the service
         self._port = port
-        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+        server_options = []
+        if max_message_size != -1:
+            print("Setting Custom Max Message Size")
+            server_options.append(('grpc.max_receive_message_length', max_message_size * 1024 * 1024))
+        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=server_options)
         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):
@@ -236,13 +248,21 @@ class AresPlannerService:
         """
         self._service_wrapper._timeout = new_timeout
 
-    def start(self):
-        """
-        Starts the service on the specified port, and waits for termination.
+    def start(self, wait_for_termination: bool = True):
+        """ 
+        Starts the service on the specified port, and waits for termination. 
+        
+        Args:
+        wait_for_termination (bool): A boolean value that determines whether the start method will use the "wait_for_termination" blocking call. 
+        If true, the gRPC service will keep the main thread alive but at the cost of blocking any continued execution of your python logic.
+        Setting this value to false will allow you to continue execution after starting your service, however this should ONLY be done if you have
+        another mechanism for keeping your process alive (such as a GUI, or a loop). Defaults to true.
         """
-        print(f"Starting Ares Planner Service on port {self._port}...")
+        print(f"Starting Ares Device Service on port {self._port}...")
         self._server.start()
-        self._server.wait_for_termination()
+
+        if wait_for_termination:
+            self._server.wait_for_termination()
 
     def stop(self):
         """

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Utils/ares_data_schema_utils.py

@@ -1,18 +1,6 @@
-from typing import Union, Dict
-
-#Datamodel Imports
+from typing import Union
 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, 
@@ -40,5 +28,9 @@ def create_settings_schema_entry(
             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)
+            
+
     return schema_entry
 

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Utils/ares_data_type_utils.py

@@ -4,7 +4,7 @@ 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
+  return ares_data_type_pb2.AresDataType(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 """
@@ -28,7 +28,7 @@ def determine_python_ares_data_type(value: Union[int, float, str, bool, list]):
         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):
+      elif(all(isinstance(x, bool) for x in value)):
         return AresDataType.BOOL_ARRAY
       else:
         return AresDataType.UNKNOWN

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Utils/ares_outcome_utils.py

@@ -3,7 +3,7 @@ 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
+  return ares_outcome_enum_pb2.Outcome(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 """

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Utils/ares_struct_utils.py

@@ -1,10 +1,10 @@
 from ares_datamodel import ares_struct_pb2
-from typing import Union, Dict
+from typing import Union, Dict, Any
 
 from . import ares_value_utils
 import copy
 
-def ares_struct_to_dict(ares_struct: ares_struct_pb2.AresStruct) -> Dict[str, any]:
+def ares_struct_to_dict(ares_struct: ares_struct_pb2.AresStruct) -> Dict[str, Any]:
     """Converts an AresStruct protobuf message to a Python dictionary."""
     return {k: ares_value_utils.ares_value_to_py(v) for k, v in ares_struct.fields.items()}
 
@@ -62,6 +62,9 @@ def create_bool_struct(key: str, value: bool) -> ares_struct_pb2.AresStruct:
     Returns:
         (AresStruct): A new AresStruct containing the provided key and value.
     """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_bool(value)
+    return new_struct
 
 def create_null_struct(key: str) -> ares_struct_pb2.AresStruct:
     """
@@ -168,7 +171,16 @@ def copy_struct(existing_struct: ares_struct_pb2.AresStruct) -> ares_struct_pb2.
     """
     return copy.deepcopy(existing_struct)
 
-def create_ares_struct(key: str, value: any):
+def create_empty_struct() -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new empty AresStruct
+    
+    Returns:
+        (AresStruct): The newly created empty AresStruct.
+    """
+    return ares_struct_pb2.AresStruct()
+
+def create_ares_struct(key: str, value: Any):
     """
     Creates a new AresStruct using the provided key and value.
 
@@ -181,28 +193,32 @@ def create_ares_struct(key: str, value: any):
     """
 
     if(isinstance(value, str)):
-        return create_string_struct(value)
+        return create_string_struct(key, value)
     
     elif(isinstance(value, (int, float))):
-        return create_number_struct(value)
+        return create_number_struct(key, value)
     
     elif(isinstance(value, bool)):
-        return create_bool_struct(value)
-    
-    elif(isinstance(value, (list[int], list[float]))):
-        return create_number_array_struct(value)
+        return create_bool_struct(key, value)
     
     elif(isinstance(value, bytes)):
-        return create_bytes_array_struct(value)
-    
-    elif(isinstance(value, list[str])):
-        return create_string_array_struct(value)
+        return create_bytes_array_struct(key, value)
     
-    elif(isinstance(value, list[bool])):
-        return create_bool_array_struct(value)
+    elif(isinstance(value, list)):
+        if(len(value) == 0):
+            return create_null_struct(key)
+
+        elif(all(isinstance(item, str) for item in value)):
+            return create_string_array_struct(key, value)
+        
+        elif(all(isinstance(item, (float, int)) for item in value)):
+            return create_number_array_struct(key, value)
+        
+        elif(all(isinstance(item, bool) for item in value)):
+            return create_bool_array_struct(key, value)
     
     else:
-        return create_null_struct()
+        return create_null_struct(key)
 
     
 

{pyares-0.1.4 → pyares-0.2.0}/PyAres/Utils/ares_value_utils.py

@@ -1,8 +1,7 @@
 from ares_datamodel import ares_struct_pb2
 from ares_datamodel import ares_data_type_pb2
-from typing import Union
+from typing import Union, Any
 
-from . import ares_struct_utils
 from . import ares_data_type_utils
 from ..Models import AresDataType 
 
@@ -33,14 +32,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, dict):
-        ares_struct_utils.dict_to_ares_struct(py_value, ares_value.struct_value)
     elif isinstance(py_value, list):
-        for item in py_value:
-            new_val = ares_value.list_value.values.add()
-            py_to_ares_value(item, new_val)
-    elif py_value is None:
-        ares_value.null_value = 0  # google.protobuf.NullValue.NULL_VALUE
+        if(all(isinstance(x, str) for x in py_value)):
+            ares_value.string_array_value.strings.extend(py_value)
+        elif(all(isinstance(x, (int, float)) for x in py_value)):
+            ares_value.number_array_value.numbers.extend(py_value)
+        elif(all(isinstance(x, bool) for x in py_value)):
+            ares_value.bool_array_value.bools.extend(py_value)
     else:
         raise TypeError(f"Unsupported type for AresValue: {type(py_value)}")
 
@@ -137,7 +135,9 @@ def create_bool_array(value: list[bool]) -> ares_struct_pb2.AresValue:
     Returns:
         (AresValue): A new AresValue containing the provided list of booleans.
     """
-    return ares_struct_pb2.AresValue(bool_array_value=value)
+    ares_value = ares_struct_pb2.AresValue()
+    ares_value.bool_array_value.bools.extend(value)
+    return ares_value
 
 def create_default(python_datatype: AresDataType) -> ares_struct_pb2.AresValue:
     """
@@ -177,7 +177,7 @@ def create_default(python_datatype: AresDataType) -> ares_struct_pb2.AresValue:
     else:
         return create_null()
     
-def create_ares_value(value: any) -> ares_struct_pb2.AresValue:
+def create_ares_value(value: Any) -> ares_struct_pb2.AresValue:
     """
     Creates a new AresValue using the provided value.
     If the provided value is not valid for use in an AresValue, a null AresValue is returned.
@@ -198,7 +198,7 @@ def create_ares_value(value: any) -> ares_struct_pb2.AresValue:
         return create_bool(value)
     
     elif(isinstance(value, bytes)):
-        return create_bool_array(value)
+        return create_bytes(value)
     
     elif(isinstance(value, list)):
         if all(isinstance(x, (int, float)) for x in value):
@@ -209,6 +209,9 @@ def create_ares_value(value: any) -> ares_struct_pb2.AresValue:
         
         elif all(isinstance(x, bool) for x in value):
             return create_bool_array(value)
-    
+        
+        else:
+            return create_null()
+        
     else:
         return create_null()

pyares-0.2.0/PyAres/Utils/param_history_info_utils.py

@@ -0,0 +1,10 @@
+from ..Planning import ParameterHistoryItem
+from ares_datamodel.planning import plan_pb2
+from . import ares_value_utils
+
+def convert_proto_param_history_to_python(proto: plan_pb2.ParameterHistoryInfo) -> ParameterHistoryItem:
+  return ParameterHistoryItem(proto.planned_value, proto.achieved_value)
+
+def convert_python_param_history_to_proto(python: ParameterHistoryItem) -> plan_pb2.ParameterHistoryInfo:
+  info = plan_pb2.ParameterHistoryInfo(planned_value=ares_value_utils.create_ares_value(python.planned_value), achieved_value=ares_value_utils.create_ares_value(python.achieved_value))
+  return info

pyares-0.2.0/PyAres/Utils/plan_request_utils.py

@@ -0,0 +1,11 @@
+from ares_datamodel.planning import plan_pb2
+from ..Planning import PlanRequest
+from . import planning_param_utils
+from . import ares_struct_utils
+
+def python_plan_request_to_proto(request: PlanRequest) -> plan_pb2.PlanningRequest:
+  proto_request = plan_pb2.PlanningRequest()
+  proto_request.analysis_results.extend(request.analysis_results)
+  ares_struct_utils.dict_to_ares_struct(request.settings, proto_request.adapter_settings)
+  proto_request.planning_parameters.extend([planning_param_utils.convert_python_plan_param_to_proto(p) for p in request.parameters]) 
+  return proto_request

pyares-0.2.0/PyAres/Utils/plan_response_utils.py

@@ -0,0 +1,16 @@
+from ares_datamodel.planning import plan_pb2
+from ..Planning import PlanResponse
+from . import ares_outcome_utils
+
+def proto_plan_response_to_python(proto_response: plan_pb2.PlanningResponse) -> PlanResponse:
+  param_names = []
+  param_values = []
+
+  for param in proto_response.planned_parameters:
+    param_names.append(param.parameter_name)
+    param_values.append(param.parameter_value)
+
+  python_response = PlanResponse(param_names, param_values)
+  python_response.outcome = ares_outcome_utils.proto_ares_outcome_to_python_ares_outcome(proto_response.planning_outcome)
+  python_response.error_string = proto_response.error_string
+  return python_response

pyares-0.2.0/PyAres/Utils/planning_param_utils.py

@@ -0,0 +1,20 @@
+from ..Planning import PlanningParameter, PlanResponse
+from ares_datamodel.planning import plan_pb2
+from typing import List
+from . import param_history_info_utils
+from . import ares_data_type_utils
+from . import ares_value_utils
+
+def convert_python_plan_param_to_proto(param: PlanningParameter) -> plan_pb2.PlanningParameter:
+  new_proto_param = plan_pb2.PlanningParameter()
+  new_proto_param.parameter_name = param.name
+  new_proto_param.minimum_value = param.minimum_value
+  new_proto_param.maximum_value = param.maximum_value
+  new_proto_param.parameter_history.extend([param_history_info_utils.convert_python_param_history_to_proto(p) for p in param.param_history])
+  new_proto_param.data_type = ares_data_type_utils.python_ares_type_to_proto_ares_type(param.data_type)
+  new_proto_param.is_planned = param.is_planned
+  new_proto_param.is_result = param.is_result
+  new_proto_param.planner_name = param.planner_name
+  ares_value_utils.py_to_ares_value(param.initial_value, new_proto_param.initial_value)
+
+  return new_proto_param 

pyares-0.2.0/PyAres/test_tools/__init__.py

@@ -0,0 +1,2 @@
+from .analyzer_tester import AnalyzerTestClient
+from .planner_tester import PlannerTestClient

pyares-0.2.0/PyAres/test_tools/analyzer_tester.py

@@ -0,0 +1,92 @@
+import grpc
+import time
+from typing import Dict
+
+from ..Utils import ares_struct_utils
+from ares_datamodel.analyzing.remote import ares_remote_analyzer_service_pb2_grpc as analyzer_service_grpc
+from ares_datamodel.analyzing.remote import ares_remote_analyzer_service_pb2 as analyzer_service
+from ares_datamodel import ares_analyzer_management_service_pb2
+from ares_datamodel.connection import connection_status_pb2
+from ares_datamodel.analyzing import analysis_pb2
+from ares_datamodel import ares_outcome_enum_pb2
+
+class AnalyzerTestClient:
+    def __init__(self, port=7083, host='localhost'):
+        """
+        Initializes an AnalyzerTestClient, useful for testing your PyAres Analyzers.
+
+        Args:
+          port (int): The port that your analyzer test client will use to try and reach your service. Defaults to 7083.
+          host (str): The host name that the client will use to try and reach your service. Defaults to localhost.
+        """
+        self.target = f"{host}:{port}"
+        self.channel = grpc.insecure_channel(self.target)
+        self.stub = analyzer_service_grpc.AresRemoteAnalyzerServiceStub(self.channel)
+        print(f"Client connected to {self.target}")
+
+    def get_info(self):
+        """Used to test that your Analyzer Service is providing info properly. If successful outputs the name, version and description of your service."""
+        print("\n--- Testing GetInfo ---")
+        try:
+            request = ares_analyzer_management_service_pb2.AnalyzerInfoRequest() 
+            response = self.stub.GetInfo(request)
+            print(f"Success! Connected to: {response.name} (version {response.version})")
+            print(f"Description: {response.description}")
+
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")
+
+    def check_status(self):
+        """Checks the status of your Analyzer Service"""
+        print("\n--- Testing Connection Status ---")
+        try:
+            request = connection_status_pb2.ConnectionStatusRequest() 
+            response: connection_status_pb2.ConnectionStatus = self.stub.GetConnectionStatus(request)
+            print(f"Status: {response.status}")
+
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")
+
+    def run_analysis(self, inputs: Dict, settings: Dict = { }):
+        """
+        This method is responsible for testing your analysis loop. Simply provide whatever values your analyzer needs to test your logic. 
+        
+        Args:
+          inputs (Dict): The inputs required by your analyzer. Ensure the names (keys) match exactly as your analyzer expects, otherwise analysis will fail
+          settings (Dict): A dictionary that contains any specific settings you want to pass to your analyzer. Defaults to an empty dictionary.
+        """
+        print(f"\n--- Testing Analysis ---")
+        if settings is None:
+            settings = {}
+
+        try:
+            input_struct = ares_struct_utils.create_empty_struct()
+            ares_struct_utils.dict_to_ares_struct(inputs, input_struct)
+            
+            settings_struct = ares_struct_utils.create_empty_struct()
+            ares_struct_utils.dict_to_ares_struct(settings, input_struct)
+
+            request = analyzer_service.AnalysisRequest(inputs=input_struct, settings=settings_struct)
+            
+            start_time = time.perf_counter()
+            response: analysis_pb2.Analysis = self.stub.Analyze(request)
+            end_time = time.perf_counter()
+
+            if response.analysis_outcome == ares_outcome_enum_pb2.SUCCESS:
+                 print(f"Analysis Successful!")
+                 print(f"Result: {response.result}")
+
+            elif response.analysis_outcome == ares_outcome_enum_pb2.WARNING:
+                print("Analysis was successful, but analyzer emitted a warning.")
+                print(f"Result: {response.result}")
+                print(f"#### WARNING: {response.error_string} #####")
+
+            else:
+                 print(f"Analysis Failed (Outcome: {response.analysis_outcome})")
+                 print(f"Error: {response.error_string}")
+
+            elapsed_time = end_time - start_time
+            print(f"Analysis request was completed in: {elapsed_time:.4f} seconds")
+
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")

pyares-0.2.0/PyAres/test_tools/planner_tester.py

@@ -0,0 +1,86 @@
+import grpc
+import time
+from ..Utils import plan_request_utils, plan_response_utils
+from ..Planning import PlanRequest, PlanResponse
+from ..Models import Outcome
+from ares_datamodel.planning.remote import ares_remote_planner_service_pb2_grpc as planner_service_grpc
+from ares_datamodel import ares_planner_management_service_pb2
+from ares_datamodel.connection import connection_status_pb2
+from ares_datamodel.planning import plan_pb2
+from ares_datamodel import ares_outcome_enum_pb2
+from ares_datamodel.connection import connection_info_pb2
+
+class PlannerTestClient:
+    def __init__(self, port=7082, host='localhost'):
+        """
+        Initializes an PlannerTestClient, useful for testing your PyAres Planners.
+
+        Args:
+          port (int): The port that your planner test client will use to try and reach your service. Defaults to 7083.
+          host (str): The host name that the client will use to try and reach your service. Defaults to localhost.
+        """
+        self.target = f"{host}:{port}"
+        self.channel = grpc.insecure_channel(self.target)
+        self.stub = planner_service_grpc.AresRemotePlannerServiceStub(self.channel)
+        print(f"Client connected to {self.target}")
+
+    def get_info(self):
+        """Used to test that your Planner Service is providing info properly. If successful outputs the name, version and description of your service."""
+        print("\n--- Testing GetInfo ---")
+        try:
+            request = ares_planner_management_service_pb2.PlannerInfoRequest() 
+            response: connection_info_pb2.InfoResponse = self.stub.GetInfo(request)
+            print(f"Success! Connected to: {response.name} (version {response.version})")
+            print(f"Description: {response.description}")
+
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")
+
+    def check_status(self):
+        """Checks the status of your Planner Service"""
+        print("\n--- Testing Connection Status ---")
+        try:
+            request = connection_status_pb2.ConnectionStatusRequest() 
+            response: connection_status_pb2.ConnectionStatus = self.stub.GetConnectionStatus(request)
+            print(f"Status: {response.status}")
+
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")
+
+    def run_planning(self, request: PlanRequest) -> PlanResponse:
+        """
+        This method is responsible for testing your planning loop. Simply provide whatever values your planner needs to test your logic. 
+        
+        Args:
+          request (PlanRequest): The self crafted plan request. This should include all relevant data for your planner.
+        """
+        print("\n--- Testing Planning Logic ---")
+
+        try:
+            proto_request = plan_request_utils.python_plan_request_to_proto(request)
+
+            start_time = time.perf_counter()
+            response: plan_pb2.PlanningResponse = self.stub.Plan(proto_request)
+            end_time = time.perf_counter()
+
+            if response.planning_outcome == ares_outcome_enum_pb2.SUCCESS:
+                 print(f"Planning Successful!")
+
+            elif response.planning_outcome == ares_outcome_enum_pb2.WARNING:
+                print("Planning was successful, but planner emitted a warning.")
+                print(f"#### WARNING: {response.error_string} #####")
+
+            else:
+                 print(f"Planning Failed (Outcome: {response.planning_outcome})")
+                 print(f"Error: {response.error_string}")
+
+            elapsed_time = end_time - start_time
+            print(f"Planning request was completed in: {elapsed_time:.4f} seconds")
+
+            return plan_response_utils.proto_plan_response_to_python(response)
+        
+        except grpc.RpcError as e:
+            print(f"RPC Failed: {e.code()} - {e.details()}")
+            return PlanResponse([], [], error_string="GRPC FAILURE", planning_outcome=Outcome.FAILURE)
+
+

{pyares-0.1.4 → pyares-0.2.0}/PyAres.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.1.4
+Version: 0.2.0
 Summary: The official Python library for ARES.
 Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
 License-Expression: MIT
@@ -9,5 +9,5 @@ Requires-Python: >=3.10
 License-File: LICENSE
 Requires-Dist: grpcio-tools>=1.75.1
 Requires-Dist: grpcio<2.0.0,>=1.71.0
-Requires-Dist: ares-datamodel>=0.13.2b1
+Requires-Dist: ares-datamodel>=0.15.1b1
 Dynamic: license-file

{pyares-0.1.4 → pyares-0.2.0}/PyAres.egg-info/SOURCES.txt

@@ -12,6 +12,15 @@ PyAres.egg-info/top_level.txt
 PyAres/Analyzing/__init__.py
 PyAres/Analyzing/analysis_service.py
 PyAres/Analyzing/analyzer_models.py
+PyAres/Demo/analyzer_test.py
+PyAres/Demo/analyzer_test_tools_demo.py
+PyAres/Demo/analyzer_wiki.py
+PyAres/Demo/device_test.py
+PyAres/Demo/hotplate.py
+PyAres/Demo/planner_test.py
+PyAres/Demo/planner_test_tools_demo.py
+PyAres/Demo/planner_wiki.py
+PyAres/Demo/rotary_mixer.py
 PyAres/Device/__init__.py
 PyAres/Device/device_models.py
 PyAres/Device/device_service.py
@@ -21,12 +30,16 @@ PyAres/Models/ares_data_models.py
 PyAres/Planning/__init__.py
 PyAres/Planning/planner_models.py
 PyAres/Planning/planning_service.py
-PyAres/Test/analyzer_test.py
-PyAres/Test/device_test.py
-PyAres/Test/planner_test.py
 PyAres/Utils/ares_data_schema_utils.py
 PyAres/Utils/ares_data_type_utils.py
 PyAres/Utils/ares_device_command_utils.py
 PyAres/Utils/ares_outcome_utils.py
 PyAres/Utils/ares_struct_utils.py
-PyAres/Utils/ares_value_utils.py
+PyAres/Utils/ares_value_utils.py
+PyAres/Utils/param_history_info_utils.py
+PyAres/Utils/plan_request_utils.py
+PyAres/Utils/plan_response_utils.py
+PyAres/Utils/planning_param_utils.py
+PyAres/test_tools/__init__.py
+PyAres/test_tools/analyzer_tester.py
+PyAres/test_tools/planner_tester.py

{pyares-0.1.4 → pyares-0.2.0}/PyAres.egg-info/requires.txt

@@ -1,3 +1,3 @@
 grpcio-tools>=1.75.1
 grpcio<2.0.0,>=1.71.0
-ares-datamodel>=0.13.2b1
+ares-datamodel>=0.15.1b1

{pyares-0.1.4 → pyares-0.2.0}/README.md

@@ -145,4 +145,8 @@ The central component to your PyAres device is your AresDeviceService. This clas
 
 ### 📄 License
 
-The PyAres project is licensed under the MIT License - see details in [LICENSE.txt]([https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE.txt](https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE))
+The PyAres project is licensed under the MIT License - see details in [LICENSE.txt]([https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE.txt](https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE)) <br></br>
+
+### CLEARANCE
+Distribution A. Approved for public release: distribution unlimited. AFRL-2025-5332.
+

{pyares-0.1.4 → pyares-0.2.0}/pyproject.toml

@@ -2,9 +2,6 @@
 requires = [
 	"setuptools>=61.0.0", 
 	"wheel",
-	"grpcio",
-	"grpcio-tools>=1.74.0",
-	"ares-datamodel",
 	"googleapis-common-protos>=1.70.0"
 	]
 build-backend = "setuptools.build_meta"
@@ -14,7 +11,7 @@ include = ["PyAres*"]
 
 [project]
 name = "PyAres"
-version = "0.1.4"
+version = "0.2.0"
 authors = [{ name = "AFRL", email = "AFRL.RX.AREScontact@us.af.mil" }]
 description = "The official Python library for ARES."
 license = "MIT"
@@ -23,7 +20,7 @@ requires-python = ">= 3.10"
 dependencies = [
   "grpcio-tools (>=1.75.1)",
   "grpcio (>=1.71.0,<2.0.0)",
-  "ares-datamodel (>=0.13.2b1)",
+  "ares-datamodel (>=0.15.1b1)",
 ]
 
 [project.urls]