PyAres 0.2.1__tar.gz → 0.3.0__tar.gz

pyares-0.3.0/.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    ignore:
+      - dependency-name: "pyares"
+  - package-ecosystem: "github-actions"
+    directory: /
+    schedule:
+      interval: "weekly"
+    groups:
+      github-actions:
+        patterns: ["*"]

pyares-0.3.0/.github/workflows/pypi.yaml

@@ -0,0 +1,59 @@
+name: Upload PyARES Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    name: Build and Publish Python Distributions to PyPi
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: .
+    
+    steps:
+      - uses: actions/checkout@v6
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.10"
+      - name: Set PyARES Package Name From Tag
+        run: echo "PYARES_PACKAGE_VERSION=${GITHUB_REF/refs\/tags\/v/}" >> $GITHUB_ENV
+      - name: Build Package
+        run: |
+          python -m pip install build
+          python -m build
+      - name: Upload Distribution
+        uses: actions/upload-artifact@v6
+        with:
+          name: pyares-release-dists
+          path: dist/
+          if-no-files-found: error
+  
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      id-token: write
+    environment:
+      name: pypi
+      url: https://pypi.org/p/pyares
+    
+    steps:
+      - name: Retrieve Release Distributions
+        uses: actions/download-artifact@v7
+        with:
+          name: pyares-release-dists
+          path: dist/
+      - name: Publish Package
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}
+

pyares-0.3.0/.github/workflows/python-tests.yaml

@@ -0,0 +1,40 @@
+name: PyAres Unit Tests
+
+on:
+  push:
+    branches:
+      - Develop
+  pull_request:
+    branches:
+      - Develop
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    
+    # Optional: Test across multiple Python versions to ensure compatibility
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+
+    steps:
+    - uses: actions/checkout@v6
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Dependencies
+      env:
+        PYARES_PACKAGE_VERSION: "0.0.1"
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e . 
+        pip install grpcio grpcio-tools protobuf pytest
+
+    - name: Run Tests
+      run: |
+        # This discovers all files starting with 'test_' in the 'tests' directory
+        # and runs them.
+        pytest -v tests/

pyares-0.3.0/.gitignore

@@ -0,0 +1,167 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

pyares-0.3.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: PyAres
+Version: 0.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>
+License: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: ares-datamodel>=0.16.0
+Requires-Dist: grpcio-tools>=1.75.1
+Requires-Dist: grpcio<2.0.0,>=1.71.0
+Description-Content-Type: text/markdown
+
+# PyAres
+The PyAres library is designed to provide support for building planners, analyzers and devices as part of your ARES self driving labratory. PyAres leverages the power of protobuf and gRPC to communicate with your ARES system while providing a simple Pythonic API. 
+
+### ✨ Features
+* A Pythonic API built on the performance of Protobuf and gRPC to streamline the creation of self-driving lab components
+* Easily define custom decision-making processes with your own PyAres Planners
+* Integrate custom data processing and intepretation workflows with PyAres Analyzers
+* Connect and control new hardware, making your implementations ARES ready as a PyAres Device
+
+### 🏗️ Installation
+
+PyAres can be installed using pip:
+```console
+pip install PyAres
+```
+
+### 🧠  Planner Usage
+
+Planners can be initialized using the AresPlannerService class. Below is a basic example of setting up a planner.
+
+``` Python
+from PyAres import AresPlannerService
+from PyAres import PlanRequest
+from PyAres import PlanResponse
+from PyAres import AresDataType
+
+import random
+
+def plan(request: PlanRequest) -> PlanResponse:
+    #This is where your custom planning logic goes
+    planned_values = []
+    names = []
+
+    for param in request.parameters:
+        planned_values.append(random.uniform(param.minimum_value, param.maximum_value))
+        names.append(param.name)
+
+    return PlanResponse(parameter_names=names, parameter_values=planned_values)
+
+
+if __name__ == "__main__":
+    #Basic details about your planner
+    name = "Demo Planner"
+    version = "1.0.0"
+    description = "This is a test planner to demonstrate working with PyAres to create planners!"
+    pythonDemoPlanner = AresPlannerService(plan, name, description, version)
+
+    #Add Supported Types
+    pythonDemoPlanner.add_supported_type(AresDataType.NUMBER)
+```
+This example creates a simple planner called "Demo Planner", that supports planning for numeric values. The 'plan' method shown here is where our custom planning logic lives. For this example, we generate a random number between the minimum and maximum value of each provided parameter.
+
+### 🔍 Analyzer Usage
+
+Analyzers can be initialized using the AresAnalyzerService class. Below is a basic example of setting up an analyzer.
+
+```Python
+from PyAres import AresAnalyzerService
+from PyAres import AnalysisRequest
+from PyAres import Analysis
+from PyAres import AresDataType
+
+def analyze(request: AnalysisRequest) -> Analysis:
+    #Custom Analysis Logic
+    growth = request.inputs.get("Growth")
+    temperature = request.inputs.get("Temperature")
+
+    print(f"Growth: {growth}")
+    print(f"Temperature: {temperature}")
+
+    analysis = Analysis(result=growth, success=True)
+    return analysis
+
+
+if __name__ == "__main__":
+    #Basic details about your analyzer
+    name = "Python Test Analyzer"
+    version = "0.0.1"
+    description = "This is a test analyzer to demonstrate working with PyAres to create analyzers!"
+    pythonDemoAnalyzer = AresAnalyzerService(analyze, name, version, description)
+
+    #Add Analysis Parameters
+    pythonDemoAnalyzer.add_analysis_parameter("Growth", AresDataType.NUMBER)
+    pythonDemoAnalyzer.add_analysis_parameter("Temperature", AresDataType.NUMBER)
+
+    pythonDemoAnalyzer.start()
+```
+This example creates a simple analyzer that expects to receive two values from ARES, growth and temperature. It then returns a simple static value of six as the analysis result.
+
+###  💻 Device Usage
+
+PyAres gives you the ability to create devices to communicate with your ARES system. Typically your device would be external hardware connected via serial port or USB to your computer. For demonstration purposes, below is a simulated device that has a modifiable temperature value. It's temperature can be set with the set_temperature method, or retrieved with the get_temperature method. We use a five second delay in the set_temperature method to simulate a delayed response from hardward. It also implements the get_device_state method which returns any data ARES should log as this devices state, and enter_safe_mode to fulfill the required ability for ARES to be able to reset any device to a known state.
+
+```Python
+class DemoDevice:
+  # A simulated device. In reality, these communications would be happening with external hardware over serial, usb, etc.
+  def __init__(self):
+    self.temperature = 0.0
+
+  def set_temperature(self, temperature: float):
+    self.temperature = temperature
+    time.sleep(5)
+    return {}
+
+  def get_temperature(self):
+    # Dictionary key should match what we defined in our schema earlier
+    return { "temperature": self.temperature }
+  
+  def get_device_state(self):
+    state_dictionary = { "temperature": self.temperature }
+    return state_dictionary
+  
+  def enter_safe_mode(self):
+    self.temperature = 0
+```
+
+PyAres can be used to connect this simulated device with ARES. Below is a basic example of setting up a PyAres device.
+
+```Python
+device = DemoDevice()
+
+if __name__ == "__main__":
+  # Basic information about my device
+  device_name = "Demo Device"
+  description = "A device to demonstrate the PyAres device capabilities"
+  version = "1.0.0"
+  device_service = AresDeviceService(device.enter_safe_mode, device.get_device_state, device_name, description, version)
+
+  #Create Command Descriptor, then add command
+  parameter_schema = DeviceSchemaEntry(AresDataType.NUMBER, "A numeric temperature value", "Degree's Celsius")
+  input_schema = { "temperature": parameter_schema }
+  descriptor = DeviceCommandDescriptor("Set Temperature", "Set's the temperature of the demo device to the provided value.", input_schema, {})
+  device_service.add_new_command(descriptor, device.set_temperature)
+
+  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.NUMBER, "The current temperature of the device", "Degree's Celsius")}
+  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)
+
+  #Add Settings
+  device_service.add_setting("Allow Negative Values", True)
+
+  device_service.start()
+```
+The central component to your PyAres device is your AresDeviceService. This class acts as a bridge, managing all gRPC communications between PyAres and ARES, and provides the ability to define the behavior and capabilities of your device. Here we create a device with two commands; "Get Temperature" and "Set Temperature". To define commands in PyAres, you must provide a defined schema for both the input and output of the command in the form of a dictionary. This gives the PyAres user a flexible way to represent the data that your commands expect to receive, as well as the data ARES should expect to come from your commands. This information becomes part of your DeviceCommandDescriptor, which also holds a name for your command as well as a brief description. We then report our command capabilities to ARES via the add_new_command method. This method takes in our descriptor, and a reference to the method you defined for your command. 
+
+### 📄 License
+
+The PyAres project is licensed under the MIT License - see details in [LICENSE.txt]([https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE.txt](https://github.com/AFRL-ARES/PyAres/blob/Develop/LICENSE)) <br></br>
+
+### CLEARANCE
+Distribution A. Approved for public release: distribution unlimited. AFRL-2025-5332.
+

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Analyzing/analysis_service.py

@@ -1,7 +1,7 @@
 # Standard Imports
 import grpc
 from concurrent import futures
-from typing import Callable, Awaitable, Union, Mapping, Dict
+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
@@ -22,6 +22,7 @@ from ..Utils import ares_outcome_utils
 
 # Import python models
 from ..Models import ares_data_models, RequestMetadata
+from ..Models import AresSchemaEntry
 from .analyzer_models import AnalysisRequest, Analysis, InfoResponse
 
 # Type hints for the user's custom logic
@@ -120,14 +121,7 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
         try:
             for(key, value) in self._settings.items():
                 settings_entry = capabilities.settings_schema.fields[key]
-                settings_entry.type = value.type
-                settings_entry.optional = value.optional
-
-                if len(value.string_choices.strings) != 0:
-                    settings_entry.string_choices.strings.extend(value.string_choices.strings)
-
-                elif len(value.number_choices.numbers) != 0:
-                    settings_entry.number_choices.numbers.extend(value.number_choices.numbers)
+                settings_entry.CopyFrom(value)
             
             return capabilities
 
@@ -143,25 +137,21 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
             print(f"Exception while trying to respond to ARES with connection status! {e}")
 
     def ValidateInputs(self, request: analyzer_service.ParameterValidationRequest, context): 
-        print("Validating Inputs")
         response = analyzer_service.ParameterValidationResult(success=True)
-        provided_params: Mapping[str, ares_data_type_pb2.AresDataType] = request.input_schema.fields
+        provided_params: Mapping[str, ares_data_schema_pb2.SchemaEntry] = request.input_schema.fields
 
         for stored_key, stored_schema in self._analysis_parameters.items():
             if stored_key in provided_params:
-                matching_schema = provided_params.get(stored_key)
-                
-                if stored_schema.type != matching_schema:
+                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)
-                    print(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)
-                    print(message)
 
-        if response.messages.count != 0:
+        if len(response.messages) != 0:
             response.success = False
 
         return response
@@ -210,7 +200,7 @@ class AresAnalyzerService:
         else:
             self._server.add_insecure_port(f'[::]:{self._port}')
 
-    def add_setting(self, setting_name: str, setting_type: ares_data_models.AresDataType, optional: bool = True, constraints: Union[list[int], list[str], list[float]] = []):
+    def add_setting(self, setting_name: str, setting_type: ares_data_models.AresDataType, optional: bool = True, constraints: Union[list[int], list[str], list[float]] = [], struct_schema: Optional[Dict[str, AresSchemaEntry]] = None):
         """
         Adds an analyzer setting to be reported to ARES when capabilities are requested.
         While most `PyAres.Models.AresDataType` options are supported, bool arrays and byte arrays
@@ -221,10 +211,11 @@ class AresAnalyzerService:
             setting_type (AresDataType): The type of this settings value.
             optional (bool): Whether the setting is optional.
             constraints: An optional list of values to constrain the available setting choices. Can be integers, strings, or floats.
+            struct_schema: An optional dictionary defining the fields of a STRUCT type setting, using AresSchemaEntry objects.
         """
-        self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(setting_type, optional, constraints)
+        self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(setting_type, optional, constraints, struct_schema)
 
-    def add_analysis_parameter(self, parameter_name: str, parameter_type: ares_data_models.AresDataType, optional: bool = False):
+    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. Analysis parameters are inputs your analyzer accepts from ARES, and will be mapped to command outputs
         in experiment scripts.
@@ -233,8 +224,9 @@ class AresAnalyzerService:
             parameter_name (str): The name of the parameter being created.
             parameter_type (AresDataType): The type associated with the new parameter.
             optional (bool): Defaults to false. Determines whether your analyzer requires this information.
+            struct_schema: An optional dictionary defining the fields of a STRUCT type parameter, using AresSchemaEntry objects.
         """
-        self._service_wrapper._analysis_parameters[parameter_name] = ares_data_schema_utils.create_settings_schema_entry(parameter_type, optional, [])
+        self._service_wrapper._analysis_parameters[parameter_name] = ares_data_schema_utils.create_settings_schema_entry(parameter_type, optional, [], struct_schema)
 
     def set_timeout(self, new_timeout: int):
         """
@@ -267,12 +259,3 @@ class AresAnalyzerService:
         """
         print("Stopping Ares Analyzer Service...")
         self._server.stop(0).wait()
-
-
-
-
-
-
-
-
-

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Device/device_service.py

@@ -128,8 +128,7 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
     try:
       for key, value in self._current_settings.items():
         new_entry = response.settings.fields[key]
-        new_ares_value = ares_value_utils.create_ares_value(value)
-        new_entry.CopyFrom(new_ares_value)
+        new_entry.CopyFrom(value)
 
       return response
     
@@ -138,7 +137,10 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
       return response
   
   def SetSettings(self, request: device_service.SetSettingsRequest, context) -> empty_pb2.Empty:
-    self._current_settings = ares_struct_utils.ares_struct_to_dict(request.settings)
+    for key, value in request.settings.fields.items():
+      if key in self._current_settings:
+        self._current_settings[key] = value
+
     return empty_pb2.Empty()
   
   def GetStateSchema(self, request, context) -> device_service.StateSchemaResponse:
@@ -181,6 +183,10 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
       if polling_info.polling_type == device_polling_settings_pb2.PollingType.INTERVAL:
         delay = polling_info.interval_ms/1000
         while True:
+          if context.is_active() == False:
+            print("Client for ARES device has disconnected.")
+            break
+          
           response = self._update_device_state()
           if isinstance(response, Awaitable):
             response = response.__await__()
@@ -195,11 +201,6 @@ class AresDeviceServiceWrapper(device_service_grpc.AresRemoteDeviceServiceServic
             ares_struct_utils.add_value_to_struct(proto_response.state, key, ares_value_utils.create_ares_value(value))
 
           yield proto_response
-
-          if context.is_active() == False:
-            print("Client for ARES device has disconnected.")
-            break
-
           time.sleep(delay)
       
       else:

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Models/__init__.py

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

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Models/ares_data_models.py

@@ -1,5 +1,7 @@
 from ares_datamodel import request_metadata_pb2
 from enum import Enum
+from dataclasses import dataclass, field
+from typing import Union, List, Optional, Dict
 
 class AresDataType(Enum):
     UNKNOWN = 0
@@ -9,8 +11,9 @@ class AresDataType(Enum):
     NUMBER = 4
     STRING_ARRAY = 5
     NUMBER_ARRAY = 6
-    BYTE_ARRAY = 7
-    BOOL_ARRAY = 8
+    LIST = 7
+    STRUCT = 8
+    BYTE_ARRAY = 9
 
 class Outcome(Enum):
     UNSPECIFIED_OUTCOME = 0
@@ -30,4 +33,13 @@ class RequestMetadata():
     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)
+        return cls(default)
+
+@dataclass
+class AresSchemaEntry:
+    type: AresDataType
+    optional: bool = False
+    description: str = ""
+    unit: str = ""
+    choices: Union[List[str], List[int], List[float]] = field(default_factory=list)
+    struct_schema: Optional[Dict[str, 'AresSchemaEntry']] = None

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Planning/planner_models.py

@@ -41,7 +41,7 @@ class PlanningParameter:
         self.name: str = name
         self.minimum_value: float = minimum_value
         self.maximum_value: float = maximum_value
-        self.param_history: List = param_history
+        self.param_history: List[ParameterHistoryItem] = param_history
         self.data_type: AresDataType = data_type
         self.is_planned: bool = is_planned
         self.is_result: bool = is_result

{pyares-0.2.1 → pyares-0.3.0}/PyAres/Planning/planning_service.py

@@ -56,7 +56,7 @@ class AresPlannerServiceWrapper(planner_service_grpc.AresRemotePlannerServiceSer
         for(key, value) in self._settings.items():
             settings_entry: ares_data_schema_pb2.SchemaEntry = capabilities.settings_schema.fields[key]
             settings_entry.type = value.type
-            settings_entry.optional - value.optional
+            settings_entry.optional = value.optional
 
             if len(value.string_choices.strings) != 0:
                 settings_entry.string_choices.strings.extend(value.string_choices.strings)
@@ -258,7 +258,7 @@ class AresPlannerService:
         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}...")
+        print(f"Starting Ares Planning Service on port {self._port}...")
         self._server.start()
 
         if wait_for_termination:
@@ -269,4 +269,4 @@ class AresPlannerService:
         Stops the service, terminating the connection.
         """
         print("Stopping Ares Planning Service...")
-        self._server.stop(0).wait()       
+        self._server.stop(0).wait()