PyAres 1.1.0__tar.gz → 1.2.0__tar.gz

{pyares-1.1.0 → pyares-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 1.1.0
+Version: 1.2.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>

pyares-1.2.0/PyAres/Analyzing/analysis_service.py

@@ -0,0 +1,147 @@
+# Standard Imports
+import grpc
+from typing import Callable, Awaitable, Union, Mapping, Dict, Optional
+
+# Import generated protobuf and gRPC stubs
+from ares_datamodel.analyzing.remote import ares_remote_analyzer_service_pb2 as analyzer_service
+from ares_datamodel.analyzing.remote import ares_remote_analyzer_service_pb2_grpc as analyzer_service_grpc
+from ares_datamodel.analyzing import analysis_pb2
+from ares_datamodel.analyzing import analyzer_capabilities_pb2
+from ares_datamodel import ares_data_schema_pb2
+from ares_datamodel import ares_outcome_enum_pb2
+
+# Import Utilities
+from ..Utils import ares_struct_utils
+from ..Utils import ares_data_schema_utils
+from ..Utils import ares_outcome_utils
+from ..Utils.ares_service_base import AresServiceWrapperBase, AresBaseService
+
+# Import python models
+from ..Models import ares_data_models, RequestMetadata, AresSchemaEntry
+from .analyzer_models import AnalysisRequest, AnalysisResponse
+
+# Type hints for the user's custom logic
+AnalyzeLogicFunction = Callable[[AnalysisRequest], Union[AnalysisResponse, Awaitable[AnalysisResponse]]]
+
+class AresAnalyzerServiceWrapper(AresServiceWrapperBase, analyzer_service_grpc.AresRemoteAnalyzerServiceServicer):
+    """
+    A wrapper around the gRPC service to expose native Python objects for analysis.
+    """
+    def __init__(self, name: str, version: str, description: str, timeout: int, custom_analysis_logic: AnalyzeLogicFunction):
+        super().__init__(name, version, description, timeout)
+        self._custom_analysis_logic = custom_analysis_logic
+        self._analysis_parameters: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+
+    def Analyze(self, request: analyzer_service.AnalysisRequest, context) -> analysis_pb2.Analysis:
+        print("Received an analysis request!")
+        try:
+            python_request = AnalysisRequest(
+                inputs=ares_struct_utils.ares_struct_to_dict(request.inputs),
+                settings=ares_struct_utils.ares_struct_to_dict(request.settings),
+                metadata=RequestMetadata(request.metadata))
+
+            python_response = self._custom_analysis_logic(python_request)
+            python_response = self._resolve_awaitable(python_response)
+
+            if not isinstance(python_response, AnalysisResponse):
+                print("Analysis response was an invalid type, ")
+                proto_analysis = analysis_pb2.Analysis()
+                proto_analysis.analysis_outcome = ares_outcome_enum_pb2.FAILURE
+                proto_analysis.error_string = "The user's custom analysis logic returned an invalid type, analysis cannot be processed"
+                return proto_analysis
+            
+            print("Sending Analysis Response.....")
+            return analysis_pb2.Analysis(
+                result=python_response.result,
+                analysis_outcome=ares_outcome_utils.python_ares_outcome_to_proto_ares_outcome(python_response.outcome),
+                error_string=python_response.error_string
+            )
+        
+        except Exception as e:
+            context.set_code(grpc.StatusCode.INTERNAL)
+            context.set_details(f"Error in custom analysis logic: {e}")
+            return analysis_pb2.Analysis(analysis_outcome=ares_outcome_enum_pb2.FAILURE, error_string=str(e))
+
+
+    def GetAnalysisParameters(self, request, context):
+        print("Analysis Parameters Requested")
+        try:
+            analysisParamResponse = analyzer_service.AnalysisParametersResponse()
+
+            for key, value in self._analysis_parameters.items():
+                map_entry = analysisParamResponse.parameter_schema.fields[key]
+                map_entry.CopyFrom(value)
+
+            return analysisParamResponse
+    
+        except Exception as e:
+            print(f"Exception while trying to respond to ARES with analysis parameters! {e}")
+
+    def GetAnalyzerCapabilities(self, request, context) -> analyzer_capabilities_pb2.AnalyzerCapabilities:
+        print("Capabilities Requested!")
+        capabilities = analyzer_capabilities_pb2.AnalyzerCapabilities(timeout_seconds=self._timeout)
+        try:
+            for(key, value) in self._settings.items():
+                settings_entry = capabilities.settings_schema.fields[key]
+                settings_entry.CopyFrom(value)
+            
+            return capabilities
+
+        except Exception as e:
+            print(f"Exception while trying to respond to ARES capabilities request! {e}") 
+            return capabilities
+        
+
+    def ValidateInputs(self, request: analyzer_service.ParameterValidationRequest, context): 
+        response = analyzer_service.ParameterValidationResult(success=True)
+        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:
+                matching_schema = provided_params[stored_key]
+                if stored_schema.type != matching_schema.type:
+                    message = f"Schema Mismatch! {stored_key} was provided with the value type {stored_schema.type}, but the value type {matching_schema} was expected!"
+                    response.messages.append(message)
+            else:
+                if not stored_schema.optional:
+                    message = f"Schema Missing! {stored_key} is marked as a required piece of data for analysis, but no assignment was found in the provided schema!"
+                    response.messages.append(message)
+
+        if len(response.messages) != 0:
+            response.success = False
+
+        return response
+ 
+class AresAnalyzerService(AresBaseService):
+    """
+    Manages the gRPC server for the AresAnalyzerService.
+    """
+    def __init__(self,
+                 custom_analysis_logic: AnalyzeLogicFunction,
+                 name: str,
+                 version: str,
+                 description: str = "",
+                 timeout: int = 30,
+                 use_localhost: bool = True,
+                 port: int = 7083,
+                 max_message_size: int = -1):
+        """
+        Initializes the AresAnalyzerService.
+        """
+        super().__init__(
+            service_name=name,
+            description=description,
+            version=version,
+            port=port,
+            use_localhost=use_localhost,
+            max_message_size=max_message_size
+        )
+
+        self._service_wrapper = AresAnalyzerServiceWrapper(name=name, version=version, description=description, timeout=timeout, custom_analysis_logic=custom_analysis_logic)
+        analyzer_service_grpc.add_AresRemoteAnalyzerServiceServicer_to_server(self._service_wrapper, self.get_server())
+
+    def add_analysis_parameter(self, parameter_name: str, parameter_type: ares_data_models.AresDataType, optional: bool = False, struct_schema: Optional[Dict[str, AresSchemaEntry]] = None):
+        """
+        Adds an analysis parameter that will be reported to ARES.
+        """
+        self._service_wrapper._analysis_parameters[parameter_name] = ares_data_schema_utils.create_settings_schema_entry(parameter_type, optional, [], struct_schema)

{pyares-1.1.0 → pyares-1.2.0}/PyAres/Demo/Devices/device_test.py

@@ -30,7 +30,7 @@ if __name__ == "__main__":
   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)
+  device_service = AresDeviceService(device.enter_safe_mode, device.get_device_state, device_name, description, version, False)
 
   # Create the "Set Temperature" Command
   quantity_schema = QuantitySchema(ureg.degree_Celsius, 40.0, 125.0)
@@ -40,7 +40,7 @@ if __name__ == "__main__":
   device_service.add_new_command(set_temp_descriptor, device.set_temperature)
 
   # Create the "Get Temperature" Command
-  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.QUANTITY, "The current temperature of the device", quantity_schema=quantity_schema)}
+  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.NUMBER, "The current temperature of the device")}
   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-1.1.0 → pyares-1.2.0}/PyAres/Demo/Planners/planner_test.py

@@ -8,6 +8,14 @@ def plan(request: PlanRequest) -> PlanResponse:
   gpdoods = []
   names = []
 
+  for i in range(len(request.analysis_results)):
+    currentAnalysis = request.analysis_results[i]
+
+    for j in range(len(currentAnalysis.objectives)):
+      currentObjective : Objective = currentAnalysis.objectives[j]
+      print(f"Analysis Result {i}: Objective number {j} is named {currentObjective.objective_name} and has a value of {currentObjective.objective_value}")
+
+    
   for param in request.parameters:
     if param.planner_name == "GPRDood":
       gpdoods.append(param)

{pyares-1.1.0 → pyares-1.2.0}/PyAres/Device/device_service.py

@@ -2,7 +2,6 @@ import grpc
 import inspect
 import time
 import warnings
-from concurrent import futures
 from typing import Dict, Callable, Awaitable, Union, Any, Optional
 
 from ares_datamodel.device.remote import ares_remote_device_service_pb2 as device_service
@@ -16,13 +15,14 @@ from google.protobuf import empty_pb2
 
 from .device_models import DeviceCommandDescriptor
 from ..Models import Limits
-from .device_models import DeviceCommandDescriptor, DeviceCommandResponse, StatusCode
+from .device_models import DeviceCommandDescriptor, DeviceCommandResponse
 from ..Utils import ares_device_command_utils
 from ..Utils import ares_data_schema_utils
 from ..Utils import ares_struct_utils
 from ..Utils import ares_value_utils
 from ..Utils import ares_data_type_utils
 from ..Utils import device_status_code_utils
+from ..Utils.ares_service_base import AresServiceWrapperBase, AresBaseService
 
 # Type hint for the user's custom methods
 EnterSafeModeMethod = Callable[[], None]
@@ -30,15 +30,19 @@ AllowedReturns = Union[DeviceCommandResponse, Dict[str, Any], Any]
 DeviceCommandMethod = Callable[..., AllowedReturns]
 DeviceStateMethod = Callable[[], Dict[str, Any]]
 
-class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServicer):
+class AresDeviceServiceWrapper(AresServiceWrapperBase, device_service_grpc.AresRemoteDeviceServiceServicer):
   """
   A wrapper around the gRPC service to expose native Python objects for devices
   """
 
-  def __init__(self, device_name: str, description: str, version: str, enter_safe_mode: EnterSafeModeMethod, update_device_state: DeviceStateMethod):
+  def __init__(self, device_name: str, description: str, version: str, timeout: int, enter_safe_mode: EnterSafeModeMethod, update_device_state: DeviceStateMethod):
+    super().__init__(service_name=device_name, version=version, description=description, timeout=timeout)
+
+    # Preserve public attributes for backwards compatibility
     self.device_name = device_name
     self.description = description
     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.AresValueSchema] = {}
@@ -48,13 +52,16 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
     self._command_methods: Dict[str, Callable] = {}
 
   def GetOperationalStatus(self, request, context) -> device_status_pb2.DeviceOperationalStatus:
-    return device_status_pb2.DeviceOperationalStatus(operational_state=device_status_pb2.OperationalState.ACTIVE, message=f"{self.device_name} is active!")
+    return device_status_pb2.DeviceOperationalStatus(
+      operational_state=device_status_pb2.OperationalState.ACTIVE,
+      message=f"{self._service_name} is active!"
+    )
 
   def GetInfo(self, request, context) -> device_service.DeviceInfoResponse:
     info = device_service.DeviceInfoResponse()
-    info.name = self.device_name
-    info.description = self.description
-    info.version = self.version
+    info.name = self._service_name
+    info.description = self._description
+    info.version = self._version
     return info
   
   def GetCommands(self, request, context) -> device_service.CommandsResponse:
@@ -249,7 +256,7 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
     except grpc.RpcError as e:
       print(f"gRPC error occured in device state stream")
 
-class AresDeviceService:
+class AresDeviceService(AresBaseService):
   """ Manages the gRPC service for the AresDeviceSerivce """
   def __init__(self, 
                enter_safe_mode_logic: EnterSafeModeMethod, 
@@ -257,8 +264,10 @@ class AresDeviceService:
                device_name: str,
                description: str, 
                version: str, 
+               timeout: int = 30,
                use_localhost: bool = True, 
-               port: int = 7100):
+               port: int = 7100,
+               max_message_size: int = -1):
     """
     Initializes the AresDeviceService
     
@@ -270,22 +279,28 @@ class AresDeviceService:
       device_name (str): The name description of your device.
       description (str): A brief description of your device.
       version (str): The version associated with your device implementation.
+      timeout (int): Timeout in seconds for service calls reported to ARES.
       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 device service will serve on. Defaults to port 7100.
+      max_message_size (int): Maximum message size for gRPC. Defaults to -1 (use library default).
     """
 
+    super().__init__(
+      service_name=device_name,
+      description=description,
+      version=version,
+      port=port,
+      use_localhost=use_localhost,
+      max_message_size=max_message_size
+    )
+
+    # Preserve these public attributes for backwards compatibility
     self.device_name = device_name
     self.description = description
     self.version = version
 
-    self._port = port
-    self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
-    self._service_wrapper = AresDeviceServiceWrapper(device_name, description, version, enter_safe_mode_logic, get_device_state_logic)
-    device_service_grpc.add_AresRemoteDeviceServiceServicer_to_server(self._service_wrapper, self._server)
-    if(use_localhost):
-      self._server.add_insecure_port(f'localhost:{self._port}')
-    else:
-      self._server.add_insecure_port(f'[::]:{self._port}')
+    self._service_wrapper = AresDeviceServiceWrapper(device_name, description, version, timeout, enter_safe_mode_logic, get_device_state_logic)
+    device_service_grpc.add_AresRemoteDeviceServiceServicer_to_server(self._service_wrapper, self.get_server())
 
   def add_new_command(self, cmd_descriptor: DeviceCommandDescriptor, method):
     """
@@ -345,12 +360,13 @@ class AresDeviceService:
     """
 
     print(f"Starting Ares Device Service on port {self._port}...")
-    self._server.start()
+    server = self.get_server()
+    server.start()
 
     if wait_for_termination:
-      self._server.wait_for_termination()
+      server.wait_for_termination()
 
   def stop(self):
     """ Stops the service, terminating the connection. """
     print("Stopping Ares Device Service...")
-    self._server.stop(0).wait()    
+    self.get_server().stop(0).wait()    

pyares-1.2.0/PyAres/Planning/planning_service.py

@@ -0,0 +1,166 @@
+import grpc
+import inspect
+import asyncio
+from concurrent import futures
+from typing import Callable, Awaitable, Union, Dict
+
+from ares_datamodel.planning.remote import ares_remote_planner_service_pb2_grpc as planner_service_grpc
+from ares_datamodel.planning import planner_pb2
+from ares_datamodel.planning import planner_service_capabilities_pb2
+from ares_datamodel.planning import plan_pb2
+from ares_datamodel import ares_data_schema_pb2
+from ares_datamodel import ares_data_type_pb2
+from ares_datamodel import ares_outcome_enum_pb2
+from ares_datamodel.connection import connection_state_pb2
+from ares_datamodel.connection import connection_info_pb2
+from ares_datamodel import ares_struct_pb2
+
+# Import Utilities
+from ..Utils import ares_value_utils
+from ..Utils import ares_data_schema_utils
+from ..Utils import ares_data_type_utils
+from ..Utils import ares_struct_utils
+from ..Utils import ares_plan_status_code_utils
+from ..Utils import plan_response_utils
+from ..Utils.ares_service_base import AresServiceWrapperBase, AresBaseService
+from ..Utils.logging_utils import setup_logger
+
+# Import python models
+from ..Models import ares_data_models, Limits
+from .planner_models import *
+
+# Type hint for the user's custom planning logic
+PlanLogicFunction = Callable[[PlanRequest], Union[PlanResponse, Awaitable[PlanResponse], List[Plan], Awaitable[List[Plan]]]]
+
+class AresPlannerServiceWrapper(AresServiceWrapperBase, planner_service_grpc.AresRemotePlannerServiceServicer):
+    """
+    A wrapper around the gRPC service to expose native Python objects for planning
+    """
+    def __init__(self, service_name: str, version: str, description: str, timeout: int, custom_plan_logic: PlanLogicFunction):
+        super().__init__(service_name, version, description, timeout)
+        self._custom_plan_logic: PlanLogicFunction = custom_plan_logic
+        self._current_settings: Dict[str, ares_struct_pb2.AresValue] = {}
+        self._planner_options: list[planner_pb2.Planner] = []
+        self._supported_types: list[ares_data_type_pb2.AresDataType] = []
+
+    def GetPlannerServiceCapabilities(self, request, context) -> planner_service_capabilities_pb2.PlannerServiceCapabilities:
+        print("Capabilities Requested!")
+        capabilities = planner_service_capabilities_pb2.PlannerServiceCapabilities(timeout_seconds=self._timeout)
+        capabilities.service_name = self._service_name
+        capabilities.accepted_types.extend(self._supported_types)
+        capabilities.available_planners.extend(self._planner_options)
+
+        for(key, value) in self._settings.items():
+            capabilities.settings_schema.fields[key].CopyFrom(value)
+
+        print("Capabilites Sent!")
+        return capabilities
+
+    
+    def Plan(self, request: plan_pb2.PlanningRequest, context) -> plan_pb2.PlanningResponse:
+        """
+        Implements the gRPC Plan method. This method converts protobuf requests to native Python objects
+        before executing the users custom planning logic and converting their response back to protobuf.
+        """
+        parameters = []
+        for proto_param in request.planning_parameters:
+            parameters.append(
+                PlanningParameter
+                (
+                    name=proto_param.parameter_name,
+                    maximum_value=proto_param.maximum_value,
+                    minimum_value=proto_param.minimum_value,
+                    param_history=[ParameterHistoryItem(ares_value_utils.ares_value_to_py(val.planned_value), ares_value_utils.ares_value_to_py(val.achieved_value)) for val in proto_param.parameter_history],
+                    data_type=ares_data_type_utils.proto_ares_type_to_python_ares_type(proto_param.data_type),
+                    is_planned=proto_param.is_planned,
+                    is_result=proto_param.is_result,
+                    planner_name=proto_param.planner_name,
+                    initial_value=ares_value_utils.ares_value_to_py(proto_param.initial_value)
+                ))
+        
+        python_request = PlanRequest(parameters=parameters, 
+                                     settings=ares_struct_utils.ares_struct_to_dict(request.adapter_settings), 
+                                     analysis_results=list(request.analysis_results),
+                                     metadata=RequestMetadata(request.metadata),
+                                     batch_size=request.batch_size,
+                                     previous_plan_status_codes=[ares_plan_status_code_utils.proto_plan_status_to_python_plan_status(c) for c in request.previous_plan_status_codes])
+        
+        #Handle call using the user's custom planning logic 
+        response_proto = plan_pb2.PlanningResponse()
+        try:
+            python_response = self._custom_plan_logic(python_request)
+            python_response = self._resolve_awaitable(python_response)
+
+        except Exception as e:
+            #Handle errors from user's logic
+            context.set_code(grpc.StatusCode.INTERNAL)
+            context.set_details(f"Error in custom planning logic: {e}")
+            response_proto.error_string = f"{e}"
+            response_proto.planning_outcome = ares_outcome_enum_pb2.FAILURE
+            return response_proto
+        
+        # This is the depricated response, and should be treated as a single plan. Maybe mention this response is depricated?
+        if isinstance(python_response, PlanResponse):
+            planned_parameters = []
+
+            for i in range(len(python_response.parameter_names)):
+                current_name = python_response.parameter_names[i]
+                current_value = python_response.parameter_values[i]
+
+                new_param = PlannedParameter(current_name, current_value)
+                planned_parameters.append(new_param)
+            
+            python_plan = Plan(planned_parameters, python_response.outcome, python_response.error_string, python_response.objective_status)
+            response_proto.plans.append(plan_response_utils.python_plan_to_proto_plan(python_plan))
+
+        elif isinstance(python_response, List) and all(isinstance(item, Plan) for item in python_response):
+            response_proto.plans.extend(plan_response_utils.python_plan_to_proto_plan(p) for p in python_response)
+
+        else:
+            response_proto.error_string = "The returned response from the user planning method was not valid, users must return either a list of plans or a plan response."
+            response_proto.planning_outcome = ares_outcome_enum_pb2.FAILURE
+        
+        print("Sending Plan Response.....")
+        return response_proto
+    
+class AresPlannerService(AresBaseService):
+    """
+    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,
+                 max_message_size: int = -1):
+        """
+        Initializes the AresPlannerService
+        """
+        super().__init__(
+            service_name=service_name,
+            description=service_description,
+            version=service_version,
+            port=port,
+            use_localhost=use_localhost,
+            max_message_size=max_message_size
+        )
+        
+        # For backwards compatibility with anyone accessing service_description directly
+        self.service_description = service_description
+
+        self._service_wrapper = AresPlannerServiceWrapper(service_name, service_version, service_description, timeout, custom_plan_logic)
+        planner_service_grpc.add_AresRemotePlannerServiceServicer_to_server(self._service_wrapper, self.get_server())
+
+    def add_planner_option(self, planner_name: str, planner_description: str, planner_version: str):
+        """
+        Adds a planner option that is reported to ARES when your services capabilities are requested.
+        """
+        self._service_wrapper._planner_options.append(planner_pb2.Planner(planner_name=planner_name, description=planner_description, version=planner_version))
+
+    def add_supported_type(self, type: ares_data_models.AresDataType):
+        """
+        Adds the specified type to the list of value types your planenr service accepts.
+        """
+        self._service_wrapper._supported_types.append(ares_data_type_utils.python_ares_type_to_proto_ares_type(type))

pyares-1.2.0/PyAres/Utils/ares_service_base.py

@@ -0,0 +1,137 @@
+import grpc
+import asyncio
+import inspect
+from typing import Any, Optional, Union, Dict
+
+from ares_datamodel.connection import connection_state_pb2
+from ares_datamodel.connection import connection_info_pb2
+from ares_datamodel.connection import connection_status_pb2
+from ares_datamodel import ares_data_schema_pb2
+
+from .grpc_base import AresGrpcServiceBase
+from . import ares_value_utils
+from . import ares_data_schema_utils
+
+class AresServiceWrapperBase:
+    """
+    Base class for ARES gRPC service wrappers to provide common connection and info methods.
+    """
+    def __init__(self, service_name: str, version: str, description: str, timeout: int):
+        self._service_name = service_name
+        self._version = version
+        self._description = description
+        self._timeout = timeout
+        self._settings: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+
+    def GetInfo(self, request, context) -> connection_info_pb2.InfoResponse:
+        try:
+            return connection_info_pb2.InfoResponse(
+                name=self._service_name,
+                version=self._version,
+                description=self._description
+            )
+        except Exception as e:
+            return connection_info_pb2.InfoResponse(
+                name="ERROR",
+                version="ERROR",
+                description=f"Error fetching information: {e}"
+            )
+
+    def GetState(self, request, context) -> connection_state_pb2.StateResponse:
+        try:
+            return connection_state_pb2.StateResponse(
+                state=connection_state_pb2.State.ACTIVE, 
+                state_message=f"{self._service_name} is active!"
+            )
+        except Exception as e:
+            return connection_state_pb2.StateResponse(
+                state=connection_state_pb2.State.ERROR, 
+                state_message=f"Exception while trying to respond to ARES with state! {e}"
+            )
+
+    def GetConnectionStatus(self, request, context) -> connection_status_pb2.ConnectionStatus:
+        try:
+            return connection_status_pb2.ConnectionStatus(
+                status=connection_status_pb2.AresStatus.CONNECTED
+            )
+        except Exception as e:
+            # Note: connection_status_pb2 might not have a way to return an error status in the same way.
+            # We return a disconnected status or let gRPC handle the exception.
+            return connection_status_pb2.ConnectionStatus(
+                status=connection_status_pb2.AresStatus.DISCONNECTED
+            )
+
+    def _resolve_awaitable(self, result: Any) -> Any:
+        """
+        Helper to resolve awaitables if the custom logic is async.
+        """
+        if inspect.isawaitable(result):
+            async def resolve(awaitable):
+                return await awaitable
+            return asyncio.run(resolve(result))
+        return result
+
+class AresBaseService(AresGrpcServiceBase):
+    """
+    Base class for ARES services to handle common management logic like settings and timeouts.
+    """
+    def __init__(self, 
+                 service_name: str, 
+                 description: str, 
+                 version: str, 
+                 port: int, 
+                 use_localhost: bool = True, 
+                 max_message_size: int = -1):
+        super().__init__(
+            service_name=service_name,
+            description=description,
+            version=version,
+            port=port,
+            use_localhost=use_localhost,
+            max_message_size=max_message_size
+        )
+
+    def add_setting(self, 
+                    setting_name: str, 
+                    setting_type: Any, 
+                    default_value: Any = None, 
+                    optional: bool = True, 
+                    constraints: Union[list, None] = None, 
+                    struct_schema: Optional[Dict] = None, 
+                    limits: Optional[Any] = None, 
+                    description: Optional[str] = None):
+        """
+        Adds a setting to the service wrapper's settings schema.
+        """
+        try:
+            # Ensure constraints is a list if not provided
+            choices = constraints if constraints is not None else []
+            
+            if default_value is not None:
+                default_ares_value = ares_value_utils.create_ares_value(default_value)
+                self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(
+                    setting_type=setting_type, 
+                    optional=optional, 
+                    choices=choices, 
+                    struct_schema=struct_schema, 
+                    limits=limits, 
+                    default_value=default_ares_value,
+                    description=description
+                )
+            else:
+                self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(
+                    setting_type=setting_type, 
+                    optional=optional, 
+                    choices=choices, 
+                    struct_schema=struct_schema, 
+                    limits=limits, 
+                    description=description
+                )
+        except Exception as e:
+            self._logger.error(f"Encountered an exception while adding setting {setting_name}: {e}")
+
+    def set_timeout(self, new_timeout: int):
+        """
+        Sets the timeout for the service wrapper.
+        """
+        self._service_wrapper._timeout = new_timeout

pyares-1.2.0/PyAres/Utils/datamodel_version_utils.py

@@ -0,0 +1,29 @@
+from importlib import metadata
+
+_DATAMODEL_DIST_NAME = "ares_datamodel"
+_HEADER_NAME = "datamodel-version"
+
+
+def get_datamodel_version() -> str:
+    """
+    Returns the installed version of the ares_datamodel package.
+
+    Falls back to ares_datamodel.__version__ if the distribution metadata
+    is not available, and finally to "unknown" if the package cannot be imported.
+    """
+    try:
+        return metadata.version(_DATAMODEL_DIST_NAME)
+    except metadata.PackageNotFoundError:
+        try:
+            import ares_datamodel  # type: ignore
+
+            return getattr(ares_datamodel, "__version__", "unknown")
+        except ImportError:
+            return "unknown"
+
+
+def get_datamodel_metadata_header() -> tuple[str, str]:
+    """
+    Returns the (key, value) tuple for the outgoing gRPC metadata header.
+    """
+    return _HEADER_NAME, get_datamodel_version()