PyAres 0.1.5__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.1.5
+Version: 0.2.0
 Summary: The official Python library for ARES.
 Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
 License-Expression: MIT

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

@@ -245,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.5/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.5 → 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.5 → 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.5 → 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.5 → pyares-0.2.0}/PyAres/Planning/planning_service.py

@@ -248,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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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.5 → pyares-0.2.0}/PyAres.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.1.5
+Version: 0.2.0
 Summary: The official Python library for ARES.
 Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
 License-Expression: MIT

{pyares-0.1.5 → 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.5 → pyares-0.2.0}/README.md

@@ -146,5 +146,7 @@ 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)) <br></br>
-PyAres has been cleared for release under clearance number AFRL-2025-5332.
+
+### CLEARANCE
+Distribution A. Approved for public release: distribution unlimited. AFRL-2025-5332.
 

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

@@ -11,7 +11,7 @@ include = ["PyAres*"]
 
 [project]
 name = "PyAres"
-version = "0.1.5"
+version = "0.2.0"
 authors = [{ name = "AFRL", email = "AFRL.RX.AREScontact@us.af.mil" }]
 description = "The official Python library for ARES."
 license = "MIT"