PyAres 0.1.4__py3-none-any.whl

PyAres/Utils/ares_struct_utils.py

@@ -0,0 +1,208 @@
+from ares_datamodel import ares_struct_pb2
+from typing import Union, Dict
+
+from . import ares_value_utils
+import copy
+
+def ares_struct_to_dict(ares_struct: ares_struct_pb2.AresStruct) -> Dict[str, any]:
+    """Converts an AresStruct protobuf message to a Python dictionary."""
+    return {k: ares_value_utils.ares_value_to_py(v) for k, v in ares_struct.fields.items()}
+
+def ares_string_array_to_list(string_array: ares_struct_pb2.StringArray) -> list[str]:
+    """Convert an Ares String Array protobuf message to a Python list of strings."""
+    return [item for item in string_array.strings]
+
+def ares_number_array_to_list(number_array: ares_struct_pb2.NumberArray) -> Union[list[int], list[float]]:
+    """Convert an Ares String Array protobuf message to a Python list of strings."""
+    return [item for item in number_array.numbers]
+
+def dict_to_ares_struct(py_dict: dict, ares_struct: ares_struct_pb2.AresStruct):
+    """Converts a Python dictionary to an AresStruct protobuf message."""
+    for k, v in py_dict.items():
+        ares_value_utils.py_to_ares_value(v, ares_struct.fields[k])
+
+def create_string_struct(key: str, value: str) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a string initialized using the provided key and value.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (str): The string to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value.
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_string(value)
+    return new_struct
+
+def create_number_struct(key: str, value: Union[int, float]) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with the provided integer or float and key.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (Union[int, float]): The number to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value.
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_number(value)
+    return new_struct
+
+def create_bool_struct(key: str, value: bool) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with the provided bool and key.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (bool): The boolean to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value.
+    """
+
+def create_null_struct(key: str) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a null value initialized using the provided key.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and a null value.
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_null()
+    return new_struct
+
+def create_string_array_struct(key: str, value: list[str]) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a string array initialized using the provided key and value.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (list[str]): The list of strings to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_string_array(value)
+    return new_struct
+
+def create_number_array_struct(key: str, value: list[Union[int, float]]) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a number array initialized using the provided key and value.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (Union[list[int], list[float]]): The list of integers or floats to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_number_array(value)
+    return new_struct
+
+def create_bool_array_struct(key: str, value: list[bool]) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a bool array initialized using the provided key and value.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (list[bool]): The list of bools to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_bool_array(value)
+    return new_struct
+
+def create_bytes_array_struct(key: str, value: bytes) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a new AresStruct with a byte array initialized using the provided key and value.
+
+    Args:
+        key (str): The associated key to be used when storing the given value.
+        value (bytes): The byte array to be stored in the new AresStruct.
+
+    Returns:
+        (AresStruct): A new AresStruct containing the provided key and value
+    """
+    new_struct = ares_struct_pb2.AresStruct()
+    new_struct.fields[key] = ares_value_utils.create_bytes(value)
+    return new_struct
+
+def add_value_to_struct(existing_struct: ares_struct_pb2.AresStruct, key: str, new_value: ares_struct_pb2.AresValue, replace: bool = True) -> ares_struct_pb2.AresStruct:
+    """
+    Adds a provided value to an existing struct, with an optional bool value that determines whether any existing value should be overwritten
+
+    Args:
+        existing_struct (AresStruct): The AresStruct that the new value appended to.
+        key (str): The key to be associated with the new value.
+        new_value (ares_struct_pb2.AresValue): The AresValue that will be added to the provided struct.
+        replace (bool): An optional boolean value that determines whether to overwrite any existing values in your struct.
+    
+    Returns:
+        (AresStruct): The provided struct with the new value appended. 
+    """
+    if replace or key not in existing_struct.fields:
+        new_entry = existing_struct.fields[key]
+        new_entry.CopyFrom(new_value)
+        
+    return existing_struct
+
+def copy_struct(existing_struct: ares_struct_pb2.AresStruct) -> ares_struct_pb2.AresStruct:
+    """
+    Creates a deep copy of an existing AresStruct.
+
+    Args:
+        existing_struct (AresStruct): The struct you want the contents of copied.
+
+    Returns:
+        (AresStruct): A new struct with all the items copied over.
+    """
+    return copy.deepcopy(existing_struct)
+
+def create_ares_struct(key: str, value: any):
+    """
+    Creates a new AresStruct using the provided key and value.
+
+    Args:
+        key (str): The key used to store the first AresValue created in this AresStruct.
+        value (any): The value to be associated with the provided key.
+    
+    Returns:
+        (AresStruct): The newly created AresStruct.
+    """
+
+    if(isinstance(value, str)):
+        return create_string_struct(value)
+    
+    elif(isinstance(value, (int, float))):
+        return create_number_struct(value)
+    
+    elif(isinstance(value, bool)):
+        return create_bool_struct(value)
+    
+    elif(isinstance(value, (list[int], list[float]))):
+        return create_number_array_struct(value)
+    
+    elif(isinstance(value, bytes)):
+        return create_bytes_array_struct(value)
+    
+    elif(isinstance(value, list[str])):
+        return create_string_array_struct(value)
+    
+    elif(isinstance(value, list[bool])):
+        return create_bool_array_struct(value)
+    
+    else:
+        return create_null_struct()
+
+    
+

PyAres/Utils/ares_value_utils.py

@@ -0,0 +1,214 @@
+from ares_datamodel import ares_struct_pb2
+from ares_datamodel import ares_data_type_pb2
+from typing import Union
+
+from . import ares_struct_utils
+from . import ares_data_type_utils
+from ..Models import AresDataType 
+
+def ares_value_to_py(ares_value: ares_struct_pb2.AresValue):
+    """Converts an AresValue protobuf message to a Python native type."""
+    type_map = {
+        "null_value": None,
+        "number_value": ares_value.number_value,
+        "string_value": ares_value.string_value,
+        "bool_value": ares_value.bool_value,
+        "string_array_value": ares_value.string_array_value.strings,
+        "number_array_value": ares_value.number_array_value.numbers,
+        "bytes_value": ares_value.bytes_value
+    }
+    
+    field = ares_value.WhichOneof("kind")
+    if field in type_map:
+        return type_map[field]
+    return None
+
+def py_to_ares_value(py_value, ares_value: ares_struct_pb2.AresValue):
+    """Sets the appropriate field in an AresValue protobuf message from a Python native type."""
+    if isinstance(py_value, str):
+        ares_value.string_value = py_value
+    elif isinstance(py_value, bool):
+        ares_value.bool_value = py_value
+    elif isinstance(py_value, (int, float)):
+        ares_value.number_value = py_value
+    elif isinstance(py_value, bytes):
+        ares_value.bytes_value = py_value
+    elif isinstance(py_value, dict):
+        ares_struct_utils.dict_to_ares_struct(py_value, ares_value.struct_value)
+    elif isinstance(py_value, list):
+        for item in py_value:
+            new_val = ares_value.list_value.values.add()
+            py_to_ares_value(item, new_val)
+    elif py_value is None:
+        ares_value.null_value = 0  # google.protobuf.NullValue.NULL_VALUE
+    else:
+        raise TypeError(f"Unsupported type for AresValue: {type(py_value)}")
+
+def create_number(value: Union[int, float]) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided number value.
+
+    Args:
+        value (Union[int, float]): The integer or float to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided number value.
+    """
+    return ares_struct_pb2.AresValue(number_value=value)
+
+def create_string(value: str) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided string value.
+
+    Args:
+        value (str): The string to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided string value.
+    """
+    return ares_struct_pb2.AresValue(string_value=value)
+
+def create_number_array(value: list[Union[int, float]]) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided list of numbers.
+
+    Args:
+        value (list[Union[int, float]]): The list of numbers to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided list of numbers.
+    """
+    num_array = ares_struct_pb2.NumberArray(numbers=value)
+    return ares_struct_pb2.AresValue(number_array_value=num_array)
+
+def create_string_array(value: list[str]) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided list of strings.
+
+    Args:
+        value (list[str]): The list of strings to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided list of strings.
+    """
+    str_array = ares_struct_pb2.StringArray(strings=value)
+    return ares_struct_pb2.AresValue(string_array_value=str_array)
+
+def create_null() -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to a null value.
+
+    Returns:
+        (AresValue): A new AresValue containing a null value.
+    """
+    return ares_struct_pb2.AresValue(null_value=ares_struct_pb2.NullValue.NULL_VALUE)
+
+def create_bool(value: bool) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided boolean value.
+
+    Args:
+        value (bool): The boolean to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided boolean value.
+    """
+    return ares_struct_pb2.AresValue(bool_value=value)
+
+def create_bytes(value: bytes) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided bytes value.
+
+    Args:
+        value (bytes): The bytes to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided bytes value.
+    """
+    return ares_struct_pb2.AresValue(bytes_value=value)
+
+def create_bool_array(value: list[bool]) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue, initialized to the provided list of booleans.
+
+    Args:
+        value (list[bool]): The list of booleans to be stored in the new AresValue.
+
+    Returns:
+        (AresValue): A new AresValue containing the provided list of booleans.
+    """
+    return ares_struct_pb2.AresValue(bool_array_value=value)
+
+def create_default(python_datatype: AresDataType) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue with a default value for the given AresDataType.
+
+    Args:
+        dataType (ares_data_type_pb2.AresDataType): The data type for which to create a default value.
+
+    Returns:
+        (AresValue): A new AresValue containing the default value.
+    """
+    dataType = ares_data_type_utils.python_ares_type_to_proto_ares_type(python_datatype)
+
+    if(dataType == ares_data_type_pb2.AresDataType.NULL):
+        return create_null()
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.NUMBER):
+        return create_number(0)
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.STRING):
+        return create_string("")
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.BOOLEAN):
+        return create_bool(False)
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.STRING_ARRAY):
+        return create_string_array([])
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.NUMBER_ARRAY):
+        return create_number_array([])
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.BOOL_ARRAY):
+        return create_bool_array([])
+    
+    elif(dataType == ares_data_type_pb2.AresDataType.BYTE_ARRAY):
+        return create_bytes(bytes())
+    else:
+        return create_null()
+    
+def create_ares_value(value: any) -> ares_struct_pb2.AresValue:
+    """
+    Creates a new AresValue using the provided value.
+    If the provided value is not valid for use in an AresValue, a null AresValue is returned.
+
+    Args:
+        value (any): An any that is stored in the newly created AresValue.
+
+    Returns:
+        (AresValue): A new AresValue with the provided value stored.
+    """
+    if(isinstance(value, str)):
+        return create_string(value)
+    
+    elif(isinstance(value, (int, float))):
+        return create_number(value)
+    
+    elif(isinstance(value, bool)):
+        return create_bool(value)
+    
+    elif(isinstance(value, bytes)):
+        return create_bool_array(value)
+    
+    elif(isinstance(value, list)):
+        if all(isinstance(x, (int, float)) for x in value):
+            return create_number_array(value)
+        
+        elif all(isinstance(x, str) for x in value):
+            return create_string_array(value)
+        
+        elif all(isinstance(x, bool) for x in value):
+            return create_bool_array(value)
+    
+    else:
+        return create_null()

PyAres/__init__.py

@@ -0,0 +1,14 @@
+from .Planning import AresPlannerService
+from .Planning import PlanResponse
+from .Planning import PlanRequest
+from .Planning import PlanningParameter
+from .Planning import ParameterHistoryItem
+from .Analyzing import AresAnalyzerService
+from .Analyzing import Analysis
+from .Analyzing import AnalysisRequest
+from .Analyzing import InfoResponse
+from .Device import AresDeviceService
+from .Device import DeviceCommandDescriptor
+from .Device import DeviceSchemaEntry
+from .Models import AresDataType
+from .Models import Outcome

pyares-0.1.4.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: PyAres
+Version: 0.1.4
+Summary: The official Python library for ARES.
+Author-email: AFRL <AFRL.RX.AREScontact@us.af.mil>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AFRL-ARES
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: grpcio-tools>=1.75.1
+Requires-Dist: grpcio<2.0.0,>=1.71.0
+Requires-Dist: ares-datamodel>=0.13.2b1
+Dynamic: license-file

pyares-0.1.4.dist-info/RECORD

@@ -0,0 +1,27 @@
+PyAres/__init__.py,sha256=fw1q1rsLkAPYP170xEwXfJ94tqhk4pqkVUR-7D21HpU,523
+PyAres/Analyzing/__init__.py,sha256=nfsCl1WxhmPNoAl7GOOB8MgRuMo6n52HcA5XxHC4vRU,219
+PyAres/Analyzing/analysis_service.py,sha256=TQLBJDogPOUG9_R2Y_bSYBOb8Kj2iUdytc8LPpl6BlA,12146
+PyAres/Analyzing/analyzer_models.py,sha256=eux-iIIT-fxns92UZiGRaxr1eDhkbraFic-yug1Y7Sc,1783
+PyAres/Device/__init__.py,sha256=NuPbt6feaM9tEwtlLC15gHwP4l91ARtHRkEetF-KD9s,141
+PyAres/Device/device_models.py,sha256=9wk8AhZdMlOBHguAAfxI_1Bc8_mGJWNJeZCg-RDXe4Q,1949
+PyAres/Device/device_service.py,sha256=U5cGcqtav89NPFlUXXb12lEkmBGlL43jWUnVWrapaDE,13082
+PyAres/Device/device_warnings.py,sha256=R-oizQzC150ol_5s-jbMKRKQlo1OPE9OUCX9xUliqLY,51
+PyAres/Models/__init__.py,sha256=-rue6Zb1wND953XI40Yt93TwMa9FwVijfXxw2939IFY,140
+PyAres/Models/ares_data_models.py,sha256=r3bPpImSQEcQNRHILSVpH4a8ITbprvuHctKzuDcAmjk,696
+PyAres/Planning/__init__.py,sha256=7OlkP6MFSOXaACjMHViUSLfT878Ukaz5OH4HHqAk0pc,248
+PyAres/Planning/planner_models.py,sha256=9a9B79dp0BYg2KcVZAFMqXuZltQNc9GbMCaRtMwVJ_E,3622
+PyAres/Planning/planning_service.py,sha256=zrmC7_041JF_EdZ9Bhj7bul7U4qwVF85o8u48f272ic,12620
+PyAres/Test/analyzer_test.py,sha256=tVs3fiEKyAHvSfbA0HZ1nc1hoRehVoo-GyeIDqqJkmM,891
+PyAres/Test/device_test.py,sha256=__9XAAfRLJPRhJOylSje1_Jm72CM8ldHRv216d4XgmQ,1941
+PyAres/Test/planner_test.py,sha256=VM-WD6XKrGOJ9WCPoBakO8Vf19UVN2ASNwIDib2XCOk,2861
+PyAres/Utils/ares_data_schema_utils.py,sha256=-ieU-w3iJnWV6O9ccNYio3lRq61_gfZdPHERhrb-iMo,1697
+PyAres/Utils/ares_data_type_utils.py,sha256=fGGHHuGpXVZyB0dOConTey9TYeJcxkz3Low1jR5bxog,1505
+PyAres/Utils/ares_device_command_utils.py,sha256=8a-vMJFSzvDl9gi60aOG7_mknSN8HmJU-tcGn4glDZc,2046
+PyAres/Utils/ares_outcome_utils.py,sha256=1xrxg557iFDOM4gXekgpXGS4UmAdoTlpPkWPxjnwikU,512
+PyAres/Utils/ares_struct_utils.py,sha256=QFQcuEhUHprNF482vTkkMyB76U-ivg7ofoeK6zRdL4k,7991
+PyAres/Utils/ares_value_utils.py,sha256=g1oav-D1V3vcDcQ3G9rIsdmF9GwdzkXq6gJrW_-gDK4,7455
+pyares-0.1.4.dist-info/licenses/LICENSE,sha256=AcN8QJ8RT55t8sjrZn-qC6NnM-_kxcm6Cv2ctvymVXQ,1066
+pyares-0.1.4.dist-info/METADATA,sha256=p-lPdX4uUzzBQ3PHhS-h6OdOS98_8n12G70YsiJAjGI,405
+pyares-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyares-0.1.4.dist-info/top_level.txt,sha256=wsglLR2yee2009OqgcP2efHcZvvpOq7iMlZVzU77k80,7
+pyares-0.1.4.dist-info/RECORD,,

pyares-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyares-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AFRL-ARES
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyares-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+PyAres