PyAres 1.2.0__tar.gz → 1.3.0__tar.gz

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

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

{pyares-1.2.0 → pyares-1.3.0}/PyAres/Analyzing/__init__.py

@@ -1,9 +1,10 @@
 from .analysis_service import AresAnalyzerService
-from .analyzer_models import AnalysisResponse, AnalysisRequest, InfoResponse
+from .analyzer_models import AnalysisResponse, AnalysisRequest, InfoResponse, Objective
 
 __all__ = [
     "AnalysisResponse",
     "AnalysisRequest",
     "InfoResponse",
     "AresAnalyzerService",
+    "Objective"
 ]

pyares-1.3.0/PyAres/Analyzing/analysis_service.py

@@ -0,0 +1,242 @@
+# Standard Imports
+import grpc
+from typing import Callable, Awaitable, Union, Mapping, Dict, Optional, List
+
+# 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 import ares_value_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, ObjectiveSchema
+
+# 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] = {}
+        self._objective_outputs: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+
+    def Analyze(self, request: analyzer_service.AnalysisRequest, context) -> analysis_pb2.AnalysisResponse:
+        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_response = analysis_pb2.AnalysisResponse()
+                proto_response.analysis_outcome = ares_outcome_enum_pb2.FAILURE
+                proto_response.error_string = (
+                    "The user's custom analysis logic returned an invalid type; "
+                    "expected AnalysisResponse."
+                )
+                return proto_response
+
+            if python_response.deprecated_result_usage:
+                print(
+                    "WARNING: AnalysisResponse(result=...) usage is deprecated and will be "
+                    "removed in a future major version. Please construct objectives explicitly."
+                )
+
+            print("Sending AnalysisResponse.....")
+            proto_response = analysis_pb2.AnalysisResponse()
+
+            for obj in python_response.objectives:
+                obj_proto = analysis_pb2.Objective()
+                obj_proto.objective_name = obj.objective_name
+
+                ares_value_utils.py_to_ares_value(obj.objective_value, obj_proto.objective_value)
+
+                if obj.objective_metadata:
+                    ares_struct_utils.dict_to_ares_struct(
+                        obj.objective_metadata, obj_proto.objective_metadata
+                    )
+
+                proto_response.objectives.append(obj_proto)
+
+            proto_response.analysis_outcome = ares_outcome_utils.python_ares_outcome_to_proto_ares_outcome(
+                python_response.outcome
+            )
+            proto_response.error_string = python_response.error_string
+
+            return proto_response
+
+        except Exception as e:
+            context.set_code(grpc.StatusCode.INTERNAL)
+            context.set_details(f"Error in custom analysis logic: {e}")
+            proto_response = analysis_pb2.AnalysisResponse()
+            proto_response.analysis_outcome = ares_outcome_enum_pb2.FAILURE
+            proto_response.error_string = str(e)
+            return proto_response
+
+    def GetAnalysisParameters(self, request, context):
+        print("Analysis Parameters Requested")
+        try:
+            analysis_param_response = analyzer_service.AnalysisParametersResponse()
+
+            for key, value in self._analysis_parameters.items():
+                map_entry = analysis_param_response.parameter_schema.fields[key]
+                map_entry.CopyFrom(value)
+
+            return analysis_param_response
+
+        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)
+
+            for key, value in self._objective_outputs.items():
+                objective_entry = capabilities.objective_output_schema.fields[key]
+                objective_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 "
+                        f"{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, "
+                        f"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,
+        list_element_schema: Optional[AresSchemaEntry] = None,
+    ) -> None:
+        """Adds an analysis parameter that will be reported to ARES.
+
+        If `parameter_type` is LIST, `list_element_schema` can be used to describe
+        the shape of each element in that list.
+        """
+        self._service_wrapper._analysis_parameters[parameter_name] = ares_data_schema_utils.create_settings_schema_entry(
+            setting_type=parameter_type,
+            optional=optional,
+            choices=[],
+            struct_schema=struct_schema,
+            list_element_schema=list_element_schema,
+        )
+
+    def add_objective_output(
+        self,
+        objective_name: str,
+        objective_type: ares_data_models.AresDataType,
+        objective_description: str = "",
+        optional: bool = False,
+        struct_schema: Optional[Dict[str, AresSchemaEntry]] = None,
+        list_element_schema: Optional[AresSchemaEntry] = None,
+    ) -> None:
+        """Adds an analysis objective to the advertised outputs of this analyzer.
+
+        If `objective_type` is LIST, `list_element_schema` can be used to describe
+        the schema of each element in that list.
+        """
+        self._service_wrapper._objective_outputs[objective_name] = ares_data_schema_utils.create_settings_schema_entry(
+            setting_type=objective_type,
+            optional=optional,
+            choices=[],
+            struct_schema=struct_schema,
+            list_element_schema=list_element_schema,
+            description=objective_description,
+        )
+
+    def get_objective_schema(self) -> List[ObjectiveSchema]:
+        """Return a fresh Python representation of the configured objective schema."""
+        schemas: List[ObjectiveSchema] = []
+        for name, proto_schema in self._service_wrapper._objective_outputs.items():
+            schemas.append(ObjectiveSchema(name, proto_schema))
+            
+        return schemas
+

pyares-1.3.0/PyAres/Analyzing/analyzer_models.py

@@ -0,0 +1,248 @@
+from typing import Dict, Any, List, Optional
+import warnings
+from ..Models import Outcome, RequestMetadata, AresDataType, AresSchemaEntry
+from ares_datamodel import ares_data_schema_pb2
+from ..Utils import ares_data_type_utils
+
+class AnalysisRequest:
+    """ Represents an analysis request received from ARES. """
+
+    def __init__(self, inputs: Dict[str, Any], settings: Dict[str, Any], metadata: RequestMetadata):
+        self.inputs = inputs
+        self.settings = settings
+        self.request_metadata = metadata
+
+    def __str__(self) -> str:
+        """Returns a string representation of the AnalysisRequest with all information organized."""
+        metadata_str = str(self.request_metadata).replace('\n', '\n\t')
+        return (f"AnalysisRequest object with:\n"
+                f"  inputs: {self.inputs}\n"
+                f"  settings: {self.settings}\n"
+                f"  metadata: {metadata_str}")
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+class Objective:
+    """ Represents a single analysis objective in the new AnalysisResponse model. """
+
+    def __init__(self, objective_name: str, objective_value: Any, objective_metadata: Optional[Dict[str, Any]] = None):
+        """
+        Initializes a new Objective.
+
+        Args:
+            objective_name: A name the user wants associated with this objective.
+            objective_value: The value associated with this objective, as calculated by the analyzer.
+            objective_metadata: Optional metadata associated with this objective, represented as a dictionary.
+        """
+        self.objective_name = objective_name
+        self.objective_value = objective_value
+        self.objective_metadata = objective_metadata or {}
+
+    def __str__(self) -> str:
+        return (f"Objective object with:\n"
+                f"  objective_name: {self.objective_name}\n"
+                f"  objective_value: {self.objective_value}\n"
+                f"  objective_metadata: {self.objective_metadata}")
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class ObjectiveSchema:
+    """A schema representing the expected form of an objective."""
+
+    def __init__(
+        self,
+        objective_name: str,
+        proto_objective_schema: ares_data_schema_pb2.AresValueSchema,
+    ):
+        self.objective_name = objective_name
+        # Convert basic scalar fields
+        self.objective_type: AresDataType = ares_data_type_utils.proto_ares_type_to_python_ares_type(proto_objective_schema.type)
+        self.objective_description: str = proto_objective_schema.description
+        self.optional: bool = proto_objective_schema.optional
+
+        # Convert nested struct schema, if present
+        self.struct_schema: Optional[Dict[str, AresSchemaEntry]] = None
+        if proto_objective_schema.struct_schema.fields:
+            self.struct_schema = {}
+            for field_name, field_schema in proto_objective_schema.struct_schema.fields.items():
+                self.struct_schema[field_name] = self._proto_value_schema_to_ares_schema_entry(field_schema)
+
+        # Convert list element schema, if present
+        self.list_element_schema: Optional[AresSchemaEntry] = None
+        # Treat type UNKNOWN (0) as "no list element schema configured"
+        if proto_objective_schema.list_element_schema.type != 0:
+            self.list_element_schema = self._proto_value_schema_to_ares_schema_entry(
+                proto_objective_schema.list_element_schema
+            )
+
+    @staticmethod
+    def _proto_value_schema_to_ares_schema_entry(
+        proto: ares_data_schema_pb2.AresValueSchema,
+    ) -> AresSchemaEntry:
+        """Convert a proto AresValueSchema into a Python AresSchemaEntry."""
+        py_type = ares_data_type_utils.proto_ares_type_to_python_ares_type(proto.type)
+
+        # Extract choices if present
+        choices: List[Any] = []
+        if proto.string_choices.strings:
+            choices = list(proto.string_choices.strings)
+        elif proto.number_choices.numbers:
+            choices = list(proto.number_choices.numbers)
+
+        entry = AresSchemaEntry(
+            type=py_type,
+            optional=proto.optional,
+            description=proto.description,
+            choices=choices,
+            struct_schema=None,
+            list_element_schema=None,
+            min_number_value=getattr(proto, "min_number_value", None),
+            max_number_value=getattr(proto, "max_number_value", None),
+        )
+
+        # Nested struct schema
+        if proto.struct_schema.fields:
+            entry.struct_schema = {}
+            for field_name, field_schema in proto.struct_schema.fields.items():
+                entry.struct_schema[field_name] = ObjectiveSchema._proto_value_schema_to_ares_schema_entry(
+                    field_schema
+                )
+
+        # Nested list element schema
+        if proto.list_element_schema.type != 0:
+            entry.list_element_schema = ObjectiveSchema._proto_value_schema_to_ares_schema_entry(
+                proto.list_element_schema
+            )
+
+        return entry
+
+    def __str__(self) -> str:
+        struct_keys = list(self.struct_schema.keys()) if self.struct_schema else []
+        list_elem_type = (
+            self.list_element_schema.type.name
+            if self.list_element_schema and hasattr(self.list_element_schema.type, "name")
+            else None
+        )
+
+        return (
+            f"ObjectiveSchema(\n"
+            f"  objective_name={self.objective_name!r},\n"
+            f"  objective_type={self.objective_type.name if hasattr(self.objective_type, 'name') else self.objective_type},\n"
+            f"  objective_description={self.objective_description!r},\n"
+            f"  optional={self.optional},\n"
+            f"  struct_schema_keys={struct_keys},\n"
+            f"  list_element_type={list_elem_type}\n"
+            f")"
+        )
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class AnalysisResponse:
+    """ Represents the result of an analysis process using objectives. 
+
+    Preferred usage:
+        - Construct with a list of Objective instances:
+            AnalysisResponse(
+                objectives=[
+                    Objective("primary_metric", 0.87, {"units": "accuracy"})
+                ],
+                outcome=Outcome.SUCCESS,
+                error_string=""
+            )
+
+    Deprecated usage:
+        - Construct with a single scalar result (will be removed in a future major version):
+            AnalysisResponse(result=0.87)
+    """
+
+    def __init__(
+        self,
+        objectives: Optional[List[Objective]] = None,
+        outcome: Outcome = Outcome.SUCCESS,
+        error_string: str = "",
+        result: Optional[float] = None,
+    ):
+        """
+        Initializes an AnalysisResponse message.
+
+        Args:
+            objectives: A list of Objective instances representing the objectives returned by analysis.
+            outcome: An Outcome value that represents whether analysis was done successfully.
+            error_string: An optional string argument for passing why analysis failed to ARES.
+            result: DEPRECATED. A single numeric result that will be wrapped into a default Objective. 
+                    This parameter is deprecated and will be removed in a future major version.
+        """
+        self._deprecated_result_usage = False
+
+        if objectives is not None and result is not None:
+            raise ValueError("AnalysisResponse cannot be constructed with both 'objectives' and deprecated 'result'. "
+                             "Use 'objectives' only.")
+
+        if objectives is None and result is not None:
+            # Deprecated path: single scalar result
+            warnings.warn(
+                "AnalysisResponse(result=...) is deprecated; use "
+                "AnalysisResponse(objectives=[Objective(...)]) instead. "
+                "Support will be removed in a future major version.",
+                DeprecationWarning
+            )
+            self._deprecated_result_usage = True
+
+            # Use a default objective name for backward compatibility
+            default_objective = Objective(
+                objective_name="result",
+                objective_value=result,
+                objective_metadata=None,
+            )
+            self.objectives: List[Objective] = [default_objective]
+        elif objectives is not None:
+            self.objectives = objectives
+        else:
+            # No objectives and no result provided: treat as empty objectives
+            self.objectives = []
+
+        self.outcome = outcome
+        self.error_string = error_string
+
+    @property
+    def deprecated_result_usage(self) -> bool:
+        """Indicates whether this AnalysisResponse was created via the deprecated 'result' parameter."""
+        return self._deprecated_result_usage
+
+    def __str__(self) -> str:
+        if not self.objectives:
+            objectives_str = "\t- (none)"
+
+        else:
+            objectives_str = "\n".join(
+                [f"\t- {obj.objective_name}: value={obj.objective_value}, metadata={obj.objective_metadata}"
+                 for obj in self.objectives])
+            
+        return (f"AnalysisResponse object with:\n"
+                f"  objectives:\n{objectives_str}\n"
+                f"  outcome: {self.outcome}\n"
+                f"  error_string: {self.error_string}")
+    
+    def __repr__(self) -> str:
+        return self.__str__()   
+
+class InfoResponse:
+    """ A response message that provides basic information about your analyzer. """   
+
+    def __init__(self, name: str, version: str, description: str = ""):
+        """Initializes a new InfoResponse message.
+
+        Args:
+            name: The name of your analyzer, to be displayed in ARES.
+            version: The specific version of your analyzer. This information is saved in experiment results that use your analyzer.
+            description: An optional (but recommended) string that gives a basic description of your analyzer. 
+        """
+
+        self.name = name
+        self.version = version
+        self.description = description

{pyares-1.2.0 → pyares-1.3.0}/PyAres/Demo/Analyzers/analyzer_wiki.py

@@ -1,4 +1,4 @@
-from PyAres import AresAnalyzerService, AnalysisRequest, AnalysisResponse, AresDataType, Outcome, Limits
+from PyAres import *
 
 def analyze_sample(request: AnalysisRequest) -> AnalysisResponse:
     # 1. Extract inputs
@@ -6,15 +6,17 @@ def analyze_sample(request: AnalysisRequest) -> AnalysisResponse:
     raw_value = request.inputs.get("Growth_Metric")
 
     if raw_value is None:
-        return AnalysisResponse(result=0.0, outcome=Outcome.FAILURE)
+        return AnalysisResponse(objectives=[], outcome=Outcome.FAILURE, error_string="No raw value provided, cannot analyze")
     
     # 2. Perform Logic
     print(f"Analyzing sample with value: {raw_value}")
     
-    calculated_score = raw_value * 1.5 
+    calculated_score = raw_value * 1.5
+
+    objective_score = Objective("Calculated Score", calculated_score) 
     
     # 3. Return Result
-    return AnalysisResponse(result=calculated_score, outcome=Outcome.SUCCESS)
+    return AnalysisResponse(objectives=[objective_score], outcome=Outcome.SUCCESS)
 
 if __name__ == "__main__":
     service = AresAnalyzerService(

pyares-1.3.0/PyAres/Demo/Analyzers/ax_analyzer_test.py

@@ -0,0 +1,80 @@
+from PyAres import *
+import math
+import random
+
+def analyze(request: AnalysisRequest) -> AnalysisResponse:
+    """
+    Evaluates the parameters chosen by your AX Planner and returns a simulated yield.
+    """
+    
+    try:
+        # 1. Extract the values ARES OS logged for this specific iteration.
+        # Ensure the parameter names in your ARES Campaign match these strings exactly.
+        temperature = request.inputs["Temperature"]
+        concentration = request.inputs["Concentration"]
+        
+        # 2. Define the "Hidden Ground Truth"
+        # This is the goal your AX Planner is trying to discover.
+        ideal_temp = 165.0
+        ideal_conc = 3.2
+        max_yield = 100.0
+        
+        # 3. Calculate the distance penalty (the variances control the "width" of the peak)
+        temp_variance = 400.0  
+        conc_variance = 2.0    
+        
+        distance_penalty = (((temperature - ideal_temp) ** 2) / temp_variance) + \
+                           (((concentration - ideal_conc) ** 2) / conc_variance)
+                           
+        # 4. Calculate theoretical yield and add noise
+        simulated_yield = max_yield * math.exp(-distance_penalty)
+        noise = random.gauss(0, 1.5) # mean=0, std_dev=1.5
+        
+        # Clamp the final yield between 0 and 100%
+        final_yield = max(0.0, min(100.0, simulated_yield + noise))
+        
+        print(f"[Demo Analyzer] Received T={temperature:.1f}, C={concentration:.1f} | Calculated Yield: {final_yield:.2f}%")
+    
+        # Preferred new usage: return an objective-based AnalysisResponse
+        return AnalysisResponse(
+            objectives=[
+                Objective(
+                    objective_name="yield",
+                    objective_value=final_yield,
+                    objective_metadata={"units": "%"}
+                )
+            ]
+        )
+
+    except Exception as e:
+        print(f"[Demo Analyzer] Error during analysis: {e}")
+        # If extraction fails (e.g., missing parameter names), return a terrible score so the planner learns to avoid it
+        return AnalysisResponse(
+            objectives=[
+                Objective(
+                    objective_name="yield",
+                    objective_value=None,
+                    objective_metadata={"error": str(e)}
+                )
+            ],
+            outcome=Outcome.FAILURE,
+            error_string=str(e),
+        )
+
+
+
+if __name__ == "__main__":
+    # Initialize the Analyzer Service
+    demo_analyzer = AresAnalyzerService(custom_analysis_logic=analyze,
+    name="Simulated Yield Demo",
+    version="1.0.0",
+    description="Calculates a simulated material yield based on a hidden ideal Temperature (165) and Concentration (3.2).",
+    port=8200)
+
+    demo_analyzer.add_analysis_parameter("Temperature", AresDataType.NUMBER)
+    demo_analyzer.add_analysis_parameter("Concentration", AresDataType.NUMBER)
+
+    demo_analyzer.add_objective_output("yield", AresDataType.NUMBER, "A numeric value that indicates the experiments yielded result")
+
+    print("Starting PyAres Simulated Goal Analyzer...")
+    demo_analyzer.start()

{pyares-1.2.0 → pyares-1.3.0}/PyAres/Demo/Planners/planner_test.py

@@ -8,12 +8,12 @@ def plan(request: PlanRequest) -> PlanResponse:
   gpdoods = []
   names = []
 
-  for i in range(len(request.analysis_results)):
-    currentAnalysis = request.analysis_results[i]
+  for objective_set in request.analysis_objectives:
+    print(f"Received a total of {len(request.analysis_objectives)} objective sets")
 
-    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 objective in objective_set:
+      print(f"Objective Name: {objective.objective_name}")
+      print(f"Objective Value: {objective.objective_value}")
 
     
   for param in request.parameters: