PyAres 0.2.0__tar.gz → 0.2.2__tar.gz

pyares-0.2.2/.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.2.2/.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.2.2/.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.2.2/.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.2.2/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: PyAres
+Version: 0.2.2
+Summary: The official Python library for ARES.
+Project-URL: Homepage, https://github.com/AFRL-ARES
+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.15.1b1
+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.0 → pyares-0.2.2}/PyAres/Analyzing/analysis_service.py

@@ -145,13 +145,14 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
     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():
+            print(f"LOOKING AT {stored_key}")
             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:
+                    print(f" THIS IS THE TYPE RIGHT HERE LOOK AT IT: {type(matching_schema)}")
                     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)
@@ -161,7 +162,7 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
                     response.messages.append(message)
                     print(message)
 
-        if response.messages.count != 0:
+        if len(response.messages) != 0:
             response.success = False
 
         return response

{pyares-0.2.0 → pyares-0.2.2}/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.0 → pyares-0.2.2}/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.0 → pyares-0.2.2}/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()

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

@@ -1,10 +1,11 @@
-from typing import Union
+from typing import Union, cast
 from ares_datamodel import ares_data_type_pb2
 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 ares_data_type_pb2.AresDataType(py_value.value)
+  val = cast(ares_data_type_pb2.AresDataType, py_value.value)
+  return val
 
 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 """

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

@@ -1,9 +1,11 @@
 from ..Models import Outcome
 from ares_datamodel import ares_outcome_enum_pb2
+from typing import cast
 
 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 ares_outcome_enum_pb2.Outcome(py_value.value)
+  val = cast(ares_outcome_enum_pb2.Outcome, py_value.value)
+  return val
 
 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 """