PyAres 0.3.3__tar.gz → 1.0.0__tar.gz

{pyares-0.3.3 → pyares-1.0.0}/.gitignore

@@ -165,3 +165,9 @@ cython_debug/
 
 # PyPI configuration file
 .pypirc
+
+# VS Code
+.vscode/
+
+#macOS
+.DS_Store

{pyares-0.3.3 → pyares-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAres
-Version: 0.3.3
+Version: 1.0.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,13 +9,13 @@ License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: ares-datamodel>=0.16.1
-Requires-Dist: grpcio-tools>=1.75.1
-Requires-Dist: grpcio<2.0.0,>=1.71.0
+Requires-Dist: ares-datamodel>=0.29.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. 
+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.
+
+You can find additional documentation on PyAres as well as the rest of the ARES ecosystem by visting https://afrl-ares.github.io/ to browse our centralized documentation site.
 
 ### ✨ Features
 * A Pythonic API built on the performance of Protobuf and gRPC to streamline the creation of self-driving lab components
@@ -73,10 +73,10 @@ Analyzers can be initialized using the AresAnalyzerService class. Below is a bas
 ```Python
 from PyAres import AresAnalyzerService
 from PyAres import AnalysisRequest
-from PyAres import Analysis
+from PyAres import AnalysisResponse
 from PyAres import AresDataType
 
-def analyze(request: AnalysisRequest) -> Analysis:
+def analyze(request: AnalysisRequest) -> AnalysisResponse:
     #Custom Analysis Logic
     growth = request.inputs.get("Growth")
     temperature = request.inputs.get("Temperature")
@@ -84,7 +84,7 @@ def analyze(request: AnalysisRequest) -> Analysis:
     print(f"Growth: {growth}")
     print(f"Temperature: {temperature}")
 
-    analysis = Analysis(result=growth, success=True)
+    analysis = AnalysisResponse(result=growth, success=True)
     return analysis
 
 
@@ -119,8 +119,8 @@ class DemoDevice:
     return {}
 
   def get_temperature(self):
-    # Dictionary key should match what we defined in our schema earlier
-    return { "temperature": self.temperature }
+    # Data type should match the one specified in your output schema
+    return self.temperature
   
   def get_device_state(self):
     state_dictionary = { "temperature": self.temperature }

{pyares-0.3.3 → pyares-1.0.0}/PyAres/Analyzing/__init__.py

@@ -1,8 +1,8 @@
 from .analysis_service import AresAnalyzerService
-from .analyzer_models import Analysis, AnalysisRequest, InfoResponse
+from .analyzer_models import AnalysisResponse, AnalysisRequest, InfoResponse
 
 __all__ = [
-    "Analysis",
+    "AnalysisResponse",
     "AnalysisRequest",
     "InfoResponse",
     "AresAnalyzerService",

{pyares-0.3.3 → pyares-1.0.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, Optional
+from typing import Callable, Awaitable, Union, Mapping, Dict, Optional, Any
 
 # Import generated protobuf and gRPC stubs
 from ares_datamodel.analyzing.remote import ares_remote_analyzer_service_pb2 as analyzer_service
@@ -11,7 +11,6 @@ from ares_datamodel.analyzing import analyzer_capabilities_pb2
 from ares_datamodel.connection import connection_state_pb2
 from ares_datamodel.connection import connection_status_pb2
 from ares_datamodel.connection import connection_info_pb2
-from ares_datamodel import ares_data_type_pb2
 from ares_datamodel import ares_data_schema_pb2
 from ares_datamodel import ares_outcome_enum_pb2
 
@@ -19,14 +18,14 @@ from ares_datamodel import ares_outcome_enum_pb2
 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
 
 # Import python models
-from ..Models import ares_data_models, RequestMetadata
-from ..Models import AresSchemaEntry
-from .analyzer_models import AnalysisRequest, Analysis, InfoResponse
+from ..Models import ares_data_models, RequestMetadata, Limits, AresSchemaEntry
+from .analyzer_models import AnalysisRequest, AnalysisResponse, InfoResponse
 
 # Type hints for the user's custom logic
-AnalyzeLogicFunction = Callable[[AnalysisRequest], Union[Analysis, Awaitable[Analysis]]]
+AnalyzeLogicFunction = Callable[[AnalysisRequest], Union[AnalysisResponse, Awaitable[AnalysisResponse]]]
 
 class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerServiceServicer):
     """
@@ -36,8 +35,8 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
         self._info = info
         self._timeout = timeout
         self._custom_analysis_logic = custom_analysis_logic
-        self._settings: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
-        self._analysis_parameters: Dict[str, ares_data_schema_pb2.SchemaEntry] = {}
+        self._settings: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
+        self._analysis_parameters: Dict[str, ares_data_schema_pb2.AresValueSchema] = {}
 
     def GetInfo(self, request, context) -> connection_info_pb2.InfoResponse:
         print("Info Requested!")
@@ -73,7 +72,7 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
             if isinstance(python_response, Awaitable):
                 python_response = python_response.__await__()
 
-            if not isinstance(python_response, Analysis):
+            if not isinstance(python_response, AnalysisResponse):
                 print("Analysis response was an invalid type, ")
                 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"
@@ -138,7 +137,7 @@ class AresAnalyzerServiceWrapper(analyzer_service_grpc.AresRemoteAnalyzerService
 
     def ValidateInputs(self, request: analyzer_service.ParameterValidationRequest, context): 
         response = analyzer_service.ParameterValidationResult(success=True)
-        provided_params: Mapping[str, ares_data_schema_pb2.SchemaEntry] = request.input_schema.fields
+        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:
@@ -200,7 +199,15 @@ 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]] = [], struct_schema: Optional[Dict[str, AresSchemaEntry]] = None):
+    def add_setting(self, 
+                    setting_name: str, 
+                    setting_type: ares_data_models.AresDataType,
+                    default_value: Any = None, 
+                    optional: bool = True, 
+                    constraints: Union[list[int], list[str], list[float]] = [], 
+                    struct_schema: Optional[Dict[str, AresSchemaEntry]] = None, 
+                    limits: Optional[Limits] = None,
+                    description: Optional[str] = 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
@@ -212,8 +219,30 @@ class AresAnalyzerService:
             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.
+            limits: An optional limits object used to specify minimum and maximum values for a setting
+            description: An optional string to describe your setting in more detail. Appears in ARES as a tooltip in the settings menu.
         """
-        self._service_wrapper._settings[setting_name] = ares_data_schema_utils.create_settings_schema_entry(setting_type, optional, constraints, struct_schema)
+        try:
+            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=constraints, 
+                                                                                                                    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=constraints, 
+                                                                                                                    struct_schema=struct_schema, 
+                                                                                                                    limits=limits,
+                                                                                                                    description=description)
+        
+        except Exception as e:
+            print(f"Encountered an exception while adding setting {setting_name}: {e}")
 
     def add_analysis_parameter(self, parameter_name: str, parameter_type: ares_data_models.AresDataType, optional: bool = False, struct_schema: Optional[Dict[str, AresSchemaEntry]] = None):
         """
@@ -247,7 +276,7 @@ class AresAnalyzerService:
             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 Analysis Service on port {self._port}...")
         self._server.start()
 
         if wait_for_termination:

{pyares-0.3.3 → pyares-1.0.0}/PyAres/Analyzing/analyzer_models.py

@@ -9,7 +9,18 @@ class AnalysisRequest:
         self.settings = settings
         self.request_metadata = metadata
 
-class Analysis:
+    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 AnalysisResponse:
     """ Represents the result of an analysis process. """
 
     def __init__(self, result: float, outcome: Outcome = Outcome.SUCCESS, error_string: str = ""):
@@ -24,7 +35,15 @@ class Analysis:
         self.result = result
         self.outcome = outcome
         self.error_string = error_string
-   
+
+    def __str__(self) -> str:
+        return (f"Analysis object with:\n"
+                f"  result: {self.result}\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. """   

pyares-1.0.0/PyAres/Demo/Analyzers/airship_analyzer.py

@@ -0,0 +1,20 @@
+from PyAres import AresAnalyzerService, AnalysisRequest, Analysis, AresDataType, Outcome
+
+def analysis_logic(request: AnalysisRequest):
+  result = int(request.inputs["ShotOutcome"])
+  print(f"Analyzing, result is: {result}")
+  response = Analysis(result=result, outcome=Outcome.SUCCESS)
+  return response
+
+if __name__ == "__main__":
+  print("Welcome to the Airship Analyzer")
+
+  analyzer = AresAnalyzerService(
+    custom_analysis_logic=analysis_logic, 
+    description="An analyzer for use with the Airship Device", 
+    name="Airship Analyzer",
+    version="1.0.0")
+  
+  analyzer.add_analysis_parameter("ShotOutcome", AresDataType.NUMBER)
+
+  analyzer.start()

{pyares-0.3.3/PyAres/Demo → pyares-1.0.0/PyAres/Demo/Analyzers}/analyzer_test.py

@@ -1,16 +1,19 @@
-from PyAres import AresAnalyzerService, AnalysisRequest, Analysis, AresDataType, Outcome
+from PyAres import AresAnalyzerService, AnalysisRequest, AnalysisResponse, AresDataType, Outcome, Limits
 
-def analyze(request: AnalysisRequest) -> Analysis:
+def analyze(request: AnalysisRequest) -> AnalysisResponse:
     #Custom Analysis Logic
-    temperature = request.inputs.get("Temperature")
-
-    if not isinstance(temperature, float):
-        print("Temperature was not a float")
-        temperature = 0.0
-
-    print(f"Temperature: {temperature}")
-
-    analysis = Analysis(result=temperature)
+    temp_one = request.inputs.get("Temperature One")
+    print("Processing Analysis Request")
+
+    if not isinstance(temp_one, float):
+        print("Temperature One was not a float")
+        print(temp_one)
+        temp_one = 0.0
+
+    else:
+        print(f"Temperature One: {temp_one}")
+    
+    analysis = AnalysisResponse(result=temp_one)
     return analysis
 
 
@@ -23,7 +26,5 @@ if __name__ == "__main__":
 
     #Add Analysis Parameters
     pythonDemoAnalyzer.add_analysis_parameter("Temperature", AresDataType.NUMBER)
-    pythonDemoAnalyzer.add_setting(setting_name="", setting_type=AresDataType.NULL, optional=True, constraints=[])
-    pythonDemoAnalyzer.start(wait_for_termination=True)
-
+    pythonDemoAnalyzer.add_setting(setting_name="", setting_type=AresDataType.NULL, optional=True, constraints=[], limits=Limits(0, 10000))
     pythonDemoAnalyzer.start()

{pyares-0.3.3/PyAres/Demo → pyares-1.0.0/PyAres/Demo/Analyzers}/analyzer_wiki.py

@@ -1,21 +1,20 @@
-from PyAres import AresAnalyzerService, AnalysisRequest, Analysis, AresDataType, Outcome
+from PyAres import AresAnalyzerService, AnalysisRequest, AnalysisResponse, AresDataType, Outcome, Limits
 
-def analyze_sample(request: AnalysisRequest) -> Analysis:
+def analyze_sample(request: AnalysisRequest) -> AnalysisResponse:
     # 1. Extract inputs
     # 'Growth_Metric' would come from a sensor or previous step
     raw_value = request.inputs.get("Growth_Metric")
 
     if raw_value is None:
-        return Analysis(result=0.0, outcome=Outcome.FAILURE)
+        return AnalysisResponse(result=0.0, outcome=Outcome.FAILURE)
     
     # 2. Perform Logic
     print(f"Analyzing sample with value: {raw_value}")
     
-    calculated_score = raw_value * 1.5 # Placeholder logic
-    is_success = calculated_score > 10.0 # Define success criteria
+    calculated_score = raw_value * 1.5 
     
     # 3. Return Result
-    return Analysis(result=calculated_score, outcome=Outcome.SUCCESS)
+    return AnalysisResponse(result=calculated_score, outcome=Outcome.SUCCESS)
 
 if __name__ == "__main__":
     service = AresAnalyzerService(
@@ -27,5 +26,10 @@ if __name__ == "__main__":
 
     # Define what data we need from ARES
     service.add_analysis_parameter("Growth_Metric", AresDataType.NUMBER)
+    
+    service.add_setting("Random Setting", AresDataType.NUMBER, 
+                        default_value=250, 
+                        limits=Limits(1, 500),
+                        description="This is a random setting, it is purely for demonstration purposes")
 
     service.start()

{pyares-0.3.3/PyAres/Demo → pyares-1.0.0/PyAres/Demo/Devices}/device_test.py

@@ -1,5 +1,6 @@
-from PyAres import AresDeviceService, DeviceCommandDescriptor, DeviceSchemaEntry, AresDataType
+from PyAres import *
 from typing import Dict
+import pint
 import time
 
 class DemoDevice:
@@ -10,10 +11,10 @@ class DemoDevice:
   def set_temperature(self, temperature: float):
     self.temperature = temperature
     time.sleep(5)
-    return {}
+    return DeviceCommandResponse(None, status_code=StatusCode.COMMAND_SUCCESS)
 
   def get_temperature(self):
-    return { "temperature": self.temperature }
+    return DeviceCommandResponse(self.temperature, status_code=StatusCode.COMMAND_SUCCESS)
   
   def get_device_state(self) -> Dict:
     state_dict = { "temperature": self.temperature }
@@ -25,24 +26,25 @@ class DemoDevice:
 device = DemoDevice()
 
 if __name__ == "__main__":
-  # Basic information about my device
+  ureg = pint.UnitRegistry()  # 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 the "Set Temperature" Command
-  parameter_schema = DeviceSchemaEntry(AresDataType.NUMBER, "A numeric temperature value", "Degree's Celsius")
+  quantity_schema = QuantitySchema(ureg.degree_Celsius, 40.0, 125.0)
+  parameter_schema = DeviceSchemaEntry(AresDataType.QUANTITY, "A numeric temperature value", quantity_schema=quantity_schema)
   input_schema = { "temperature": parameter_schema }
   set_temp_descriptor = DeviceCommandDescriptor("Set Temperature", "Set's the temperature of the demo device to the provided value.", input_schema, {})
   device_service.add_new_command(set_temp_descriptor, device.set_temperature)
 
   # Create the "Get Temperature" Command
-  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.NUMBER, "The current temperature of the device", "Degree's Celsius")}
+  output_schema = {"temperature": DeviceSchemaEntry(AresDataType.QUANTITY, "The current temperature of the device", quantity_schema=quantity_schema)}
   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.add_setting("Allow Negative Values", True, description="A boolean value that determines whether the test device allows negative values")
 
   device_service.start()

pyares-1.0.0/PyAres/Demo/Devices/failure_test_device.py

@@ -0,0 +1,66 @@
+import random
+
+from PyAres import AresDeviceService, AresDataType, DeviceCommandDescriptor, DeviceSchemaEntry
+
+
+class FailureTestDevice:
+    def fail(self):
+        """Intentionally fails so command failure handling can be tested."""
+        print("[Test Device] Running intentionally failing command...")
+        raise RuntimeError("Intentional test command failure")
+
+    def maybe_fail(self):
+        """Fails half the time and otherwise returns 20."""
+        print("[Test Device] Running command with a 50% failure chance...")
+        if random.random() < 0.5:
+            raise RuntimeError("Random test command failure")
+
+        print("[Test Device] Command succeeded and returned 20.")
+        return {"number": 20}
+
+    def get_state(self):
+        return {}
+
+    def safe_mode(self):
+        print("[Test Device] Safe mode triggered.")
+
+
+if __name__ == "__main__":
+    test_device = FailureTestDevice()
+
+    service = AresDeviceService(
+        test_device.safe_mode,
+        test_device.get_state,
+        "Test Device",
+        "A device with commands for testing ARES failure handling",
+        "1.0.0",
+        port=7102,
+    )
+
+    fail_command = DeviceCommandDescriptor(
+        "Fail",
+        "Intentionally throws an exception",
+        {},
+        {},
+    )
+    service.add_new_command(fail_command, test_device.fail)
+
+    maybe_fail_output_schema = {
+        "output": DeviceSchemaEntry(
+            AresDataType.STRUCT,
+            "Successful command output",
+            struct_schema={
+                "number": DeviceSchemaEntry(AresDataType.NUMBER, "Returned Number")
+            },
+        )
+    }
+    maybe_fail_command = DeviceCommandDescriptor(
+        "Maybe Fail",
+        "Has a 50% chance of failing; otherwise returns 20",
+        {},
+        maybe_fail_output_schema,
+    )
+    service.add_new_command(maybe_fail_command, test_device.maybe_fail)
+
+    print("Test Device Service Running...")
+    service.start()

{pyares-0.3.3/PyAres/Demo → pyares-1.0.0/PyAres/Demo/Devices}/hotplate.py

@@ -1,4 +1,4 @@
-from PyAres import AresDeviceService, AresDataType, DeviceSchemaEntry, DeviceCommandDescriptor
+from PyAres import *
 
 # --- PART 1: The Simulated Hardware ---
 class VirtualHotplate:
@@ -8,14 +8,16 @@ class VirtualHotplate:
     def set_temperature(self, temp: float):
         """Simulates setting the heater."""
         print(f"[Hardware] Heating to {temp}°C...")
+        response = DeviceCommandResponse(None, status_code=StatusCode.COMMAND_SUCCESS)
         self.target_temp = temp
-        return {} # Return empty dict if no data needs to be sent back
+        return response
 
     def get_temperature(self):
         """Simulates reading the sensor."""
+        response = DeviceCommandResponse({ "current_temp": self.target_temp }, status_code=StatusCode.COMMAND_SUCCESS)
         # In a real device, you'd read a serial port here.
         print("[Hardware] Retrieving the current temperature...")
-        return { "current_temp": self.target_temp }
+        return response
 
     def get_state(self):
         """Required: Tells ARES the current status for logging."""
@@ -54,9 +56,19 @@ if __name__ == "__main__":
     service.add_new_command(set_cmd, my_hotplate.set_temperature)
 
     # 4. Define Command: Get Temperature
-    # This schema tells ARES to expect a number back
+    # This schema tells ARES to expect a struct back
     output_schema = {
-        "current_temp": DeviceSchemaEntry(AresDataType.NUMBER, "Current Temperature", "Celsius")
+        "output": DeviceSchemaEntry(
+            AresDataType.STRUCT,
+            "Current temperature output",
+            struct_schema={
+                "current_temp": DeviceSchemaEntry(
+                    AresDataType.NUMBER,
+                    "Current Temperature",
+                    "Celsius"
+                )
+            }
+        )
     }
     get_cmd = DeviceCommandDescriptor(
         "Get Temp", 
@@ -69,4 +81,4 @@ if __name__ == "__main__":
     # 5. Start the Service
     # This will block and listen for ARES connections
     print("Virtual Hotplate Service Running...")
-    service.start()
+    service.start()

pyares-1.0.0/PyAres/Demo/Devices/random_number_device.py

@@ -0,0 +1,70 @@
+import random
+
+from PyAres import AresDeviceService, AresDataType, DeviceSchemaEntry, DeviceCommandDescriptor, DeviceCommandResponse, StatusCode
+
+
+# --- PART 1: The Simulated Hardware ---
+class VirtualRandomNumberDevice:
+    def __init__(self):
+        self.last_number = 0
+
+    def generate_number(self):
+        """Simulates reading a random value from hardware."""
+        self.last_number = random.randint(1, 100)
+        print(f"[Hardware] Generated random number: {self.last_number}")
+        response = DeviceCommandResponse({"random_number": self.last_number}, status_code=StatusCode.COMMAND_SUCCESS)
+        return response
+
+    def get_state(self):
+        """Required: Tells ARES the current status for logging."""
+        return {"last_number": self.last_number}
+
+    def safe_mode(self):
+        """Required: A safety fallback."""
+        print("[Hardware] SAFE MODE TRIGGERED: Random number device idle.")
+
+
+# --- PART 2: The Ares Service Wrapper ---
+if __name__ == "__main__":
+    # 1. Initialize the hardware
+    my_random_device = VirtualRandomNumberDevice()
+
+    # 2. Define the Service Info
+    service = AresDeviceService(
+        my_random_device.safe_mode,
+        my_random_device.get_state,
+        "My Virtual Random Number Device",
+        "A simulated device that generates random numbers",
+        "1.0.0",
+        port=7101
+    )
+
+    # 3. Define Command: Generate Number
+    # This schema tells ARES to expect a struct back
+    output_schema = {
+        "output": DeviceSchemaEntry(
+            AresDataType.STRUCT,
+            "Generated random number output",
+            struct_schema={
+                "random_number": DeviceSchemaEntry(
+                    AresDataType.NUMBER,
+                    "Random Number",
+                    "1-100",
+                    min_number_value=1,
+                    max_number_value=100,
+                )
+            },
+        )
+    }
+    generate_cmd = DeviceCommandDescriptor(
+        "Generate Number",
+        "Generates a random number from 1 to 100",
+        {},
+        output_schema,
+    )
+    service.add_new_command(generate_cmd, my_random_device.generate_number)
+
+    # 4. Start the Service
+    # This will block and listen for ARES connections
+    print("Virtual Random Number Device Service Running...")
+    service.start()

pyares-1.0.0/PyAres/Demo/Devices/rotary_mixer.py

@@ -0,0 +1,50 @@
+from PyAres import *
+
+class RotaryMixer:
+    def __init__(self, speed):
+        self.speed = speed
+
+
+mixer = RotaryMixer(1200)
+
+# 1. Define your hardware logic
+def set_speed(rpm: float):
+    print(f"Setting motor speed to {rpm}")
+    mixer.speed = rpm
+    return DeviceCommandResponse(None, status_code=StatusCode.COMMAND_SUCCESS) # Return empty dict if no data needs to be sent back
+
+def get_speed():
+    print("Hey I got speed")
+    return DeviceCommandResponse(mixer.speed, status_code=StatusCode.COMMAND_SUCCESS)
+
+def get_status():
+    # Return a dictionary matching your state schema
+    return { "rpm": mixer.speed } 
+
+def safe_mode():
+    print("Stopping motor immediately!")
+
+# 2. Initialize Service
+service = AresDeviceService(
+    safe_mode, 
+    get_status, 
+    "Rotary Mixer", 
+    "High-speed mixer control", 
+    "1.0.0",
+    port=7101
+)
+
+# 3. Define the 'Set Speed' Command
+# Input: One number (Speed)
+input_schema = { "rpm": DeviceSchemaEntry(AresDataType.NUMBER, "Speed in RPM", "RPM") }
+cmd_descriptor = DeviceCommandDescriptor("Set Speed", "Sets mixer speed", input_schema, {})
+
+output_schema = { "rpm": DeviceSchemaEntry(AresDataType.NUMBER, "Speed in RPM", "RPM") }
+get_speed_descriptor = DeviceCommandDescriptor("Get Speed", "Gets mixer speed", {}, output_schema)
+
+# 4. Register the command
+service.add_new_command(cmd_descriptor, set_speed)
+service.add_new_command(get_speed_descriptor, get_speed)
+
+# 5. Start
+service.start()